[Leetcode] 128, 16, 18

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.

Your algorithm should run in O(n) complexity.

Solution: 哈希表存储后，两头查询。

快排的时间复杂度是O(nlogn)，但此题要求O(n)，因此此题不能进行排序操作。

但是，排序算法中有一个很特别的算法，时间复杂度也仅为O(n)：

假设需要排序的数据是整数且范围是有限的0<=x<=max，那么可以建立一个数组x[0]-x[max]，初始化为0，遍历无序数组a，然后将x[an]++，这样就能在O(n)的时间复杂度内进行排序。

此题数据为整数，但是没有给出范围，因此不能使用这种排序算法，但是可以将其进行变体，使用unordered_map来存储，然后对于一个数据向两头查找，就能够得到包含它的最长连续序列。

Note:map和unordered_map对比。

map和unordered_map的使用方法类似，但是实现方式不同，导致性能有差异：

map使用红黑树实现，unordered_map使用哈希表实现。

map内部是有序的，每次插入和查询的复杂度均为logn。

但我查到的资料对于unordered_map的性能有不同的说法，unordered_map的查询操作是公认的快，但是插入操作有说比map慢，也有说比map快。但就哈希表的特性和这题解法来说，用unordered_map进行插入操作时间复杂度应该在O(1)才对，但是鉴于我不清楚unordered_map具体的实现细节，可能也有待补充的地方。（待查）

Code:

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        unordered_map<int,bool> m;
        for(auto i:nums) m[i] = false; //遍历的简化写法，auto：自动判断变量类型
        
        int maxlength = 0;
        for(auto i:nums){
            
            if(m[i]==true) continue;
            else{
                
                int min = i;
                int max = i;
                
                int length = 1;
                int end = false;
                while(!end){
                    end = true;
                    if(m.find(min-1)!=m.end()){
                        m[min-1] = true;
                        min--;
                        length++;
                        end = false;
                    }
                    if(m.find(max+1)!=m.end()){
                        m[max+1] = true;
                        max++;
                        length++;
                        end = false;
                    }
                }
                if(maxlength<length) maxlength = length;
            }
        }
        
        return maxlength;
    }
};

16. 3Sum Closest

Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.

Solution: 排序之后，夹逼（不需要遍历）

Code:

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        
        int cloSum = nums[0] + nums[1] + nums[2];
        for(auto a = nums.begin(); a<prev(nums.end(),2); 
            a = upper_bound(a,prev(nums.end(),2),*a)){//得到下一个不重复的a值
            auto b = next(a);
            auto c = prev(nums.end());
                
            while(b<c){
                int sum = *a + *b + *c;
                
                if(abs(sum-target)<abs(cloSum-target)){
                    cloSum = sum;
                }
                
                if(sum<target) b++;
                else c--;
            }
            
        }
        
        return cloSum;
    }
};

18. 4Sum

Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.

Note: The solution set must not contain duplicate quadruplets.

Solution: 排序之后，两层遍历之后夹逼（不需要遍历）

Code:

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        
        vector<vector<int>> result;
        if(nums.size()<4) return result;
        
        sort(nums.begin(), nums.end());
        
        
        for(auto a = nums.begin(); a<prev(nums.end(), 3); 
           a = upper_bound(a, prev(nums.end(), 3), *a)){
            int t = target - *a;
            for(auto b = next(a); b<prev(nums.end(),2); 
               b =upper_bound(b, prev(nums.end(),2), *b)){
                auto c = next(b);
                auto d = prev(nums.end());
                
                while(c<d){
                    int sum = *b + *c + *d;
                    if(sum==t){
                        vector<int> r;
                        r.push_back(*a);
                        r.push_back(*b);
                        r.push_back(*c);
                        r.push_back(*d);
                        result.push_back(r);
                        c = upper_bound(c, prev(nums.end()), *c);
                    }else if(sum>t){
                        d = prev(d);
                    }else if(sum<t){
                        c = next(c);
                    }
                }
                
            }
            
        }
        
        return result;
    }
};

 

Add to List

18. 4S