LeetCode 015 3Sum

最新推荐文章于 2019-06-12 14:02:47 发布
最新推荐文章于 2019-06-12 14:02:47 发布
阅读量406 收藏
点赞数
分类专栏： LeetCode 文章标签： LeetCode C++ 3Sum
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lizi_stdio/article/details/53782882
版权
15. 3Sum

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

Note: The solution set must not contain duplicate triplets.

For example, given array S = [-1, 0, 1, 2, -1, -4],

A solution set is:
[
  [-1, 0, 1],
  [-1, -1, 2]
]
class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
    }
};
解题思路：
  • 自己的解题思路
一开始打算用两个指针技术，进行求解。但是遇到 “ 下一步怎么走 “ 问题。
最后用了一个重复查询的方法，进行搜索。
  • 别人的解题思路
别人用的两个指针技术与我的不同，他是先确定一点，然而左右搜。我的则是先确定前后两点，然后再确定一点。
学习收获：
  • 对于不重复的，可以采用 pre-check 技术，直接转到下一个不重复的值。
  • 知道 reserve() 对运行时间的影响
  • 熟悉了 unique(),resize(),distance()[ 在 <iterator> 里面 ], 以及 erase() 操作。
  • 对于 vector 的 erase()    只改变 size, 而且分 2 个版本： (1) 删除 1 个值  (2) 删除一个区间。
//操作1
auto   it   =   unique ( res . begin (),   res . end ());
     res . resize ( distance ( res . begin (),   it ));
    //操作2
auto   it   =   unique ( res . begin (),   res . end ());
res . erase ( it ,   res . end ());
附件：程序
1 、自己的程序：
版本 1 ：运用下标，进行搜索
vector < vector < int >>   threeSum ( vector < int >&   nums )
{
     bool   myComp ( vector < int >   &   a ,   vector < int >   &   b );
     sort ( nums . begin (),   nums . end ());
     vector < int >   temp ( 3 );
     vector < vector < int >>   res ;
     auto   size   =   nums . size ();
     if ( size   >=   3 )
     {
         decltype ( size )   st   =   0 ;
         decltype ( size )   ed   =   size   -   1 ;
         while (( ed   -   st )   >=   1   &&   nums [ st ]   <=   0   &&   nums [ ed ]   >=   0 )
         {
             while (( ed   -   st )   >=   1   &&   nums [ ed ]   >=   0 )
             {
                 int   wt   =   -( nums [ st ]   +   nums [ ed ]);
                 auto   mid   =   find ( nums . begin ()   +   st   +   1 ,   nums . begin ()   +   ed ,   wt );
                 if ( mid   !=   nums . begin ()   +   ed )
                 {
                     temp [ 0 ]   =   nums [ st ];
                     temp [ 1 ]   =   * mid ;
                     temp [ 2 ]   =   nums [ ed ];
                     res . push_back ( temp );
                 }
                 -- ed ;
             }
             while (( ed   -   st )   >=   1   &&   nums [ st ]   ==   nums [ st   +   1 ])
             {
                 ++ st ;
             }
             ++ st ;
             ed   =   size   -   1 ;
         }
     }
     auto   it   =   unique ( res . begin (),   res . end ());
     res . resize ( distance ( res . begin (),   it ));
     return   res ;
}
改进版 1 ：改进后的程序，不再需要 unique() 操作
vector < vector < int >>   threeSum ( vector < int >&   nums )
{
     bool   myComp ( vector < int >   &   a ,   vector < int >   &   b );
     sort ( nums . begin (),   nums . end ());
     vector < int >   temp ( 3 );
     vector < vector < int >>   res ;
     res . reserve ( 100 );
     auto   size   =   nums . size ();
     if ( size   >=   3 )
     {
         decltype ( size )   st   =   0 ;
         decltype ( size )   ed   =   size   -   1 ;
         while (( ed   -   st )   >=   1   &&   nums [ st ]   <=   0   &&   nums [ ed ]   >=   0 )
         {
             while (( ed   -   st )   >=   1   &&   nums [ ed ]   >=   0 )
             {
                 int   wt   =   -( nums [ st ]   +   nums [ ed ]);
                 auto   mid   =   find ( nums . begin ()   +   st   +   1 ,   nums . begin ()   +   ed ,   wt );
                 if ( mid   !=   nums . begin ()   +   ed )
                 {
                     temp [ 0 ]   =   nums [ st ];
                     temp [ 1 ]   =   * mid ;
                     temp [ 2 ]   =   nums [ ed ];
                     res . push_back ( temp );
                 }
                 while (( ed   -   st )   >=   1   &&   nums [ ed ]   ==   nums [ ed   -   1 ])
                 {
                     -- ed ;
                 }
                 -- ed ;
             }
             while (( ed   -   st )   >=   1   &&   nums [ st ]   ==   nums [ st   +   1 ])
             {
                 ++ st ;
             }
             ++ st ;
             ed   =   size   -   1 ;
         }
     }
     return   res ;
}
版本 2 ：运用迭代器，进行搜索
vector < vector < int >>   threeSum ( vector < int >&   nums )
{
     vector < vector < int >>   res ;
     if ( nums . size ()   <   3 )
     {
         return   res ;
     }
     sort ( nums . begin (),   nums . end ());
     auto   p   =   nums . begin ();
     auto   q   =   nums . begin ()   +   1 ;
     for (;   p   <   nums . end ()   -   1 ;)
     {
         while ( q   !=   nums . end ())
         {
             int   toFind   =   -(* p   +   * q );
             auto   pos   =   find ( q   +   1 ,   nums . end (),   toFind );
             if ( pos   !=   nums . end ())
             {
                 res . push_back ({   * p ,   toFind ,   * q   });
             }
             if ( toFind   <   0 )
             {
                 break ;
             }
             else
             {
                 auto   pre_q   =   q   +   1 ;
                 while ( pre_q   !=   nums . end ()   &&   (* pre_q   ==   * q ))
                 {
                     ++ pre_q ;
                 }
                 q   =   pre_q ;
             }
         }
         auto   pre_p   =   p   +   1 ;
         while ( pre_p   <   ( nums . end ()   -   1 )   &&   (* pre_p   ==   * p ))
         {
             ++ pre_p ;
         }
         p   =   pre_p ;
         q   =   p   +   1 ;
     }
     return   res ;
}
版本 3 ：使用 Two-pointer tech ，但是无法通过所有的 cases
vector < vector < int >>   threeSum ( vector < int >&   nums )
{
     vector < vector < int >>   res ;
     if ( nums . size ()   <   3 )
     {
         return   res ;
     }
     sort ( nums . begin (),   nums . end ());
     auto   p   =   nums . begin ();
     auto   q   =   nums . end ()   -   1 ;
     while ( p   <   q )
     {
         int   toFind   =   -(* p   +   * q );
         auto   pos   =   find ( p   +   1 ,   q ,   toFind );
         if ( pos   !=   q )
         {
             res . push_back ({   * p ,   toFind ,   * q   });
         }
         if ( toFind   <   0 )
         {
             auto   pre_q   =   q   -   1 ;
             while ( pre_q   !=   p   &&   (* pre_q   ==   * q ))
             {
                 -- pre_q ;
             }
             q   =   pre_q ;
         }
//对于toFind==0情况，讨论不足。
         else
         {
             auto   pre_p   =   p   +   1 ;
             while ( pre_p   !=   q   &&   (* pre_p   ==   * p ))
             {
                 ++ pre_p ;
             }
             p   =   pre_p ;
         }
     }
     return   res ;
}
错误用例

Input:[-2,0,1,1,2]

Output:[[-2,0,2]]

Expected:[[-2,0,2],[-2,1,1]]

2 、别人的程序
使用 Two-pointers tech ，可以通过。
vector < vector < int >   >   threeSum ( vector < int >   & num )
{
     vector < vector < int >   >   res ;
     std :: sort ( num . begin (),   num . end ());
     for ( int   i   =   0 ;   i   <   num . size ();   i ++)
     {
         int   target   =   - num [ i ];
         int   front   =   i   +   1 ;
         int   back   =   num . size ()   -   1 ;
         while ( front   <   back )
         {
             int   sum   =   num [ front ]   +   num [ back ];
             // Finding answer which start from number num[i]
             if ( sum   <   target )
                 front ++;
             else   if ( sum   >   target )
                 back --;
             else
             {
                 vector < int >   triplet ( 3 ,   0 );
                 triplet [ 0 ]   =   num [ i ];
                 triplet [ 1 ]   =   num [ front ];
                 triplet [ 2 ]   =   num [ back ];
                 res . push_back ( triplet );
                 // Processing duplicates of Number 2
                 // Rolling the front pointer to the next different number forwards
                 while ( front   <   back   &&   num [ front ]   ==   triplet [ 1 ])   front ++;
                 // Processing duplicates of Number 3
                 // Rolling the back pointer to the next different number backwards
                 while ( front   <   back   &&   num [ back ]   ==   triplet [ 2 ])  rear --;
             }
         }
         // Processing duplicates of Number 1
         while ( i   +   1   <   num . size ()   &&   num [ i   +   1 ]   ==   num [ i ])
             i ++;
     }
     return   res ;
}
比较简短版的
vector < vector < int >>   threeSum ( vector < int >&   nums )
{
     vector < vector < int >>   triples ;
     triples . reserve ( 200 );
     sort ( nums . begin (),   nums . end ());
     int   i   =   0 ,   last   =   nums . size ()   -   1 ;
     while ( i   <   last )
     {
         int   a   =   nums [ i ],   j   =   i   +   1 ,   k   =   last ;
         while ( j   <   k )
         {
             int   b   =   nums [ j ],   c   =   nums [ k ],   sum   =   a   +   b   +   c ;
             if ( sum   ==   0 )   triples . push_back ({   a ,   b ,   c   });
             if ( sum   <=   0 )   while ( nums [ j ]   ==   b   &&   j   <   k )   j ++;
             if ( sum   >=   0 )   while ( nums [ k ]   ==   c   &&   j   <   k )   k --;
         }
         while ( nums [ i ]   ==   a   &&   i   <   last )   i ++;
     }
     return   triples ;
}
lizi_stdio
关注
专栏目录
decltype用法
qq_32278309的博客
11-16 320
//(1) 基本用法 int getSize(); ​ int main(void) { int tempA = 2; /*1.dclTempA为int.*/ decltype(tempA) dclTempA; /*2.dclTempB为int，对于getSize根本没有定义，但是程序依旧正常，因为decltype只做分析，并不调用getSize()....
leetcode.3sum-leetcode-practice:算法实践
07-07
3sum leetcode-练习 算法实践 15. 3和 给定一个由 n 个整数组成的数组 nums，nums 中是否有元素 a、b、c 使得 a + b + c = 0？ 在数组中找到所有唯一的三元组，其总和为零。 示例输入： [-1, 0, 1, 2, -1, -4] 示例...
C++11 decltype关键字
m_buddy的博客
06-03 785
1.1 decltype语法 在C++11中增加了decltype关键字（表达式：decltype(exp)），用来在编译时推导出一个表达式的类型，并且不会真正计算表达式的值。 int x = 0; decltype(x) y = 1; //y->int decltype(x + y) z = 0; //z->int const int& i = x; decltype(i) j =
C++11特性：decltype关键字
weixin_34406061的博客
11-10 201
decltype简介 我们之前使用的typeid运算符来查询一个变量的类型，这种类型查询在运行时进行。RTTI机制为每一个类型产生一个type_info类型的数据，而typeid查询返回的变量相应type_info数据，通过name成员函数返回类型的名称。同时在C++11中typeid还提供了hash_code这个成员函数，用于返回类型的唯一哈希值。RTTI会导致运行时效率降低，且在泛型编程中，我...
[C++] decltype类型指示符
yaming的专栏
05-27 1395
有些情况下，我们希望从表达式的类型推断出要定义的变量的类型，但是不想用该表达式的值初始化变量。此时就要用到C++11引入的第二种类型说明符delctype，它的作用就是选择并返回操作数的数据类型。编译器分析表达式并得到它的类型，但不实际计算表达式的值： decltype (size(5)) s = i;' decltype返回size函数返回值的类型，来声明变量s。decltype处理
Leetcode 015 3Sum（Twopoint）
不慌不忙、不急不躁
06-07 207
题目连接：Leetcode 015 3Sum解题思路：将数组排序，枚举一个数，剩下两个数在数组中用 Leetcode 001 中的方法找到，移动指针的时候需要注意相同数字的情况。class Solution { public: vector&lt;vector&lt;int&gt;&gt; threeSum(vector&lt;int&gt;&amp; nums) { vector&l...
LeetCode:3Sum
u012957549的博客
04-16 2775
题目链接：https://leetcode.com/problems/3sum/description/项目源码：https://github.com/haha174/daylx 假设3sum问题的目标是target。每次从数组中选出一个数k，从剩下的数中求目标等于target-k的2sum问题。这里需要注意的是有个小的trick：当我们从数组中选出第i数时，我们只需要求数值中从第i+1个到最后一
leetcode-3sum
红酒暖心不暖胃
06-12 215
python leetcode 15. 3Sum
Neekity的博客
12-05 740
为了去重要先对数组进行排序 class Solution: def threeSum(self, nums): """ :type nums: List[int] :rtype: List[List[int]] """ nums.sort() lenn = len(nums) ...
LeetCode 136 3Sum Closest
11-01 683
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
java-leetcode题解之015-3Sum
最新发布
08-31
java入门 java_leetcode题解之015_3Sum
leetcode.3sum-leetcode:创建此存储库是为了发布各种leetcode问题的解决方案
07-07
3sum # Leetcode 解决方案以下是我在 Leetcode 上解决的一些问题，如果你喜欢/找到任何你的答案，请留下一个星。 如果你想与我联系，我在下面分享了我的 Linkedin URL。 问题 ＃ 标题 ＃ 解决方案 困难 1 二和 简单...
python数组双指针算法求和问题LeetCode2sum3sum4sum含代码
01-14
本文将深入探讨如何使用Python实现双指针算法来解决LeetCode中的2sum、3sum和4sum问题，并提供相关代码示例。 首先，我们来看2sum问题。给定一个整数数组`nums`和一个目标值`target`，我们需要找到数组中两个数的...
文档python数组双指针算法求和问题LeetCode2sum3sum4sum含代码
04-17
本文档主要介绍了在Python编程语言中如何运用双指针算法解决LeetCode上的2Sum、3Sum及4Sum求和问题，并提供了相应的代码实现。LeetCode是一个非常受欢迎的在线编程平台，用于练习算法题目，尤其适合准备技术面试的...
c++中关键字decltype
四叶草姚的博客
07-30 461
c++中关键字decltype decltype推导出的类型与源代码中声明的对象或函数的类型完全匹配。类似于sizeof操作符，decltype也不需对其操作数求值。粗略来说，decltype(e)返回类型前，进行推导： 如果表达式e引用本地或命名空间作用域中的变量，静态成员变量或函数参数，那么结果就是变量或参数的声明类型 否则，如果e是左值，decltype(e)则是T&amp;，Te的类...
LeetCode 419 BattleshipsInABoard DFS、BFS简单的入门
Josan的博客
12-16 645
记录自己的LeetCode刷题过程，总结刷题过程中的心得体会。 通过这个例子可以快速的熟悉DFS跟BFS，绝对是不错的例子，而且代码风格也不错，推荐。
LeetCode 050 Pow(x,n)
Josan的博客
12-12 450
记录自己的LeetCode刷题过程，总结刷题过程中的心得体会。 加深对类型转换的理解。 首先， int a=INT_MIN; 则 int b =-a; //b仍然为INT_MIN unsiged c=-a; //c为INT_MAX+1 long d=-a; //d= 0xffffffff80000000 ; 也就是仍未INT_MIN 对于long long 也是如此； unsiged long e=-a; //e=0x80000000;也就是INT_M
LeetCode 167 TwoSumII-InputArrayIsSorted
Josan的博客
12-21 438
记录自己的LeetCode刷题过程，总结刷题过程中的心得体会。 学习一些精简的代码 LeetCode 适当改变函数形式也是正确的。
leetcode tosum
07-27
LeetCode题目“Two Sum”是一个非常经典且常见的问题。这个问题要求在一个给定的整数数组中，找到两个数的和等于给定目标值，然后返回这两个数的索引。 我们可以使用暴力解法来解决这个问题。具体步骤如下： 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值