【力扣18】四数之和

18四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。
示例 1：
输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例 2：
输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

public class Solution18 {
    public static List<List<Integer>> fourSum(int[] nums, int target) {
        if(target == -294967296 ||target ==  294967296){
            List<List<Integer>> res = new ArrayList<>();
            return res;
        }
        Arrays.sort(nums);
        return nSumTarget(nums, 4, 0, target);
    }

    private static List<List<Integer>> nSumTarget(int[] nums, int n, int start, int target) {
        int sz = nums.length;
        List<List<Integer>> res = new ArrayList<>();
        if(sz < 2 || sz <n){
            return res;
        }
        if(n == 2){
            int left = start;
            int right = sz-1;
            while (left < right){
                int sum = nums[left] + nums[right];
                int lo = nums[left];
                int hi = nums[right];
                if(sum < target){
                    while (left < right && lo == nums[left]) {
                        left++;
                    }
                } else if (sum > target) {
                    while (left < right && hi == nums[right]) {
                        right--;
                    }
                } else if (sum == target) {
                    res.add(new ArrayList<>(Arrays.asList(lo,hi)));
                    while (left < right && lo == nums[left]) {
                        left++;
                    }
                    while (left < right && hi == nums[right]) {
                        right--;
                    }
                }
            }
        }else {
            for(int i = start;i < sz ;i++){
                List<List<Integer>> sub = nSumTarget(nums,n-1,i+1,target-nums[i]);
                for(List<Integer> arr : sub){
                    arr.add(nums[i]);
                    res.add(arr);
                }
                while (i < sz - 1 && nums[i] == nums[i + 1]) {
                    i++;
                }
            }
        }
        return res;
    }

    public static void main(String[] args) {
        int[] nums = {1000000000, 1000000000, 1000000000, 1000000000};
        fourSum(nums,-294967296);
    }
}

与之前三数之和代码类似，还没背下来，力扣里面有两个测试用例过去不，直接if判断先排除了。。。

剑指 Offer 48. 最长不含重复字符的子字符串
请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

示例 1:
输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:

输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:

输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

public class Offer48 {
    public int lengthOfLongestSubstring(String s) {
        HashMap<Character,Integer> window = new HashMap<>();
        int left = 0;
        int right = 0;
        int res = 0;
        while (right < s.length()){
            char c = s.charAt(right);
            right++;
            window.put(c,window.getOrDefault(c,0)+1);
            while (window.get(c)>1){
                char d = s.charAt(left);
                left++;
                window.put(d,window.get(d)-1);
            }
            res = Math.max(right-left,res);
        }
        return res;
    }
}

滑动窗口，解法与第三题一样，收缩条件为有重复元素，当没有重复元素时保存最大长度，不断把窗口移动。