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(n2)；

倒排索引法(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的时候，需要用倒排索引；

有序序列可以用二分法、首尾指针夹逼法快速查找元素。