双指针进阶，接雨水，缺失的第一个整数问题，力扣算法

一，接雨水

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

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。
示例 2：

输入：height = [4,2,0,3,2,5]
输出：9
力扣链接
初步分析得出的算法：

class Solution {
    public int trap(int[] height) {
        int sum=0;
        int ans=0;
        int[] left=new int[height.length];
        int[] right=new int[height.length];
        left[0]=height[0];
        right[height.length-1]=height[height.length-1];
        for(int i=1;i<=height.length-1;i++){
            left[i]=height[i]>left[i-1]?height[i]:left[i-1];
        }
        for(int i=height.length-2;i>=0;i--){
            right[i]=height[i]>right[i+1]?height[i]:right[i+1];
        }
        for(int i=1;i<=height.length-2;i++){
            if(Math.min(left[i-1],right[i+1])-height[i]>0){
                ans=Math.min(left[i-1],right[i+1])-height[i];
            }else{
                ans=0;
            }
            sum=sum+ans;
        }
        return sum;
    }
}

具体分析：
1，
考虑下标为5的位置

要想水不漏，水就需要左边和右边高度最高的柱子，来给他兜底。
左边是红色的柱子，右边是绿色柱子，然后两者取较小值，再减去5位置自身的高度，这就是下标为5的位置可以装的最多水。
把每一个下标累加，就是总水量。
2，
如何记录i位置左边最高柱子，和右边最高柱子？就是这段代码
这是左

for(int i=1;i<=height.length-1;i++){
            left[i]=height[i]>left[i-1]?height[i]:left[i-1];
        }

这是右

for(int i=height.length-2;i>=0;i--){
            right[i]=height[i]>right[i+1]?height[i]:right[i+1];
        }

3，
这是累加

for(int i=1;i<=height.length-2;i++){
            if(Math.min(left[i-1],right[i+1])-height[i]>0){
                ans=Math.min(left[i-1],right[i+1])-height[i];
            }else{
                ans=0;
            }
            sum=sum+ans;
        }

---

双指针版本优化：

代码原理思考
动态规划里面，我们从暴力递归
到挂缓存表的递归
到从底到顶的动态规划
最后到没有数组的动态规划
为什么可以这样优化？？？？
是不是我们每次只用有限个数组里面的量，用完了就不再用了
因此，就可以用有限个变量，滚动更新

上面的优化思维可以悟一下
详细可以看我的动态规划，感悟每一步是如何优化的
一维动态规划

---

下面的双指针版本的代码：

class Solution {
    public int trap(int[] height) {
        int l=1;
        int r=height.length-2;
        int lmax=height[0];
        int rmax=height[height.length-1];
        int sum=0;
        while(l<=r){
            if(lmax<rmax){
                sum=sum+Math.max(0,lmax-height[l]);
                lmax=lmax>height[l]?lmax:height[l];
                l++;
            }else{
                sum=sum+Math.max(0,rmax-height[r]);
                rmax=rmax>height[r]?rmax:height[r];
                r--;
            }
        }
        return sum;
    }
}

解释：

1，

对于i位置的水量，我们其实只需要，left[i-1]和right[i+1]即可

因此可以设置两个变量，lmax和rmax，初始值为
height[0]和height[height.length-1]
再设置两个指针，l和r，初始值是1和height.length-2，从两边逼近
2，
对于下面代码的解释：

if(lmax<rmax){
                sum=sum+Math.max(0,lmax-height[l]);
                lmax=lmax>height[l]?lmax:height[l];
                l++;
            }else{
                sum=sum+Math.max(0,rmax-height[r]);
                rmax=rmax>height[r]?rmax:height[r];
                r--;
            }

由于我们是：先找出两边各自最大值，再比较得出两个最大值的较小值。

---

1，
如果lmax<rmax,我们考虑l位置的水量
如果lmax>rmax,我们考虑r位置的水量
这是是考虑l位置，
2，
对于l位置水量，需要left[l-1]和right[l+1]的较小值
3，
lmax等于left[l-1],虽然rmax不等于right[r+1],
但是，rmax肯定是小于等于right[l+1]的
lmax已经比rmax小了
4，
那么lmax肯定也比right[l+1]小
所以，lmax就是较小值
5，
得出l位置水量，并且累加即可

if(lmax<rmax){
                sum=sum+Math.max(0,lmax-height[l]);
                lmax=lmax>height[l]?lmax:height[l];
                l++;
            }

二，缺失的第一个整数问题

给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。

请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。

示例 1：

输入：nums = [1,2,0]
输出：3
解释：范围 [1,2] 中的数字都在数组中。
示例 2：

输入：nums = [3,4,-1,1]
输出：2
解释：1 在数组中，但 2 没有。
示例 3：

输入：nums = [7,8,9,11,12]
输出：1
解释：最小的正数 1 没有出现。

力扣链接

---

源码

class Solution {
    public int firstMissingPositive(int[] nums) {
        int l=0;
        int r=nums.length;
        int temp=0;
        while(l<r){
            if(nums[l]==l+1){
                l++;
            }else if(nums[l]<=l||nums[l]>=r+1||nums[nums[l]-1]==nums[l]){
                r--;
                temp=nums[l];
                nums[l]=nums[r];
                nums[r]=nums[l];
            }else{
                temp=nums[nums[l]-1];
                nums[nums[l]-1]=nums[l];
                nums[l]=temp;
            }
        }
        return l+1;
    }
}

思路：
1，
如果可以0位置放1
1位置放2
2位置放3
3位置放4
以此类推，直到l位置无法放l+1，返回l+1
2，
对于无法放置的数，准备一个垃圾区，通过一个r指针，来划分垃圾区
满足以下条件中的至少一个就为垃圾区

nums[l]<=l
nums[l]>=r+1
nums[nums[l]-1]==nums[l]

3，
把垃圾数放进垃圾区

r--;
temp=nums[l];
nums[l]=nums[r];
nums[r]=nums[l];

4，
如果不是垃圾
就进行这一步

temp=nums[nums[l]-1];
nums[nums[l]-1]=nums[l];
nums[l]=temp;