【LeetCode】1. Two Sum

Two Sum

Given an array of integers, find two numbers such that they add up to a specific target number.

The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.

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

Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2

首先，不能对该数组作任何预处理。因为要求返回是原始数组的下标，如果对数组进行了排序，那么下标就会乱。

（如果是有序数组，可以用双指针来做，参见Two Sum II - Input array is sorted）

很容易想到用<value, index>的映射表。

遍历numbers，在映射表中寻找target-numbers[i].

若找到则结束，返回存储的下标+1和当前下标+1. （注意题目中规定，以1作为起始下标）

若找不到则将<numbers[i], i>加入映射表。

这里又有一个问题，C++中常用的映射表有map, unordered_map。

根据http://www.cplusplus.com/reference/上面的说明我们来比较差异：

map:

Internally, the elements in a map are always sorted by its key following a specific strict weak ordering criterion indicated by its internal comparison object (of type Compare).

map containers are generally slower than unordered_map containers to access individual elements by their key, but they allow the direct iteration on subsets based on their order.

map::operator[]:

Logarithmic in size.

unordered_map:

Internally, the elements in the unordered_map are not sorted in any particular order with respect to either their key or mapped values, but organized into buckets depending on their hash values to allow for fast access to individual elements directly by their key values (with a constant average time complexity on average).

unordered_map containers are faster than map containers to access individual elements by their key, although they are generally less efficient for range iteration through a subset of their elements.

unordered_map::operator[]:

Average case: constant.
Worst case: linear in container size.

本题只需要根据key访问单个元素，因此unordered_map更合适。

时间复杂度O(n)：一次遍历

空间复杂度O(n)：unordered_map

ps: 严格来说，target-numbers[i]可能溢出int，因此提升为long long int更鲁棒。

class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> ret(2,-1);
        unordered_map<int, int> m;    //value->index map
        for(int i = 0; i < numbers.size(); i ++)
        {
            if(m.find(target-numbers[i]) == m.end())
            //target-numbers[i] not appeared
                m[numbers[i]] = i;
            else
            {
                ret[0] = m[target-numbers[i]]+1; 
                ret[1] = i+1;
                return ret;
            }
        }
    }
};