LeetCode

First Missing Positive

2014.2.8 23:43

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.

Solution1:

　　The first solution I thought of was hashing, using unordered_map. This promises O(n) time, but not constant space.

　　Solution is simple and runs in one pass. I guess the code can explain itself.

　　Time and space complexities are both O(n).

Accepted code:

// 1AC, unordered_map is a good substitute for map
#include <unordered_map>
using namespace std;

class Solution {
public:
    int firstMissingPositive(int A[], int n) {
        if (A == nullptr || n <= 0) {
            return 1;
        }
        
        unordered_map<int, int> um;
        int result;
        int i;
        
        result = 1;
        for (i = 0; i < n; ++i) {
            if (A[i] > result) {
                um[A[i]] = 1;
            } else if (A[i] < result) {
                continue;
            } else {
                um[result] = 1;
                ++result;
                while (um.find(result) != um.end()) {
                    ++result;
                }
            }
        }
        
        um.clear();
        return result;
    }
};

Solution2:

　　The last solution used hashing, thus cannot satisfy the constraint on space usage.

　　Note that there're n integers in [1, n], if there exists some A[i] out of this range, one of the positive integers from [1, n] must be missing, which is the answer we're looking for. If no such A[i] exists, (n + 1) will be the first missing positive integer.

　　Since we care only about positive integers, we can use "-" sign to mark a position, as a way of hashing. If we mark A[i] as minus, it means the positive number i has already appeared. You don't have to worry about i going out of range, because the size of the hash table is exactly n. The array itself serves as the hash table, while the sign of each element is used for hashing, whereas their absolute values are preserved.

　　Time complexity is O(n). Space complexity is O(1).

Accepted code:

// 1CE, 1AC, this solution is very tricky, hope it would inspire you.
class Solution {
public:
    int firstMissingPositive(int A[], int n) {
        if (A == nullptr || n <= 0) {
            return 1;
        }
        
        int i;
        for (i = 0; i < n; ++i) {
            if (A[i] <= 0) {
                A[i] = n + 1;
            }
        }
        
        int tmp;
        for (i = 0; i < n; ++i) {
            if (myabs(A[i]) <= n) {
                // think about why we care about values between [1, n]
                tmp = myabs(A[i]);
                // the array itself serves as a hash table of size n.
                // setting it to minus means occupying this position.
                A[tmp - 1] = -myabs(A[tmp - 1]);
            }
        }
        
        for (i = 0; i < n; ++i) {
            if (A[i] > 0) {
                return (i + 1);
            }
        }
        // this array consists of [1, n].
        return (n + 1);
    }
private:
    int myabs(const int x) {
        return (x >= 0 ? x : -x);
    }
};