Given a sorted array of non-negative integers, find the smallest positive integer that is not the sum of a subset of the array.

For example, for the input [1, 2, 3, 10], you should return 7.

Do this in O(N) time.

A naive solution would be to start with 1 and keep incrementing until we find a solution. However, since the problem of determining whether a subset of an array sums to a given number is NP-complete, this approach cannot succeed in linear time. 

There is a pesudo polynomial solution with dynamic programming for the subset sum problem.  This is still not real linear time as the target can be pretty big.

O(N) solution

1. Initialize the smallest impossible sum to be 1.

2. Iterate through the input array, for each element, do the following:

2(a). if a[i] <= smallest impossible sum, increment the smallest impossible sum by a[i];

2(b). if a[i] > smallest impossible sum, return smallest impossible sum;

Why does this alogrithm work? 

At any given point of smallest impossible sum k, we know we already can make any non-negative sum from 0 to k – 1. As long as a[i] <= k, we can get k, k + 1, k + 2,….. k – 1 + a[i], and the smallest impossible sum becomes k – 1 + a[i] + 1. However, if a[i] > k, then we can only get 1, 2,…. k – 1, a[i], a[i] + 1, a[i] + 2, ….., a[i] + k – 1. Since a[i] > k, there is a gap! k is the smallest positive integer that is not covered by any subset sum.

public int smallestPositiveInteger(int[] a) {
    if(a == null || a.length == 0) {
        return 1;
    }
    int impossible_sum = 1;
    for(int i = 0; i < a.length; i++) {
        if(a[i] <= impossible_sum) {
            impossible_sum += a[i];
        }
        else {
            break;
        }
    }
    return impossible_sum;
}