leetcode 1. 两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例：

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

这道题给我们一个数组，还有一个目标数target，让找到两个数字使其和为target，如果用暴力法，遍历两次，时间复杂度O(n^2)，空间复杂度O(1)，这样是不可取的。
为了提高时间复杂度，需要用空间来换，就是说只能遍历一个数字，那么另一个数字呢，可以事先将其存储起来，使用一个 HashMap，来建立数字和其坐标位置之间的映射，在遍历数组的时候，用target减去遍历到的数组，就是另外一个数组了。这时时间复杂度O(n)，空间复杂度O(n)。
两个for循环：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> m;
        vector<int> res;
        for(int i = 0; i < nums.size(); ++i)
        {
            m[nums[i]] = i;
        }
        for (int i = 0; i < nums.size(); ++i)
        {
            int t = target - nums[i];
            if (m.count(t) && m[t] != i)
            {
                res.push_back(i);
                res.push_back(m[t]);
                break;
            }
        }
        return res;
    }
};

简化之后

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> m;
        for (int i = 0; i < nums.size(); ++i)
        {
            if (m.count(target - nums[i]))
            {
                return {i,m[target - nums[i]]};
            }
            m[nums[i]] = i;
        }
        return {};
    }
};

Python版

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        dict = {}
        for index, num in enumerate(nums):
            another_num = target - num
            if another_num in dict:
                return [dict[another_num], index]
            dict[num] = index
        return None