Two Sum & 3Sum & 3Sum Closest & 4Sum

最新推荐文章于 2014-08-03 10:51:07 发布
最新推荐文章于 2014-08-03 10:51:07 发布
阅读量428 收藏
点赞数
分类专栏： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenshente/article/details/22751957
版权

(0) Two Sum (注，这道题最后才发现，所以坐标从0开始)

一开始看觉得好简单直接遍历所有可能不就好了吗，O(n*n)。

 vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> ret;
        int i,j,n=numbers.size();
        
        if(n<2)
            return ret;
        
        for(i=0;i<n-1;i++)
        {
            j=i+1;
            while(j<n){
                if(numbers[i]+numbers[j]==target)
                {
                    ret.push_back(i+1);
                    ret.push_back(j+1);
                    return ret;
                }
                j++;
            }
        }
    }

结果 Time Limit Exceeded。 果然n太大时会超时。

想了想觉得（1）的那种首尾指针时间复杂度会减少（O(nlogn)+O(n)=O(nlogn)），但是这个需要输出坐标的，如果排序之后坐标怎么保存呢，后来搜了搜参考了[4]，巧妙利用了sort()函数第三个可定义判断条件的参数，还需自己新建一个结构体同时保存原来的值和坐标，结构体排序后保持对应不变。

typedef struct node{
    int val;
    int pos;
    }Node;

bool compare(Node a, Node b){
    return a.val<=b.val;
}

class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
         vector<int> ret;
        int i,j,n=numbers.size(),sum;
        vector<Node> tmp(n);
        
        if(n<2)
            return ret;
        
        for(i=0;i<n;i++){
            tmp[i].val=numbers[i];
            tmp[i].pos=i+1;
        }
        
        sort(tmp.begin(),tmp.end(),compare);
        
        i=0;j=n-1;
        while(i<j){
            sum=tmp[i].val+tmp[j].val;
            if(sum==target)
                {
                    ret.push_back(min(tmp[i].pos,tmp[j].pos));
                    ret.push_back(max(tmp[i].pos,tmp[j].pos));
                    return ret;
                }
            else if(sum<target)
                i++;
            else j--;
        }
        }
   
};

Accepted（48ms）。
[2]中还介绍了一个O(n)的方法，很巧妙地利用map的特性。 
class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {

        vector<int> result;
        map<int,int> mapping;
        
        for (int i=0; i<numbers.size(); ++i)
        {
            if (mapping[ target - numbers[i]] > 0)
            {
                result.push_back(mapping[ target - numbers[i]]);
                result.push_back(i+1);               
            }
            else
                mapping[ numbers[i] ] = i+1;
        }
        return result;        
    }
};
Accepted（103ms）。时间反而长了，可能是因为对map的处理（查找，插入）占了比较大的开销。

(1) 3sum

这是一道求三个数为固定值的题，参考到了编程之美中快速寻找符合条件的两个数或者三个数[1]的算法：

先用快速排序对数组排序，让后用双指针（双索引）法对排序好的数组进行反向遍历，并且遍历的方向不变。（若是计算两个数的和，则初始化为i=0,j=n-1，若是计算两个数的差，则初始化为i=0,j=1）。之所以这样遍历方式能成功，是因为排序后，若ai+aj<sum，则ai+ak<sum(k=i,i+1...j)，而i之前j之后的情况已遍历过，所以只有i++才可能有等号的情况；若ai+aj>sum，则ak+aj>sum(k=i,i+1...j)，而i之前j之后的情况已遍历过，所以只有j--才可能有等号的情况。时间复杂度为O(nlogn)+O(n*n)=O(n*n)。

然后就唰唰唰写下第一个版本： 

class Solution { //version 1.0
public:
    vector<vector<int> > threeSum(vector<int> &num) {
        
        vector<vector<int>> ret;
        int i,j,k,n=num.size(),sum;
        
        sort(num.begin(),num.end());
        
        if(n<=2)       
            return ret;        
                
        for( k=0;k<n;k++){
            sum=0-num[k];
            i=k+1;
            j=n-1;
            if(i==j)
                break;
            while(i<j){
            if(num[i]+num[j]==sum)
                {
                    vector<int> tmp;
                    tmp.push_back(num[i]);  
                    tmp.push_back(num[j]);  
                    tmp.push_back(num[k]);  
                    ret.push_back(tmp);
                    i++;
                    j--;
                }
            else if(num[i]+num[j]<sum)
                i++;
            else 
                j--;
            }
        }
        return ret;
    }
};
结果提示： Output Limit Exceeded

后来网上搜了一通参考到[2]，才明白我的输出包含相同的例子，所以输出非常多导致时间超了。

然后改了改...

class Solution {  //version 2.0
public:
    vector<vector<int> > threeSum(vector<int> &num) {
        
        vector<vector<int>> ret;
        int i,j,k,n=num.size(),sum;
        
        sort(num.begin(),num.end());
        
        if(n<=2)
            return ret;
                
        for( k=0;k<n;k++){
            
            if(k > 0 && num[k]==num[k-1])  //过滤相同的k
                continue;  
                
            sum=0-num[k];
            i=k+1;
            j=n-1;
            if(i==j)
                break;
            while(i<j){
                
            if(i>k+1&&num[i]==num[i-1]){   //过滤相同的i
                    i++;  
                    continue;  
                } 
            
            if(j<num.size()-1&& num[j]==num[j+1]){  //过滤相同的j
                    j--;  
                    continue;  
                }  
                
            if(num[i]+num[j]==sum)
                {
                    vector<int> tmp;
                    tmp.push_back(num[k]);  
                    tmp.push_back(num[i]);  
                    tmp.push_back(num[j]);  
                    ret.push_back(tmp);
                    i++;
                    j--;
                }
            else if(num[i]+num[j]<sum)
                i++;
            else 
                j--;
            }
        }
        return ret;
    }
};

Accepted （254ms）!!!

(2) 3sum Closest
这是看起来是（1）的加强版，其实更简单了，只要求符合条件为三个数的和最接近目标数的那个和。算法基本不变，只要先设定好一个初值ret（参考[3]，发现其实一开始随便指定三个数和为ret的初始值就可以了），然后按照（1）的算法每次循环中选出的三个数的和与ret比较谁更接近目标数，更新ret。时间复杂度依旧是O(n*n)。 
class Solution {
public:
    int threeSumClosest(vector<int> &num, int target) {
        
        int i,j,k,n=num.size(),sum,ret,flag=true;
        
        sort(num.begin(),num.end());
        
        if(n<=2)
            return 0;
                
        ret=num[0]+num[1]+num[2];  //ret初始值
        
        for( k=0;k<n;k++){
            
            if(k > 0 && num[k]==num[k-1])  //过滤相同的k
                continue;  
                
            i=k+1;
            j=n-1;
            if(i==j)
                break;
            
            while(i<j){
                
            if(i>k+1&&num[i]==num[i-1]){   //过滤相同的i
                    i++;  
                    continue;  
                } 
            
            if(j<num.size()-1&& num[j]==num[j+1]){  //过滤相同的j
                    j--;  
                    continue;  
                }  
                
            sum=num[i]+num[j]+num[k];   
            
            if(abs(sum-target)<abs(ret-target))
                ret=sum;
                
            if(sum==target)
                return target;
            else if(sum<target)
                i++;
            else 
                j--;
            }
        }
        return ret;
        
    }
};
Accepted （54ms）!!!
（3） 4sum
这个比（1）单纯的多了一维，所以时间复杂度是O(n*n*n)。 
class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
         vector<vector<int>> ret;
        int i,j,k,l,n=num.size(),sum;
        
        sort(num.begin(),num.end());
        
        if(n<4)
            return ret;
         
        for(l=0;l<=n-4;l++){
           if(l > 0 && num[l]==num[l-1])  //过滤相同的l
                continue;  
                
        for( k=l+1;k<=n-3;k++){
            
            if(k > l+1 && num[k]==num[k-1])  //过滤相同的k
                continue;  
                
            sum=target-num[l]-num[k];
            i=k+1;
            j=n-1;
            if(i==j)
                break;
            while(i<j){
                
            if(i>k+1&&num[i]==num[i-1]){   //过滤相同的i
                    i++;  
                    continue;  
                } 
            
            else if(j<num.size()-1&& num[j]==num[j+1]){  //过滤相同的j
                    j--;  
                    continue;  
                }  
                
            else if(num[i]+num[j]==sum)
                {
                    vector<int> tmp;
                    tmp.push_back(num[l]);
                    tmp.push_back(num[k]);  
                    tmp.push_back(num[i]);  
                    tmp.push_back(num[j]);  
                    ret.push_back(tmp);
                    i++;
                    j--;
                }
            else if(num[i]+num[j]<sum)
                i++;
            else 
                j--;
            }
        }
        }
        return ret;
    }
};
Accepted （454ms）!!!

小结：一个晚上刷了四道题真爽 ！！！



参考：
[1] http://blog.csdn.net/linyunzju/article/details/7720413
[2] http://blog.csdn.net/xshalk/article/details/8148422

[3] http://www.cnblogs.com/remlostime/archive/2012/10/27/2742667.html

[4]http://blog.csdn.net/ithomer/article/details/8783952


i_dont_give_a_fxxk
关注
专栏目录
leetcode答案-LeetCode_1_TwoSum:LeetCode_1_TwoSum
06-30
答案LeetCode_1_TwoSum LeetCode 问题：给定一个整数数组，找出两个数字，使它们相加为特定的目标数字。 函数 twoSum 应该返回两个数字的索引，使它们相加为目标，其中 index1 必须小于 index2。 请注意，您返回的...
Coding Interview In Java
04-07
18 3Sum Closest 57 19 String to Integer (atoi) 59 20 Merge Sorted Array 61 ... ... 231 Counting Bits 561 232 Maximum Product of Word Lengths 563 233 Gray Code 565 234 Permutations 567 235 Permutations...
leetcode题库-LeetCode:力码
06-29
leetcode题库 LeetCode 题解合集 本仓库展示了LeetCode题库中部分题目的解法（持续更新），所有代码均采用C++编写...3Sum.cpp 最接近的三数之和 3Sum Closest .cpp 20 有效的括号 Valid Parentheses.cpp 22 括号生成 G
LeetCode 刷题汇总1
08-03
* 3Sum最近（3Sum Closest）：找到数组中三个元素的和最近目标值的元素。 * 4Sum（4Sum）：找到数组中四个元素的和等于目标值的元素。 这些知识点涵盖了算法设计、数据结构、数学运算、字符串操作、链表操作、栈...
程序员面试宝典LeetCode刷题手册
最新发布
05-18
16. 3Sum Closest 17. Letter Combinations of a Phone Number 18. 4Sum 19. Remove Nth Node From End of List 20. Valid Parentheses 21. Merge Two Sorted Lists 22. Generate Parentheses 23. Merge k Sorted ...
Word Ladder I && II
文森的学术之路
07-31 709
(1) Word Ladder BFS(宽度优先搜索)，但是我们可以假想构建一个图，其中图中的每个顶点都是我们的元素，点和点是如何联系起来的呢？如果一个单词通过改变一次字母，能够变成另外一个单词，我们称之为1 edit distance 距离（是不是想起了leetcode中edit distance那道题目了？）所以，图中的所有相邻元素都是edit distance 距离为1的元素。那么，我们只
Pow(x, n)
文森的学术之路
03-26 663
这题顾名思义，要求实现double x的n次方，当然n可正可负。 上路想都不想觉得太简单了然后唰唰唰写了一个最无脑直接分递归版本： //version 1.0 class Solution { public: double pow(double x, int n) { if(n==0) return 1.0;
Evaluate Reverse Polish Notation
文森的学术之路
03-02 660
先付上我的code： class Solution {   public:       int evalRPN(vector &tokens) {           stack tmp;         char t[256];         int opnum3;                  if(tokens.size()==1)         return at
N-Queens && II and Permutations && II && Next Permutation
文森的学术之路
04-26 657
(1) N-Queens 典型的N皇后问题[1]： class Solution { private: void print(int *q, vector> &ret,int n) { vector tmp; for(int i=1;i<=n;i++) { string s(n,'.');
Triangle & Count and Say
文森的学术之路
05-22 609
(1) Triangle  动态规划，从下往上gengx
Best Time to Buy and Sell Stock I & II & III
文森的学术之路
04-08 589
(1) Best Time to Buy and Sell Stock 题目是求数组中shudui
Recover Binary Search Tree & Edit Distance & Reverse Nodes in k-Group
文森的学术之路
06-18 582
(1) Recover Binary Search Tree 这题的要点就是想到使用树的递归中序遍历，因为二叉查找树合法的情况，中序遍历的值是从小到大排列的。 当出现当前值比前一个值小的时候，就是存在不合法的节点。 用pre存中序遍历时当前节点的前一个节点，方便值的大小对比，用s1，s2记录这两个不合法序列的位置，s1存较大的值，s2存较小的值。 最后把两个不合法的值交
Single Number II
文森的学术之路
03-09 569
先附上我的code： class Solution { public: int singleNumber(int A[], int n) { map counter; for(int i=0;i<n;i++) if(counter.find(A[i])==counter.end())
Sudoku Solver & Word Break I && *II
文森的学术之路
07-25 567
(1) Sudoku Solver 注意细节[1]：
Single Number I & II
文森的学术之路
03-16 555
这周才发现原来leetcode有不少题喜欢连着两道（第一道简单，第二道进阶）。上周用了个简单粗暴的遍历方法实现了Single Number II，当时对位运算的方法不屑（现在才发现自己错了，算法的魅力真的很大），今天用一种异或的方法做了I之后发现这要比原来的无脑遍历计数方法要好太多了。 (1) Single Number I： class Solution { public: int
Search a 2D Matrix & Set Matrix Zeroes & Combinations
文森的学术之路
04-25 531
(1) Search a 2D Matrix class Solution { public: bool searchMatrix(vector > &matrix, int target) { int i=0,j=matrix[0].size()-1; while(i=0) {
LRU Cache & Max Points on a Line & Valid Number
文森的学术之路
08-03 531
(1) LRU Cache LRU简洁明了的算法描述[1]，就是用一个双向链表+map，不用map查找的话就要遍历了。。。时间复杂度就上升了。双向链表的好处就是。。。用map定位到那个节点，然后很方便的移动或者删除啊什么的，单向就做不到啦，因为你要删除还要找prev 双向链表就不写了，用stl的list代替
Anagrams
文森的学术之路
03-23 503
国际惯例先附上我的代码： class Solution { public: vector anagrams(vector &strs) { vector ret; vector tmpstrs=strs; unordered_multimap hash; unordered_multimap::iterator it;
Search Insert Position
文森的学术之路
03-24 502
第一眼看题目的时候心里一声： “卧槽，这么简单，直接循环遍历比较一次不就得了么” 然后唰唰唰地写完然后妥妥地Accepted了 class Solution { //runtime: 54ms public: int searchInsert(int A[], int n, int target) { if(target<A[0])
leetcode热题100刷题顺序
03-30
16. 3Sum Closest 17. Letter Combinations of a Phone Number 18. 4Sum 19. Remove Nth Node From End of List 20. Valid Parentheses 21. Merge Two Sorted Lists 22. Generate Parentheses 23. Swap Nodes in ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值