求和

主要思想：哈希 双指针
内容：用unordered_map来改善哈希表的性能

5、128. Longest Consecutive Sequence
Given an unsorted array of integers, find the length of the longest consecutive elements sequence.

For example,
Given [100, 4, 200, 1, 3, 2],
The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.
难点在于这道题要求O(n)复杂度的方法

//我使用了Hash，但是爆RE了，内存溢出
int n=nums.size();
int root[1000],val[1000];
for(int i=0;i<1000;i++){
    root[i]=0;val[i]=0;
}
for(int i=0;i<n;i++){
    root[nums[i]]=1;
}
int flag=0;
for(int i=0;i<1000;i++){
    if(root[i]>0){
        flag++;
    }
    else{
        flag=0;
    }
    val[i]=flag;
}
int max=-1;
for(int i=0;i<1000;i++){
    if(val[i]>max) max=val[i];
}
return max;

正确答案用的其实也是hash，不过是STL的

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        unordered_map<int,bool> used;
        int n=nums.size();
        for(auto i : nums) used[i]=false;
        int count=0;
        for(auto i : nums){
            if(used[i]) continue;
            int length=1;
            used[i]=true;
            for(int j=i+1;used.find(j)!=used.end();j++){
                used[j]=true;
                length++;
            }
            for(int j=i-1;used.find(j)!=used.end();j--){
                used[j]=true;
                length++;
            }
            count=max(count,length);
        }
        return count;
    }
};

既然总是使用STL来解决，为什么不自己研究一下如何手写unordered_map
看了一下，是使用由数组引出的链表解决
即先通过hash确认哈希码，然后将这个数据挂在目的位置的最后

---

求和
6、Two Sum
Given nums = [2, 7, 11, 15], target = 9,
Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].
这道题看起来就不像是让你用暴力去解决的。
但是它要求返回下标，所以不能通过排序和左右夹逼（left+right

//于是我想了半天也只想出来一个暴力的
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::vector<int> aim;int n=nums.size();
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                if(nums[i]+nums[j]==target){
                    aim.push_back(i);
                    aim.push_back(j);
                    break;
                }
            }
        }
        return aim;
    }
};

//正确的解决办法应当使用HashMap，每次寻找target-nums[i]是否在这个里面O(1)，这样就可以得到

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> map;
        vector<int> aim;
        int n=nums.size();

        for(int i=0;i<n;i++){
            map[nums[i]]=i;
        }
        for(int i=0;i<n;i++){
            int val=target-nums[i];
            if(map.find(val)!=map.end() && map[val]!=i){
                aim.push_back(i);
                aim.push_back(map[val]);
                break;
            }
        }
        return aim;
    }
};

这里有必要对unordered_map的用法进行一个汇总：
声明：
unordered_map < key,value >map;这里的key和value分别是基础数据类型
map[nums[i]]=i; 赋值语句，将map[key]=value;也就是指定键值对的对应关系
map.find(key) 对某一个值进行查找
if(map.find(key) !=map.end())判断在哈希表里面是否可以找到相应元素