[5.24+5.25]算法刷题：双指针遍历/滑动窗口

[5.24+5.25]双指针遍历/滑动窗口

一、[Leetcode：3] 无重复字符的最长字串

(https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/)

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

解法一：HashMap来存储出现次数，然后双指针移动

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eWZIawXY-1621940232174)(双指针滑动窗口.assets/image-20210524120032034.png)]

class Solution {
    public int lengthOfLongestSubstring(String s) {
      if(s.length()<=0){
            return s.length();
        }
        Map<Character,Integer> map=new HashMap<>();
        char[] sword=s.toCharArray();
        int i=0;
        int j=0;
        int max=0;
        while(j<s.length()&&i<s.length()){
            while(j<s.length()&&(!map.containsKey(sword[j])||map.get(sword[j])==0)){
                map.put(sword[j],map.getOrDefault(sword[j],0)+1);
                j++;
            }
            max=Math.max(j-i,max);
            while(j<s.length()&&map.get(sword[j])!=0){
                map.put(sword[i],map.get(sword[i])-1);
                i++;
            }
            max=Math.max(j-i,max);
        }
        return max;
    }
}

解法二：HashMap来存储出现的下标，然后双指针移动，可以减少对hashmap的调用次数并且可以减少对hashmap中值的修改(代码更简单)

class Solution {
    public int lengthOfLongestSubstring(String s) {
      Map<Character,Integer> map=new HashMap<>();
      if(s.length()<=1) return s.length();
      int left=0;
      int count=0;
      for(int i=0;i<s.length();i++){
          if(!map.containsKey(s.charAt(i))){
              map.put(s.charAt(i),i);
          }
          else{
              left=Math.max(left,map.get(s.charAt(i))+1);
          }
          map.put(s.charAt(i),i);
          count=Math.max(count,i-left+1);
      }
      return count;
    }
}

二、[Leetcode：11] 盛最多水的容器

（11. 盛最多水的容器 - 力扣（LeetCode） (leetcode-cn.com)

给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

解法一

• 首先想到的便是普遍的解法，i从0开始遍历，然后j从i+1开始遍历，然后每次取他们的最小值来计算面积，最后输出最大的面积的暴力法
• 之后查看解析发现可以优化，每次如果两边的最小的值进行相减的时候，值只会越来越小，所以可以通过移动小的一边的矩形来进行优化
• 采用双指针，每次都移动小的一边的指针，直到指针之间相等，因为一条是构不成容纳的水的

class Solution {
    public int maxArea(int[] height) {
        int i=0;
        int j=height.length-1;
        int res=0;
        while(i<j){
            int temp=Math.min(height[i],height[j]);
            res=Math.max(temp*(j-i),res);
            if(height[i]<height[j]) i++;
            else{
                j--;
            }
        }
        return res;
    }
}

三、[Leetcode：15] 三数之和

（15. 三数之和 - 力扣（LeetCode） (leetcode-cn.com)）

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

解法一：首先排序，然后遍历，将遍历的值当作target值，然后进行两数之和的双指针计算

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res=new ArrayList<>();
        int len=nums.length;
        if(len<3) return res;
        Arrays.sort(nums);
        for(int i=0;i<len-1;i++){
            if(nums[i]>0) break;
            if(i>0&&nums[i]==nums[i-1]) continue;
            int L=i+1;
            int R=len-1;
            while(L<R){
                int sum=nums[i]+nums[L]+nums[R];
                if(sum==0){
                    res.add(Arrays.asList(nums[i],nums[L],nums[R]));
                    while (L<R && nums[L] == nums[L+1]) L++;
                    while (L<R && nums[R] == nums[R-1]) R--; 
                    L++;
                    R--;
                }
                else if (sum < 0) L++;
                else if (sum > 0) R--;
            }
        }        
        return res;
    }
}

四、[Leetcode：16] 最接近的三数之和

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

题解：

和上一题的三数之和是一样的，就是需要判断每个的距离而已

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        Arrays.sort(nums);
        int ans = nums[0] + nums[1] + nums[2];
        for(int i=0;i<nums.length;i++) {
            int start = i+1, end = nums.length - 1;
            while(start < end) {
                int sum = nums[start] + nums[end] + nums[i];
                if(Math.abs(target - sum) < Math.abs(target - ans))
                    ans = sum;
                if(sum > target)
                    end--;
                else if(sum < target)
                    start++;
                else
                    return ans;
            }
        }
        return ans;
    }
}

五、[Leetcode：26] 删除有序数组中的重复项

（26. 删除有序数组中的重复项 - 力扣（LeetCode） (leetcode-cn.com)）

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

题解一：

双指针进行left和right的指向，相等就将right后移一个，否则将left+1的值和right进行赋值操作。最后返回left的位置即可。

class Solution {
    public int removeDuplicates(int[] nums) {
        int left=0;
        if(nums.length<=1) return nums.length;
        int right=1;
        while(right<nums.length){
            while(right<nums.length&&nums[right]==nums[left]) right++;
            if(right<nums.length) nums[left+1]=nums[right];
            left++;
        }
        return left;

    }
}

六、[Leetcode：42] 接雨水

(42. 接雨水 - 力扣（LeetCode） (leetcode-cn.com))

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

题解一：动态规划，两边的最短值乘以高就是面积

图和算法借鉴 ：

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/trapping-rain-water/solution/jie-yu-shui-by-leetcode-solution-tuvc/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
    public int trap(int[] height) {
        int n = height.length;
        if (n == 0) {
            return 0;
        }

        int[] leftMax = new int[n];
        leftMax[0] = height[0];
        for (int i = 1; i < n; ++i) {
            leftMax[i] = Math.max(leftMax[i - 1], height[i]);
        }

        int[] rightMax = new int[n];
        rightMax[n - 1] = height[n - 1];
        for (int i = n - 2; i >= 0; --i) {
            rightMax[i] = Math.max(rightMax[i + 1], height[i]);
        }

        int ans = 0;
        for (int i = 0; i < n; ++i) {
            ans += Math.min(leftMax[i], rightMax[i]) - height[i];
        }
        return ans;
    }
}

题解二：单调栈

class Solution {
   public int trap(int[] height) {
       int ans = 0;
       Deque<Integer> stack = new LinkedList<Integer>();
       int n = height.length;
       for (int i = 0; i < n; ++i) {
           while (!stack.isEmpty() && height[i] > height[stack.peek()]) {
               int top = stack.pop();
               if (stack.isEmpty()) {
                   break;
               }
               int left = stack.peek();
               int currWidth = i - left - 1;
               int currHeight = Math.min(height[left], height[i]) - height[top];
               ans += currWidth * currHeight;
           }
           stack.push(i);
       }
       return ans;
   }
}

七、[Leetcode：209] 长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
         int left=0;
         int right=0;
         int n=nums.length;
         int sum=0;
         int min=Integer.MAX_VALUE;
         while(right<n){
             while(right<n&&sum<target) {
                 sum += nums[right];
                 right++;
             }
             while(left<right&&sum>=target) {
                 min=Math.min(right-left,min);
                 sum -= nums[left];
                 left++;
             }

             System.out.println(left+" "+right);
         }
        return min==Integer.MAX_VALUE?0:min;
    }
}

改进：尽量的减少判断，结果会好很多

  public int minSubArrayLen(int target, int[] nums) {
         int left=0;
         int right=0;
         int n=nums.length;
         int sum=0;
         int min=Integer.MAX_VALUE;
         while(right<n){
             sum += nums[right++];
             while(left<right&&sum>=target) {
                 min=Math.min(right-left,min);
                 sum -= nums[left];
                 left++;
             }
         }
        return min==Integer.MAX_VALUE?0:min;
    }

解法二：二分法+前缀和(但是效率不如前面一个的优化)

（https://leetcode-cn.com/problems/minimum-size-subarray-sum/submissions/）

class Solution {
        public int minSubArrayLen(int s, int[] nums) {
        int length = nums.length;
        int min = Integer.MAX_VALUE;
        int[] sums = new int[length + 1];
        for (int i = 1; i <= length; i++) {
            sums[i] = sums[i - 1] + nums[i - 1];
        }
        for (int i = 0; i <= length; i++) {
            int target = s + sums[i];
            int index = Arrays.binarySearch(sums, target);
            if (index < 0)
                index = ~index;
            if (index <= length) {
                min = Math.min(min, index - i);
            }
        }
        return min == Integer.MAX_VALUE ? 0 : min;
    }
}