題目

給你一個整數(shù)數(shù)組 nums 和一個整數(shù) k 。
每一步操作中，你需要從數(shù)組中選出和為 k 的兩個整數(shù)，并將它們移出數(shù)組。
返回你可以對數(shù)組執(zhí)行的最大操作數(shù)。

示例 1：

輸入：nums = [1,2,3,4], k = 5
輸出：2
解釋：開始時 nums = [1,2,3,4]：
- 移出 1 和 4 ，之后 nums = [2,3]
- 移出 2 和 3 ，之后 nums = []
不再有和為 5 的數(shù)對，因此最多執(zhí)行 2 次操作。

示例 2：

輸入：nums = [3,1,3,4,3], k = 6
輸出：1
解釋：開始時 nums = [3,1,3,4,3]：

• 移出前兩個 3 ，之后nums = [1,4,3]
  不再有和為 6 的數(shù)對，因此最多執(zhí)行 1 次操作。

提示：

1 <= nums.length <= 105
1 <= nums[i] <= 109
1 <= k <= 109

解答

V1：暴力法，不用想，肯定超時

class Solution {
public:
    void Swap(int &a, int &b)
    {
        int tmp = a;
        a = b;
        b = tmp;
    }

    int maxOperations(vector<int>& nums, int k) {
        int maxOper = 0;
        for (int i = 0; i < nums.size() - 1; i++) {
            //int m = i + 1;
            for (int j = i + 1; j < nums.size(); j++) {
                if (nums[i] + nums[j] == k) {
                    i++;
                    Swap(nums[i], nums[j]);
                    maxOper++;
                    break;
                }
            }
        }
        return maxOper;
    }
};

V2：使用unordered_multiset

class Solution {
public:
    int maxOperations(vector<int>& nums, int k) {
        int maxOper = 0;
        unordered_multiset<int> numsSet;
        for (int i = 0; i < nums.size(); i++) {
            auto iter = numsSet.find(k - nums[i]);
            if (iter != numsSet.end()) {
                numsSet.erase(iter);
                maxOper++;
            } else {
                numsSet.insert(nums[i]);
            }
        }
        return maxOper;
    }
};

V3：改進，使用map

class Solution {
public:
   int maxOperations(vector<int>& nums, int k) {
       int maxOper = 0;
       unordered_map<int, int> numsMap;
       for (int i = 0; i < nums.size(); i++) {
           auto iter = numsMap.find(k - nums[i]);
           if (iter != numsMap.end()) {
               numsMap[k - nums[i]]--;
               if (numsMap[k - nums[i]] == 0) {
                   numsMap.erase(iter);
               }
               maxOper++;
           } else {
               if (numsMap.find(nums[i]) != numsMap.end()) {
                   numsMap[nums[i]]++;
               } else {
                   numsMap[nums[i]] = 1;
               }

           }
       }
       return maxOper;
   }
};

V4:先排序，再使用雙指針

class Solution {
public:
    int maxOperations(vector<int>& nums, int k) {
        int maxOper = 0;
        sort(nums.begin(), nums.end());
        int i = 0;
        int j = nums.size() - 1 - i;
        while (i < j) {
            if (nums[i] + nums[j] == k) {
                maxOper++;
                i++;
                j--;
            } else if (nums[i] + nums[j] > k) {
                j--;
            } else {
                i++;
            }
        }

        return maxOper;
    }
};

實測結(jié)果：

圖1 實測結(jié)果

結(jié)果是V4最快，為什么呢？按道理一個sort的時間復(fù)雜度就O(nlogn)了，而V2、V3的時間復(fù)雜度似乎只有O(n)，但實際并非如此，V2中使用了unordered_multiset，底層是hash表，insert和erase的時間復(fù)雜度最差是O(1)最差O(n)，V3中使用了map，底層是紅黑樹，insert時間復(fù)雜度是O(nlog)，find的時間復(fù)雜度是O(logn)，erase的時間復(fù)雜度是O(1)。