2Sums&3Sums

最新推荐文章于 2022-03-27 19:13:33 发布

waaaaht

最新推荐文章于 2022-03-27 19:13:33 发布

阅读量566

点赞数

分类专栏： leetCode

本文链接：https://blog.csdn.net/u012876995/article/details/48014967

版权

leetCode 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

从来没刷算法题，但是突然感觉这样还是不完整，听从学长建议从leetcode下手，感受了一下2Sums和3Sums，觉得自己算法真是差太多了。。。

从2Sums说起

起手双循环，不出意料超时了，于是开始想可以优化的地方，当时想着要是能把所有的遍历过的值的信息储存起来，就可以遍历一遍了，但是我大概觉得这样换个vector储存好像没用，要找匹配的还是要再遍历。于是就没想法了。上网找答案，第一下找到的就是换个储存地方，比如hashmap这种取数据为常数时间的容器，或者用map这种logn时间的。同时也意识到其实换个容器的本质只是说去查找一个可匹配的队用更好的查找算法(比如二分之类的),由此这一类解法的根本应该是遍历一遍数组，在查找可匹配的数时候用更好的查找算法，从而把时间缩小到(nlogn)甚至接近(n)。

最终做法，起手排序，接循环，循环内部使用其他容器的存放已遍历过的数，然后匹配是通过其他容器(map)的查找来查找，从而优化这个查找时间。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> result;
        vector<int>::iterator it;
        int length = nums.size();
        for(it = nums.begin(); it!= nums.end();){
            if(*it > target) it=nums.erase(it);
            else ++it;
        }
        for(int i=0; i<length-1; i++){
            for(int j=i+1; j<length; j++){
                if(nums[i]+nums[j] == target){
                    result.push_back(i+1);
                    result.push_back(j+1);
                    return result;
                }
            }
        }
        return result;
    }
};

所以，应该自己用二分查找发应该也行吧，埋个坑，日后再填

接着3Sums

起手循环，接2Sums算法，依旧超时(用的c++,据说没有现成的hash的stl容器，所以内部循环其实是nlogn)，其实这个时候可以试试java的hashmap(查找接近常数时间)的算法能不能过，总之用C++得自己实现hash的话觉得实在太麻烦了。于是想了有段时间觉得应该有别的做法的。很无耻的百度。。

这些找一个2sums做法如下:

起手排序，从数组两头遍历，如果和大于target，尾部指针向前移动一位，小于target头部指针向前移动一位。

这种算法对我这种渣渣确实不明显，仔细想想确实没有错误，这种做法的充分利用已排序的这个前提，如果排序的数组仅仅被用作二分，其实很多信息是没有用到的。我想从这个题给我一个思路就是对数组从尾部和头部的双向遍历总能更巧妙的思路，就像快排一样。

其实这道题我起初有这种想法，记得初中有称重实验，有一套规则，比如砝码重了的话，先把最重的砝码换下换第二重的，砝码轻了的话，把最轻的砝码换下，换第二轻的。。但是并没有想到从两头遍历，一点都没有想到这里。最终代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> result;
        int length = nums.size();
        int before = 0;
        for(int i=0; i<length; i++){
            if(nums[i] > 0) break;
            if(i!=0 && nums[i]==before){
                continue;
            }else{
                before = nums[i];
            }
            int target = -nums[i];
                int first = i+1;
                int last = length-1;
                while(first < last){
                    if(nums[first]+nums[last] > target){
                        last --;
                        continue;
                    }else if(nums[first]+nums[last] < target){
                        first ++;
                        continue;
                    }else {
                        vector<int> temp;
                        temp.push_back(nums[i]);
                        temp.push_back(nums[first]);
                        temp.push_back(nums[last]);
                        result.push_back(temp);
                        first ++;
                        last --;
                    }
                }
        }
        //去重
        vector<vector<int>>::iterator iter=unique(result.begin(),result.end());
        result.erase(iter,result.end());
        return result;
    }
};