leetcode 167

167. 两数之和 II - 输入有序数组

给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列  ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。

以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

你所设计的解决方案必须只使用常量级的额外空间。

 

示例 1：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。

示例 2：

输入：numbers = [2,3,4], target = 6
输出：[1,3]
解释：2 与 4 之和等于目标数 6 。因此 index1 = 1, index2 = 3 。返回 [1, 3] 。

示例 3：

输入：numbers = [-1,0], target = -1
输出：[1,2]
解释：-1 与 0 之和等于目标数 -1 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。

提示：

• 2 <= numbers.length <= 3 * 104
• -1000 <= numbers[i] <= 1000
• numbers 按 非递减顺序 排列
• -1000 <= target <= 1000
• 仅存在一个有效答案

第一反应用了哈希表，我们先遍历一遍数组，把这些数加入到哈希表中，哈希表的键为数组的值，哈希表的值为数组的id。当遍历一个数的时候，我们直接使用哈希表判断target - numbers[i] 是否在哈希表中（注意重复性），这能解决两个值不同的数的和是target的问题。这是一种情况。

另外新建一个哈希表，记录每个数出现的次数，若target是偶数，查看target/2在这个哈希表中出现的次数，如果是两次，这是另外一种情况。

代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {

        std::unordered_map<int,int> numbers_hash;
        for (int i = 0; i < numbers.size(); i++)
        {
            numbers_hash[numbers[i]] = i + 1;
        }

        vector<int> res;
        for (const auto& v : numbers_hash)
        {
            int other_value = target - v.first;
            if (numbers_hash.count(other_value))
            {
                res = { v.second,numbers_hash[other_value] };
            }
        }
        

        std::unordered_map<int, int> repeat_number;
        for (int i = 0; i < numbers.size(); i++)
        {
            if (repeat_number.count(numbers[i]))
            {
                repeat_number[numbers[i]]++;
            }
            else
            {
                repeat_number[numbers[i]] = 1;
            }
        }

        if (target % 2 == 0)
        {
            int value = target / 2;
            if (repeat_number.count(value)&& repeat_number[value]>1)
            {
                res = { numbers_hash[value] - 1,numbers_hash[value] };
            }
        }

        std::sort(res.begin(), res.end());

        return res;
    }

};

速度和内存占用都是5%

确实可以通过，但存在以下问题：第一空间占用偏大，多开辟了连个哈希表，第二没有应用到数组的有序性。

另外一种巧妙的解法，是双指针法：

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {

        vector<int> res;
        int front = 0, back = numbers.size() - 1;
        while (front < back)
        {
            if (target == numbers[front] + numbers[back]) //找到目标后退出
            {
                res = { front+1,back+1 };
                break;
            }
            else if (target > numbers[front] + numbers[back]) //如果两个数比target小，前面的指针后移
            {
                front++;
            }
            else // 否则后面的指针前移
            {
                back--;
            }

        }
        return res;
    }

};

速度和内存都是击败 60%以上