[Leetcode 96] 41 First Missing Positive

Problem:

Given an unsorted integer array, find the first missing positive integer.

For example,
Given [1,2,0] return 3,
and [3,4,-1,1] return 2.

Your algorithm should run in O(n) time and uses constant space.

 

Analysis:

At first thought, hash table can be used in this problem. First hash all the numbers in the given array with O(n) time complexity, then search from 1 until the first missing positive number which also takes O(n) time complexity. But the requirement only allows constant space, so this is not good enough. And the way we can solve the problem is to use some in-place method.  The method is as follows: everytime, swap the current element with value a with the A[a-1] place. Thus, A[0] stores 1, A[1] stores 2, etc. After the swap, if the new element in this palce is less than or equal to 0 or happened to be the element should be here, then we move to the next position, else we continue to swap at this position.

The skip condition is as follows: 1. A[i] <=0; 2. A[i] == i+1; 3. A[i] >= n; 4. A[i] == A[A[i]-1] 

 

Code:

Hashtable Version:

class Solution {
public:
    int firstMissingPositive(int A[], int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        unordered_set<int> us;
        
        for (int i=0; i<n; i++) {
            us.insert(A[i]);
        }

        int ms=1;
        while (ms <= n) {
            if (us.find(ms) == us.end())
                return ms;
            
            ms++;
        }

        return ms;
    }
};

 

Swap Version:

class Solution {
public:
    int firstMissingPositive(int A[], int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int tmp;
        
        for (int i=0; i<n; ) {
            if (A[i] > 0 && A[i] != i+1 && A[i] < n) {
                tmp = A[A[i]-1];
                A[A[i]-1] = A[i];
                A[i] = tmp;
            }
            
            if (A[i] <= 0 || A[i] == i+1 || A[i] == A[A[i]-1] || A[i] >=n)
                i++;
        }
        
        int i=0;
        while (i<n) {
            if (A[i] != i+1)
                return i+1;

            i++;
        }
                
        return i+1;
    }
};