leetcode 1. Two Sum

leetcode 1. Two Sum

Question

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution.

Example

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

问题

给定一个整数数组和一个目标整数，返回两个索引值，使得这两个索引对应的两个数组元素的和为目标数组。假设只有唯一解。

分析

首先想到的肯定是常规的两重遍历法，时间复杂度为O($n^2$)；
倒排索引法(inverted index)：创建一个map，把数组的value作为key，把数组的key作为value。一次遍历数组nums，通过倒排索引的map查找key为target - nums[i]的value j，则[i, j]即为所求索引对；
首尾指针夹逼法：首先将数组排序（注意要保存原索引），然后首尾两个指针分别向中间移动，直到找到符合条件的指针对。

代码

两重遍历法：

vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> ret;
        for (int i = 0; i < nums.size(); i++)
        {
            for (int j = i + 1; j < nums.size(); j++)
            {
                if (nums[i] + nums[j] == target)
                {
                    ret.push_back(i);
                    ret.push_back(j);
                    return ret;
                }
            }
        }
        return ret;
    }

倒排索引法：

vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> ret;
        map<int, int> numsMap;
        for (int i = 0; i < nums.size(); i++)
        {
            if (numsMap.find(target - nums[i]) == numsMap.end())
            {
                numsMap[nums[i]] = i;
            }
            else
            {
                ret.push_back(numsMap[target - nums[i]]);
                ret.push_back(i);
                break;
            }
        }
        return ret;
    }

首尾夹逼法：

    struct Compare
    {
        bool operator() (const pair<int, int> &lhs, const pair<int, int> &rhs)
        {
            return lhs.second < rhs.second;
        }
    };

    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> ret;
        vector<pair<int, int>> numsPair;
        for (int i = 0; i < nums.size(); i++)
        {
            numsPair.push_back({i, nums[i]});
        }
        sort(numsPair.begin(), numsPair.end(), Compare());
        int beg = 0;
        int end = nums.size() - 1;
        while(beg < end)
        {
            int sum = numsPair[beg].second + numsPair[end].second;
            if (sum == target)
            {
                ret.push_back(numsPair[beg].first);
                ret.push_back(numsPair[end].first);
                break;
            }
            else if (sum < target)
            {
                beg++;
            }
            else if (sum > target)
            {
                end--;
            }
        }
        return ret;
    }

复杂度再分析

网上看到很多网友说倒排索引法的时间复杂度是O(n)，我觉得是不对的，应该是O(nlogn)。假设当前进行到第i次循环，numsMap中有i-1个元素，STL map的find操作是O(logn)的复杂度，那么整个循环的复杂度应该是log1 + log2 + log3 + … + log(i-1) >= (i - 1)log(i-1)。
至于首尾夹逼法，由于有排序，所以复杂度也是O(nlogn)。

总结

当需要用value来定位key的时候，需要用倒排索引；
有序序列可以用二分法、首尾指针夹逼法快速查找元素。