https://leetcode.cn/problems/max-number-of-k-sum-pairs/

给你一个整数数组 nums 和一个整数 k 。

每一步操作中，你需要从数组中选出和为 k 的两个整数，并将它们移出数组。

返回你可以对数组执行的最大操作数。

示例 1：

输入：nums = [1,2,3,4], k = 5
输出：2
解释：开始时 nums = [1,2,3,4]：

• 移出 1 和 4 ，之后 nums = [2,3]
• 移出 2 和 3 ，之后 nums = [] 不再有和为 5 的数对，因此最多执行 2 次操作。

示例 2：

输入：nums = [3,1,3,4,3], k = 6
输出：1
解释：开始时 nums = [3,1,3,4,3]：

• 移出前两个 3 ，之后nums = [1,4,3] 不再有和为 6 的数对，因此最多执行 1 次操作。

第一种

排序后，双指针

class Solution {
    public int maxOperations(int[] nums, int k) {
        // 排序
        Arrays.sort(nums);
        // 首 尾指针
        int i = 0, j = nums.length - 1;
        int result = 0;
        while (i < j) {
            int sum = nums[i] + nums[j];
            if (sum == k) { 
                // 不需要真移除，只要把两边的指针都挪一位即可。
                i++; j--; // 刚好相等，让两个指针靠近
                result++; // 结果+1
            } else if (sum < k) { // 偏小了，挪动左指针，获得一个更大的数
                i++;
            } else {
                j--; // 偏大了，挪动右指针，获得一个更小的数
            }
        }
        return result;
    }
}

时间复杂度O(nlogn + n)，空间复杂度O(1)。

第二种

遍历，用map缓存数字

class Solution {
    public int maxOperations(int[] nums, int k) {
        int result = 0;

        HashMap<Integer, Integer> map = new HashMap<>();

        for (int num : nums) {
            int target = k - num;
            Integer x = map.get(target);
            if (x != null && x > 0) {
                result++; // 结果+1
                map.put(target, x-1); // target被用过，所以-1
            } else {
                // 没找到合适的数，就暂存当前的num，以便之后使用
                map.put(num, map.getOrDefault(num,0)+1);
            }


        }

        return result;
    }
}

时间复杂度O(n)，空间复杂度O(n)。

本文完