成全视频在线观看免费高清动漫,亚洲欧美国产日韩中文字幕 ,好看的韩国三色电费2024

Question:

Paste_Image.png

My code:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        if (nums == null)
            return null;
        Arrays.sort(nums);
        
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        if (nums.length < 3 || nums[0] > 0 || nums[0] + nums[1] + nums[2] > 0)
            return result;
        
        for (int i = 0; i < nums.length - 2; i++) {
            int negate = -nums[i];
            int start = i + 1;
            int end = nums.length - 1;
            while ((i == 0 || nums[i] != nums[i - 1]) && start < end) {
                if (nums[start] + nums[end] > negate) {
                    end--;
                }
                else if (nums[start] + nums[end] < negate) {
                    start++;
                }
                else {
                    List<Integer> s = new ArrayList<Integer>();
                    s.add(nums[i]);
                    s.add(nums[start]);
                    s.add(nums[end]);
                    result.add(s);
                    start++;
                    end--;
                    while (start < end && nums[start] == nums[start - 1])
                        start++;
                    while (start < end && nums[end] == nums[end + 1])
                        end--;
                }
            }
        }
        return result;
    }
    
    public static void main(String[] args) {
        Solution test = new Solution();
        int[] a = {-1, 0, 1, 2, -1, -4};
        System.out.println(test.threeSum(a));
    }
}

My test result:

Paste_Image.png

這次作業，還是沒能自己做出來。看了提示，說是用雙指針。我也猜到。
于是第一步做對了，先排個序。
然后我錯誤得將該數組分成兩類， < 0 為一類， >= 0 為一類。
然后設置了兩個指針 head, tail分別指向這個數組的頭和尾，想通過這樣的雙指針來解決問題。
同時，我參考了2Sum的解法，先將head and tail 所指的數的和的相反數求出來，存入哈希表中。然后如果小于0，那就移動head指針來找。如果大于0，那就移動tail指針來找。
但是問題來了，當等于0時，如果找到了（nums[middle] == 0 is true）,那么接下來，可能性就會有三種了，要么head++; 要么 tail--. 要么也可以同時加減。我的一個簡單的循環，類似于一個狀態機，無法在一個時刻，在無先決條件的情況下，描述出這三種發展可能性。所以我的程序是錯誤的，或者說，我的模型，再次錯誤了。同時，我還把那個相反數存入了哈希表。下次新的相反數出現時，如果哈希表中已經存在了，那么就直接跳過。以此來篩選掉那些重復情況。這樣其實也是錯的。
比如 4 + -3 = 1; 哈希表中存放 -1. 3 + -2 = 1；此時完全是另外一種情況，但1已經存在于哈希表中了，于是直接跳過。造成錯誤。
然后這個時候我就放棄了。上網看了下思路。
發現該用這種解法。我也不知道為什么自己想不出這種解法。一個很大的可能是。昨天的水桶題也是雙指針，雙指針是從頭和尾巴向中間走。于是我就直接把那個模型套過來了。
而這道題目，雖然也是頭指針和尾指針向著中間靠，但準確的說，是有三個指針的。是不一樣的模型。
累死了。

**
總結：所以說，雙指針目前碰到的幾個類型。
1.徹底的頭指針，尾指針。水桶題。
2.一個基指針，然后跟著頭指針和尾指針，此道題目就是如此。
3.也有頭指針再加中間一個指針，同時開始跑。具體題型忘了。
然后，
List<List<Integer>> result = new List<List<Integer>>(); 是錯的。
List<List<Integer>> result = new ArrayList<List<Integer>>(); 是對的。
因為 List是一個接口，不能被new。所以只能用ArrayList來代替。
只有類才能new 接口是不能new的。

那么，接口和抽象類有什么區別。
抽象類可以實現方法。接口不行。
抽象類可以有 static final, 接口不行。
一個子類只能繼承一個抽象類，但可以實現多個接口。

差不多就總結這些吧。媽的每次凌晨做的題目都好帶勁！可惜精神狀態都不是最佳。
**

Anyway, Good luck, Richardo!

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;

public class Solution {
    /* Solution 1: O(n^k) k = 2, 3, 4, 5, ... general solution
    public List<List<Integer>> threeSum(int[] nums) {
        ArrayList<List<Integer>> ret = new ArrayList<List<Integer>>();
        if (nums == null || nums.length <= 2)
            return ret;
        HashSet<List<Integer>> retSet = new HashSet<List<Integer>>();
        ArrayList<Integer> group = new ArrayList<Integer>();
        helper(nums, 3, 0, 0, retSet, group);
        for (List<Integer> tmp : retSet) {
            ret.add(tmp);
        }
        return ret;
    }
    
    private void helper(int[] nums, int k, int begin, int target, HashSet<List<Integer>> retSet, ArrayList<Integer> group) {
        if (k == 0) {
            int sum = 0;
            int[] arr = new int[group.size()];
            for (int i = 0; i < group.size(); i++) {
                arr[i] = group.get(i);
                sum += arr[i];
            }
            if (sum == target) {
                Arrays.sort(arr);
                ArrayList<Integer> newGroup = new ArrayList<Integer>();
                for (int i = 0; i < arr.length; i++)
                    newGroup.add(arr[i]);
                retSet.add(newGroup);
            }
            return;
        }
        for (int i = begin; i < nums.length; i++) {
            group.add(nums[i]);
            helper(nums, k - 1, i + 1, target, retSet, group);
            group.remove(group.size() - 1);
        }
    }
    */
    
    /* Solution 2: sort to simplify, O(n^k) with a smaller constant
    public List<List<Integer>> threeSum(int[] nums) {
        ArrayList<List<Integer>> ret = new ArrayList<List<Integer>>();
        if (nums == null || nums.length <= 2)
            return ret;
        Arrays.sort(nums);
        HashSet<List<Integer>> retSet = new HashSet<List<Integer>>();
        ArrayList<Integer> group = new ArrayList<Integer>();
        helper(nums, 3, 0, 0, 0, retSet, group);
        for (List<Integer> tmp : retSet) {
            ret.add(tmp);
        }
        return ret;
    }
    
    private void helper(int[] nums, int k, int begin, int target, int sum, HashSet<List<Integer>> retSet, ArrayList<Integer> group) {
        if (k == 0) {
            if (sum == target) {
                retSet.add(new ArrayList<Integer>(group));
            }
            return;
        }
        for (int i = begin; i < nums.length; i++) {
            if (sum + nums[i] > target)
                break;
            group.add(nums[i]);
            helper(nums, k - 1, i + 1, target, sum + nums[i], retSet, group);
            group.remove(group.size() - 1);
        }
    }
    */
    
    /* Solution 3: sort, use 2Sum model, O(n^2) with larger constant because of Hash operation
    public List<List<Integer>> threeSum(int[] nums) {
        ArrayList<List<Integer>> ret = new ArrayList<List<Integer>>();
        if (nums == null || nums.length <= 2)
            return ret;
        Arrays.sort(nums);
        HashSet<List<Integer>> retSet = new HashSet<List<Integer>>();
        for (int i = 0; i < nums.length; i++) {
            helper(nums, i, retSet);
        }
        for (List<Integer> tmp : retSet) {
            ret.add(tmp);
        }
        return ret;
    }
    
    private void helper(int[] nums, int targetIndex, HashSet<List<Integer>> retSet) {
        HashMap<Integer, Integer> tracker = new HashMap<Integer, Integer>();
        int target = (-1) * nums[targetIndex];
        for (int i = targetIndex + 1; i < nums.length; i++) {
            if (tracker.containsKey(nums[i])) {
                ArrayList<Integer> group = new ArrayList<Integer>();
                group.add((-1) * target);
                group.add(nums[tracker.get(nums[i])]);
                group.add(nums[i]);
                retSet.add(group);
            }
            else {
                if (target - nums[i] < nums[i])
                    break;
                tracker.put(target - nums[i], i);
            }
        }
    }
    */
    
    /** Solution 4: pass all online tests. O(n ^ 2) with smaller constant */
    public List<List<Integer>> threeSum(int[] nums) {
        ArrayList<List<Integer>> ret = new ArrayList<List<Integer>>();
        if (nums == null || nums.length <= 2)
            return ret;
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            if (i >=1 && nums[i] == nums[i - 1])
                continue;
            int target = (-1) * nums[i];
            int start = i + 1;
            int end = nums.length - 1;
            while (start < end) {
                int sum = nums[start] + nums[end];
                if (sum < target)
                    start++;
                else if (sum > target)
                    end--;
                else {
                    ArrayList<Integer> group = new ArrayList<Integer>();
                    group.add(nums[i]);
                    group.add(nums[start]);
                    group.add(nums[end]);
                    ret.add(group);
                    start++;
                    end--;
                    while (nums[start] == nums[start - 1] && start < end)
                        start++;
                    while (nums[end] == nums[end + 1] && start < end)
                        end--;
                }
            }
        }
        return ret;
    }
    
    
    
    public static void main(String[] args) {
        Solution test = new Solution();
        int[] nums = new int[] {-1, 0, 1, 2, -1, -4};
        System.out.println(test.threeSum(nums));
    }
}

我自己寫了三種做法，但是沒有一個通過測試。
做法一是一個通解，對 kSum 都可以求解。但是沒有排序，復雜度為 O(n ^ 3) 并且常數系數比較大。
做法二是對做法一的優化。先排序，之后當發現和已經大于了要求時表示再也找不到了，就立刻停止。復雜度仍然為O(n ^ 3),但是常數系數會小一些。
做法三是利用2Sum的模型。先固定住一個值，那么后面就是2Sum，target = -nums[i]
然后復雜度是O(n ^ 2) ，因為2Sum是O(n). 但是涉及到哈希表的許多操作，所以常數系數不會小。

然后我看了能通過測試的做法，即做法4.
http://www.programcreek.com/2012/12/leetcode-3sum/
復雜度也是O(n ^ 2), 但是沒有任何哈希操作，所以常數系數小，可以通過測試。
也是固定住一個值， target = (-1) * nums[i]. 然后從頭尾同時開始搜索這個target，一旦發現，加入list。然后呢，為了避免重復，start和end需要向左和向右滑行一段，保證下一對正確的值不再重復。
同時，在最外層for循環中，為了避免重復，每次需要判斷當前nums[i] 是否和
nums[i - 1] 相等。如果相等，那么之后找出來的解很有可能是重復的。所以要避免這種情況。

感覺這道題木還是很經典的。
我一開始直接用DFS的思路來求解，寫起來是簡單，但是復雜度較高。
后來想用2sum來降低復雜度，但是還是存在大量的哈希操作。
最后，用雙指針，頭尾跑，解決了問題。
雙指針，頭尾跑，經常應用于已經排好序的數組中。
留意。

Anyway, Good luck, Richardo!

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Leetcode - 3Sum

Leetcode - 3Sum

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Leetcode - 3Sum

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频