class Solution {
    public int maxSubArray(int[] nums) {
        // 以i结尾的最大值数组和  
        //pre[i] = max{pre[i-1],nums[i]}
        //求最大数组和，可以计算出每个位置的最大值数组和，再取最大
        int pre = 0;
        int ans = nums[0];
        for(int i=0;i<nums.length;i++){
            pre = Math.max(pre+nums[i],nums[i]);
            ans = Math.max(ans,pre);
        }
        return ans;
    }
}

class Solution {
    public int[][] merge(int[][] intervals) {
        //排序
        Arrays.sort(intervals,(a,b) -> (a[0]-b[0]));
        List<int[]> ans  = new ArrayList<>();
        //循环，判断a[1]和b[0]大小
        for(int i =0;i<intervals.length;i++){
            //如果a[1]>b[0]则可以合并
            int size = ans.size();
            if(size>0&&ans.get(size-1)[1]>=intervals[i][0]){
                //比较a[1]和b[1]哪个大保留哪个
                ans.get(size-1)[1] = Math.max(ans.get(size-1)[1],intervals[i][1]);
            }else{
                //如果a[1]<b[0]则不能合并,添加到list
                ans.add(intervals[i]);
            }
        }
        return ans.toArray(new int[0][]);
    }
}

class Solution {
    public void rotate(int[] nums, int k) {
        //计算新索引的位置 i = (i + k)%nums.length
        //索引0-5 移动1位 5 -> (5+1)%6  = 0  0-> (0+1)%6 = 1
        int len = nums.length;
        int[] ans = new int[len];
        for(int i=0;i<len;i++){
            ans[(i+k)%len] = nums[i];
        }
        //覆盖原数组
        //public static void arraycopy(
        // Object src,      // 源数组：要复制的原数组
        // int srcPos,      // 源数组起始位置：从源数组的第几个索引开始复制
        // Object dest,     // 目标数组：复制到的目标数组
        // int destPos,     // 目标数组起始位置：复制到目标数组的第几个索引
        // int length       // 复制长度：要复制的元素个数
        // )
        System.arraycopy(ans,0,nums,0,len);
    }
}

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int n = nums.length;
        int[] res = new int[n];
        res[0] = 1;
        for (int i = 1; i < n; i++) {
            res[i] = res[i - 1] * nums[i - 1];
        }
        int right = 1;
        for (int i = n - 1; i >= 0; i--) {
            res[i] = res[i] * right;
            right *= nums[i];
        }
        return res;
    }
}

class Solution {
    public int firstMissingPositive(int[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            while (nums[i] >= 1 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
                int tmp = nums[i];
                nums[i] = nums[tmp - 1];
                nums[tmp - 1] = tmp;
            }
        }
        for (int i = 0; i < n; i++) {
            if (nums[i] != i + 1) {
                return i + 1;
            }
        }
        return n + 1;
    }
}

class Solution {
    public int lengthOfLongestSubstring(String s) {
        //使用滑动窗口
        Set<Character> set = new HashSet<>();
        int length = s.length();
        int lPointer = 0;
        int ans = 0;
        for(int rPointer = 0;rPointer<length;rPointer++) {
            //移动右指针，添加字符
            Character c = s.charAt(rPointer);
            while(set.contains(c)){
                //如果集合包含字符，移动左指针移，除左指针所在位置字符，直到移除掉重复字符
                set.remove(s.charAt(lPointer));
                lPointer++;
            }
            set.add(c);
            //记录最大值
            ans = Math.max(ans,rPointer-lPointer+1);
        }
        return ans;
    }
}

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        //把字符串p映射成0~25的数组上分别对应a~z
        int[] pCnt = new int[26];
        for(int i = 0;i<p.length();i++){
            pCnt[p.charAt(i) - 'a'] ++ ; //如：a-a =0 ,b-a = 1 
        }
        //同理把滑动窗口也映射到数组上
        int[] wCnt = new int[26];
        List<Integer> res = new ArrayList<>();
        for(int r = 0;r<s.length();r++){
            int l = r - p.length() + 1;
            //记录字符
            wCnt[s.charAt(r) - 'a'] ++;
            //窗口需要和p长度一致
            if(r<p.length()-1){
                continue;
            }
            //比较两个数组是否相同
            if(Arrays.equals(pCnt,wCnt)){
                res.add(l);
            }
            //继续寻找
            //左指针移动，恢复现场
            wCnt[s.charAt(l) - 'a'] --;
        }
        return res;
    }
}

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        //双端队列实现（队列最左边为最大元素） 左->右 （队首->队尾）
        //维护方法：及时弹出小于队尾的元素，保证双端队列有序
        Deque<Integer> q = new ArrayDeque<>();
        //一个有 nums.length - k +1 个窗口
        int[] ans = new int[nums.length-k+1];
        for(int i =0;i<nums.length;i++){
            //入队
            //过滤小于队尾的元素
            while(!q.isEmpty()&&nums[q.getLast()]<=nums[i]){
                q.removeLast();
            }
            q.addLast(i);
            //出队
            //如果队首元素超出了这个滑动窗口（即 小于 i -k +1）移除队首元素
            if(q.getFirst()<i-k+1){
                q.removeFirst();
            }
            //记录最大值
            if(i>=k-1){
                ans[i-k+1] = nums[q.getFirst()];
            }
        }
        return ans;
    }
}

class Solution {
    //字符串不连续的情况
    public String minWindow(String s, String t) {
        int[] tCharArr = new int[128];

        //初始化
        for(int i=0;i<t.length();i++){
            char c = t.charAt(i);
            tCharArr[c]++;
        }
        int[] ansCharArr = new int[128];
        int l = 0;
        int ansL = -1;
        int ansR = s.length();
        for(int r=0;r<s.length();r++){
            char c = s.charAt(r);
            ansCharArr[c]++;
            //判断是否覆盖
            while(isCovered(tCharArr,ansCharArr)){
                //判断最小子字符串是否缩短
                if(r-l<ansR-ansL){
                    //记录边界
                    ansL = l;
                    ansR = r;
                }
                //删除最左边元素
                ansCharArr[s.charAt(l)]--;
                //左边界向右移动
                l++;
            }
        }
        return ansL < 0 ? "":s.substring(ansL,ansR+1);
    }

    private boolean isCovered(int[] tCharArr,int[] ansCharArr){
        //逐个字符比较大小
        for(int i='A';i<='Z';i++){
            //ans是长字符串 t是短字符串
            if(ansCharArr[i]<tCharArr[i]){
                return false;
            }
        }
        for(int i='a';i<='z';i++){
            //ans是长字符串 t是短字符串
            if(ansCharArr[i]<tCharArr[i]){
                return false;
            }
        }
        return true;
    }
}

class Solution {
    public int[] twoSum(int[] nums, int target) {
        //hashmap 存放value->index
        Map<Integer,Integer> map = new HashMap<>();
        for(int i = 0;i<nums.length;i++){
            int requireValue = target - nums[i];
            //requireValue如果存在，即找到和为target的两个数
            if(map.containsKey(requireValue)){
                return new int[]{i,map.get(requireValue)};
            }
            map.put(nums[i],i);
        }
        return new int[]{};
    }
}

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        //使用Map存放，排序好的字符串->原字符串List
        Map<String,List<String>> map = new HashMap<>();

        for(int i=0;i<strs.length;i++){
            char[] strArr = strs[i].toCharArray();
            Arrays.sort(strArr);
            String sortedStr = new String(strArr);
            //如果map包含已排序好字符串add,否则new ArrayList并add
            map.computeIfAbsent(sortedStr,k->new ArrayList<>()).add(strs[i]);
        }
        return new ArrayList<>(map.values());
    }
}

class Solution {
    int ans = 0;
    public int longestConsecutive(int[] nums) {
        //1.去重
        Set<Integer> set = new HashSet<>();
        for(int i = 0;i<nums.length;i++){
            set.add(nums[i]);
        }
        //2.寻找子串的起点值
        for(Integer x:set){
            //如果有下一个不是起点，跳过
            if(set.contains(x-1)){
                continue;
            }
            int y = x + 1;
            //3.循环计数
            while(set.contains(y)){
                y++;//跳出循环时最后一个y要去掉
            }
            //4.记录最大值,x~y-1 连续数= y-x
            ans = Math.max(ans,y-x);
        }
        return ans;
    }
}

class Solution {
    public int subarraySum(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>();
        //key: if pre[i],pre[j] is the sum of 0~i/0~j
        //want solve: pre[i] - pre[j-1] = k
        //pre[j-1] = pre[i] - k
        //if pre[j-1] exists , means pre[i] - pre[j-1] is k  . j ~ i is the subarray we want
        int sum = 0,count = 0;
        //if sum == k need zero key
        map.put(0,1);
        for(int i=0;i<nums.length;i++){
            sum+= nums[i];
            if(map.containsKey(sum-k)){
                count+=map.get(sum-k);
            }
            //the sum as key , occur times as value
            map.put(sum,map.getOrDefault(sum,0)+1);
        }
        return count;
    }
}

class Solution {
    public void moveZeroes(int[] nums) {
        int length = nums.length;
        //双指针
        for(int left=0;left<length;left++){
            //左指针寻找0
            if(nums[left] == 0){
                int right = left+1;

                //右指针找到非0数，交换位置
                while(right<length&&nums[right]==0){
                    right++;
                }
                //防止right越界
                if(right>=length){
                    return;
                }
                int tmp = nums[right];
                nums[right] = nums[left];
                nums[left] = tmp;
            }
        }
    }
}

class Solution {
    public int maxArea(int[] height) {
        //使用双指针
        int l = 0,r = height.length-1;
        int res = 0;
        //比较l和r，移动height小的指针
        while(l<r){
            //计算面积
            int area = (r-l)*Math.min(height[l],height[r]);
            res = Math.max(res,area);
            //继续寻找
            if(height[l]<height[r]){
                l++;
            }else{
                r--;
            }
        }
        return res;
    }
}

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        //排序
        Arrays.sort(nums);
        //遍历数组
        for(int i = 0;i<nums.length;i++){
            //去重
            if(i>0&&nums[i]==nums[i-1]){
                continue;
            }
            int target = -nums[i];
            int l = i+1,r=nums.length -1;
            while(l<r){
                //如果nums[l]+nums[r] = target
                if(nums[l]+nums[r] == target){
                    res.add(Arrays.asList(nums[i],nums[l],nums[r]));
                    //继续寻找
                    l++;
                    r--;
                    //跳过重复元素
                    while(nums[l-1]==nums[l]&&l<r){
                        l++;
                    }
                    while(nums[r+1]==nums[r]&&l<r){
                        r--;
                    }
                    continue;
                }
                //如果nums[l]+nums[r] < target l++
                if(nums[l]+nums[r] < target){
                    l++;
                    continue;
                }
                //如果nums[l]+nums[r] > target r--
                if(nums[l]+nums[r] > target){
                    r--;
                }
            }
        }
        return res;
    }
}

class Solution {
    public int trap(int[] height) {
        //关键：下标 i 处能接的雨水量由 leftMax[i]（左指针走到i过程中发现的最大值） 和 rightMax[i] 中的最小值决定。
        //方法1：创建前缀最大值数组+后缀最大值数组，存放i从左到右、从右到左的最大值 (空间复杂度O(n))
        int preMax[] = new int[height.length];
        preMax[0] = height[0];
        //计算前缀最大值
        for(int i=1;i<height.length;i++){
            preMax[i] = Math.max(preMax[i-1],height[i]);
        }
        //计算后缀最大值
        int sufMax[] = new int[height.length];
        sufMax[height.length-1] = height[height.length-1];
        for(int i=height.length-2;i>=0;i--){
            sufMax[i] = Math.max(sufMax[i+1],height[i]);
        }
        //计算结果
        int ans = 0;
        for(int i=0;i<height.length;i++){
            ans += Math.min(preMax[i],sufMax[i]) - height[i];
        }
        return ans;

        // //方法2：双指针(空间复杂度O(1))
        // //分别计算前缀和后缀，需要额外的存储空间，如果不使用额外的空间，可以只记录当前左边最大，右边最大，并实时更新。
        // //移动小边的指针原因：大边的最大值已经确定，小边的值可能会增大，可能会接到更多雨水
        // int leftMax =0,rightMax = 0;
        // int l=0,r=height.length-1;
        // int ans = 0;
        // while(l<r){
        //     //判断哪边小
        //     //更新最大值
        //      leftMax = Math.max(leftMax,height[l]);
        //      rightMax = Math.max(rightMax,height[r]);
        //    if(leftMax<=rightMax){
        //      //计算雨水
        //      ans+=leftMax-height[l];
        //      l++;
        //    }else{
        //      //计算雨水
        //      ans+=rightMax-height[r];
        //      r--;
        //    }
        // }
        // return ans;
    }
}