[LeetCode] 1539. Kth Missing Positive Number

Given an array arr of positive integers sorted in a strictly increasing order, and an integer k.

Find the kth positive integer that is missing from this array.

Example 1:

Input: arr = [2,3,4,7,11], k = 5
Output: 9
Explanation: The missing positive integers are [1,5,6,8,9,10,12,13,...]. 
The 5th missing positive integer is 9.

Example 2:

Input: arr = [1,2,3,4], k = 2
Output: 6
Explanation: The missing positive integers are [5,6,7,...]. 
The 2nd missing positive integer is 6.

Constraints:

• 1 <= arr.length <= 1000
• 1 <= arr[i] <= 1000
• 1 <= k <= 1000
• arr[i] < arr[j] for 1 <= i < j <= arr.length

第K個缺失的正整數。

題意是給一個升序的數組和一個數字K，請返回第K個缺失的正整數。這道題和1060題是一模一樣，但是這道題是easy的原因在於數據范圍很小，nums[i] 只到1000。

這道題有好幾種解法，我這里都列出來。分別是暴力解，線性解和二分法。

首先是暴力解，用一個指針掃描input數組，去看每一個位置上的數字是否是要找的數字target。一開始target = 1，意思是從1開始找，如果能在input數組中找到每個正整數，則接着往后遍歷；但凡有一個正整數找不到，就把這個缺失的正整數加到一個list中，直到這個list的size達到K。但是也有可能list沒有到K，input數組就遍歷完了，此時可以把缺失的整數用一個while循環模擬完。

時間O(n)

空間O(n)

Java實現

class Solution {
    public int findKthPositive(int[] arr, int k) {
        int target = 1;
        int i = 0;
        List<Integer> missingOnes = new ArrayList<>();
        while (i < arr.length) {
            // if the target number is found
            if (arr[i] == target) {
                i++;
                target++;
            }
            // if it's not found
            else {
                missingOnes.add(target);
                target++;
            }
        }
        int size = missingOnes.size();
        int count = size;
        int lastNumber = (missingOnes.size() == 0) ? arr[arr.length - 1]
                : Math.max(arr[arr.length - 1], missingOnes.get(missingOnes.size() - 1));
        if (count >= k) {
            return missingOnes.get(k - 1);
        } else {
            while (count < k) {
                lastNumber++;
                count++;
            }
            return lastNumber;
        }
    }
}

 

一個比較優化的線性解法是，因為題目給的是一個升序的正整數數組，而且數組理論上是從1開始。所以理想情況下，數字nums[i]和它對應的下標i的關系應該是nums[i] = i + 1。所以在掃描input數組的時候，如果發覺數字和他對應的下標的差大於1了，則說明中間開始缺失數字了。當這個差距大於等於K的時候，則找到了第K個缺失的數字。

時間O(n)

空間O(1)

Java實現

class Solution {
    public int findKthPositive(int[] arr, int k) {
        int len = arr.length;
        for (int i = 0; i < len; i++) {
            if (arr[i] - i - 1 >= k) {
                return k + i;
            }
        }
        return k + len;
    }
}

 

二分法。因為input數組是有序的，所以如果面試官不滿意O(n)級別的思路的話，可以試圖往二分法上靠。mid找到中點，還是跟第二種做法類似，比較當前這個index上的數字和index的差值。如果差值小於K，則往數組的右半邊找；反之則往數組的左半邊找。

時間O(logn)

空間O(1)

Java實現一，right 指針一開始在數組范圍外

class Solution {
    public int findKthPositive(int[] arr, int k) {
        int left = 0;
        int right = arr.length;
        int mid = 0;
        while (left < right) {
            mid = left + (right - left) / 2;
            if (arr[mid] - mid >= k + 1) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return left + k;
    }
}

 

Java實現二，right 指針一開始在數組范圍內。因為 right = nums.length - 1，mid 指針能碰到的范圍是在 [left, right] 之間，所以當 mid 不滿足判斷條件的時候，left = mid + 1，right = mid - 1。

class Solution {
    public int findKthPositive(int[] arr, int k) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            int missing = arr[mid] - mid - 1;
            if (missing < k) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return left + k;
    }
}

 

JavaScript實現一

/**
 * @param {number[]} arr
 * @param {number} k
 * @return {number}
 */
var findKthPositive = function (arr, k) {
    let start = 0;
    let end = arr.length - 1;
    while (start <= end) {
        let mid = start + Math.floor((end - start) / 2);
        let missing = arr[mid] - mid - 1;
        if (missing < k) {
            start = mid + 1;
        } else {
            end = mid - 1;
        }
    }
    return start + k;
};

 

JavaScript實現二

/**
 * @param {number[]} arr
 * @param {number} k
 * @return {number}
 */
var findKthPositive = function (arr, k) {
    let start = 0;
    let end = arr.length;
    while (start < end) {
        let mid = start + Math.floor((end - start) / 2);
        let missing = arr[mid] - mid - 1;
        if (missing < k) {
            start = mid + 1;
        } else {
            end = mid;
        }
    }
    return start + k;
};

 

相關題目

410. Split Array Largest Sum

774. Minimize Max Distance to Gas Station

875. Koko Eating Bananas

1011. Capacity To Ship Packages In N Days

1060. Missing Element in Sorted Array

1231. Divide Chocolate

1283. Find the Smallest Divisor Given a Threshold

1482. Minimum Number of Days to Make m Bouquets

1539. Kth Missing Positive Number

LeetCode 題目總結