LeetCode - 15. 3Sum

方法一：

这一道题目直接的想法就是Brute Force，通过三重循环来寻找目标，但是这样的时间复杂度非常高，同时又需要检测来避免重复，所以这种方法虽然能够得到正确的答案，但是在leetcode上会因为time limit exceeded而无法通过

public class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> resultList = new ArrayList<List<Integer>>();

for(int i = 0; i < nums.length; i++){
for(int j = i + 1; j < nums.length; j++){
for(int k = j + 1; k < nums.length; k++){
if(nums[i] + nums[j] + nums[k] == 0){
List<Integer> list = new ArrayList<Integer>();
list.add(nums[i]);
list.add(nums[j]);
list.add(nums[k]);

if(!resultList.contains(list)){
resultList.add(list);
}
}
}
}
}
return resultList;
}
}
方法二：

回想前面所做的1. Two Sum这一道题目，在这一题目中采用了一种思想：先固定一个数，通过查找的方式找出第二个数，在Two Sum题目中这一思想得到了很好的应用。所以在思考更快速的方法来解决3Sum的时候，可以在外围使用两个二重循环分别固定两个数，而采用查找的方式来找出第三个数字，这样时间复杂度就从原来的O(n^3)变成了O(n^2logn)。可惜这种改进方法还是无法在leetcode上面通过，同样会出现time limit exceeded的错误

public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<List<Integer>>();

//sort array
java.util.Arrays.sort(nums);

//find complement
int complement;
for(int i = 0; i < nums.length; i++){
for(int j = i + 1; j < nums.length; j++){
complement = 0 - nums[i] - nums[j];

int index = java.util.Arrays.binarySearch(nums, complement);
if(index >= 0 && nums[index] > nums[j]){
List<Integer> list = new ArrayList<Integer>();
list.add(nums[i]);
list.add(nums[j]);
list.add(nums[index]);

if(!result.contains(list)){
result.add(list);
}
}
}
}
return result;
}
方法三：

正在一筹莫展的时候，搜索到了这篇文章http://www.sigmainfy.com/blog/summary-of-ksum-problems.html，是对k-sum问题的一个总结，看下来之后又有了新的想法。首先，在2Sum问题当中，首先对数组进行排序，接着通过一个指向头部，一个指向尾部的指针向中间移动，来寻找目标数字，这样就成功地把2Sum问题的时间复杂度降低到了O(n)级别，非常有效。因此对于2Sum问题的变体-3Sum，也可以采用同样的思路，即通过一个外层的循环分别固定数组中的每一个数字，将3Sum问题变成多个2Sum问题，同时，题目要求没有重复，所以在添加结果之前，还要检测是否有重复

public class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<List<Integer>>();
int pfront;
int pback;

//sort array
java.util.Arrays.sort(nums);

for(int i = 0; i < nums.length - 2; i++){
int complement = 0 - nums[i];

//set pointers
pfront = i + 1;
pback = nums.length - 1;

//search complement
while(pfront < pback){
if(nums[pfront] + nums[pback] == complement){
//construct answer, nondescending order
List<Integer> list = java.util.Arrays.asList(nums[i], nums[pfront], nums[pback]);
if(!result.contains(list)){
result.add(list);
}

/*
List<Integer> list = new ArrayList<Integer>();
list.add(nums[i]);
list.add(nums[pfront]);
list.add(nums[pback]);
result.add(list);
*/

//move pointers and avoid duplicate
pfront++;
pback--;

}else if(nums[pfront] + nums[pback] < complement){
pfront++;
}else{
pback--;
}
}
}
return result;
}
}方法四：
方法三在leetcode上面得到的结果竟然还是time limit exceeded，此时我的内心几乎是崩溃的....还能有其他的方法减少时间吗？其实是有的，注意到在方法三中，检测重复时使用了list的内置函数contains，但是我们可以通过对指针的正确操作来避免对contains的使用。要了解怎么操作指针，首先我们应该想到在什么情况下会有重复，当然就是给出的目标数组中有相等数字的情况，而在这一算法中，外层循环中的i，内层循环中的两个指针pfront, pback可能会碰到相同的数字进而导致重复，所以在每次外层循环的时候，我们都要检测nums[i]和nums[i
- 1]是否一样，如果一样的话，很可能会造成重复；在内层循环中，当找到目标数字的时候，需要进行pfront++和pback--来跳过临近的相同数字。总的来说，第四种方法和第三种方法并没有本质上的区别，只是优化了检测重复的机制，这样就终于可以在leetcode上accept了

public class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<List<Integer>>();

//Attention: alaways consider extreme situation
if(nums == null || nums.length < 3) return result;

int pfront;
int pback;
int complement;

//sort array
Arrays.sort(nums);

for(int i = 0; i < nums.length - 2; i++){
//avoid duplicate
if(i > 0 && nums[i] == nums[i - 1]) continue;

complement = 0 - nums[i];
//set pointers
pfront = i + 1;
pback = nums.length - 1;

while(pfront < pback){
if(nums[pfront] + nums[pback] == complement){
List<Integer> list = Arrays.asList(nums[i], nums[pfront], nums[pback]);
result.add(list);

//move pointers
while(pfront < pback && nums[pfront] == nums[pfront + 1]) pfront++;
while(pfront < pback && nums[pback] == nums[pback - 1]) pback--;
pfront++;
pback--;
}else if(nums[pfront] + nums[pback] < complement){
pfront++;
}else{
pback--;
}
}
}
return result;
}
}知识点：
1. List<List<Integer>>的正确实例化是new ArrayList<List<Integer>>()或new ArrayList<>()，而不是new ArrayList<ArrayList<Integer>>()或new List<List<Integer>>，前者的解释在http://stackoverflow.com/questions/5763750/why-we-cant-do-listparent-mylist-arraylistchild，而后者List是接口，不能实例化

2. Array与List的相互转换：java.util.Arrays.asList(nums[i], nums[pfront], nums[pback])

3. Array排序：Arrays.sort(nums)

4000