Leetcode 1 两数之和

更加丰富内容可查看我的个人博客：xukang’s blog

对于这道题，首先题目给出一个注意点：一个数只能用一次！但是并不代表数组没有重复元素！

所以这算是这道题需要考虑的另一个注意点：重复元素怎么办？

map存储只能存储一个是否对这道题有用呢？

这道题虽然看似简单，但是有一些细节的地方需要考虑清楚，在leetcode评论区，我发现好多人都没有真正理解两遍hash和一遍hash这两种方法，还有人甚至理解不能重复使用元素就是没有重复元素！

方法1、暴力法

最简单也很容易想到，但是时间复杂度很高！ O(N^2)

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
      	vector<int> res;
       	for (int i = 0; i < nums.length; i++) {
          	//j = i + 1  不能重复使用
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[j] == target - nums[i]) {
                    res.push_back(i);
                  	res.push_back(j);
                  	return res;
                }
            }
        }
      	return res;
    }
};

方法2、双指针

刚看到这道题，我的第一想法是双指针！先排序然后双指针，用map存储下标！

但是发现问题并没有我想得那么容易，重复问题需要仔细考虑！这里如果用map存储下标，我解决不了重复问题，从而弃用map！直接拷贝一份，在副本中查找，因为重复元素在排序后的先后顺序是不变的！

时间复杂度 O(NlogN)

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
      	//拷贝一份
        vector<int> tmp(nums);
      	//排序O(NlongN)	
        sort(nums.begin(), nums.end());  
      	//双指针
        int i = 0;
        int j = nums.size() - 1;
        while (i < j) {
            if (nums[i] + nums[j] < target) i++;
            if (nums[i] + nums[j] > target) j--;
            if (nums[i] + nums[j] == target) break;
        }
      
        vector<int> res;
        if (i == j) return res;
        for (int k = 0; k < nums.size(); k++) {
            if (tmp[k] == nums[i]) {
                res.push_back(k);
                break;
            }
        }
        for (int k = 0; k < nums.size(); k++) {
          	// k != res[0], 下标不能一样，每个元素只能使用一次
            if (tmp[k] == nums[j] && k != res[0]) { 
                res.push_back(k);
                break;
            }
        }
        return res;
    }
};

方法3、两遍hash表

在第一次迭代中，我们将每个元素的值和它的索引添加到hash表中。

在第二次迭代中，我们将检查每个元素所对应的目标元素（target−nums[i]）是否存在于表中。注意，该目标元素不能是
nums[i] 本身！

1. 是否解决重复元素的问题！

因为每次网hash表中添加元素的时候，重复元素会覆盖之前的下标。仔细体会！！！

2. 复杂度分析：
   • 时间复杂度：O(N)，
     我们把包含有 N 个元素的列表遍历两次。由于哈希表将查找时间缩短到
     O(1) 所以时间复杂度为 O(N)。
   • 空间复杂度：O(N)，
     所需的额外空间取决于哈希表中存储的元素数量，该表中存储了
     N 个元素。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map<int, int> my_map;
        for (int i = 0; i < nums.size(); i++) 
            my_map.insert(pair<int, int>(nums[i], i));
        for (int i = 0; i < nums.size(); i++) {
          	// my_map[target - nums[i]] != i  不能重复使用
            if (my_map.count(target - nums[i]) && my_map[target - nums[i]] != i) {
                return vector<int>{i, my_map[target - nums[i]]};
            }
        }
        return vector<int>();
    }
};

方法4、一遍hash表

1. 怎么理解一边hash？
   • 可以将两遍hash合成一边hash，因为很容易发现两遍hash，在第二遍hash查找的过程中每次查找都是在整个数组范围内查找，虽然查找的时间复杂度为O(1) ，但是还可简化！！！
   • 其实就是对暴力搜索的直接优化! 理解暴力搜索即可！
2. 注意如何解决重复使用问题

其实跟暴力搜索一样，每次搜索的返回不包括本身！

3. 是否解决重复元素的问题！

同样能解决重复问题

4. 复杂度分析：
   • 时间复杂度：O(N)，
     我们只遍历了包含有 N个元素的列表一次。在表中进行的每次查找只花费O(1) 的时间。
   • 空间复杂度：O(N)，
     所需的额外空间取决于哈希表中存储的元素数量，该表中存储了
     N 个元素。

/*
//暴力搜索的另一种写法！
vector<int> twoSum(vector<int>& nums, int target) {
        for (int i = 0; i < nums.size(); i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] + nums[j] == target)
                    return vector<int>{i, j};
            }
        }
        return vector<int>{};
    } 
 */

vector<int> twoSum(vector<int>& nums, int target) {
        map<int, int> my_map;
        for (int i = 0; i < nums.size(); i++) {
            int complement = target - nums[i];
            if (my_map.count(complement)) {
                return vector<int>{i, my_map[complement]};
            } else {
                my_map[nums[i]] = i;
            }
        }
        return vector<int>();
    }