【Leecode笔记之java】第11周上（11.16-11.18）动态规划专题结束

【11.16】三步问题

分析：当楼梯阶数为0或1时，就只有一种解法；当楼梯阶数为2时，有两种解法；当阶数为3时，有4种解法；当阶数大于3时，例如四个阶梯，解法为走到第3阶后的走法O（3），加上走到第二阶后的走法O（2），加上走到第一阶的走法O（1）；推广到第n阶，动态方程为O（n） = O(n-1)+O(n-2)+O(n-3)

方法一：快速幂；利用矩阵构建动态方程。

方法二：直接用动态规划。

//执行用时：24 ms, 在所有 Java 提交中击败了91.64%的用户
//内存消耗：42 MB, 在所有 Java 提交中击败了64.53%的用户
import java.util.*;
class Solution {
    public int waysToStep(int n) {
        if(n == 1) return 1;
        if(n == 2) return 2;
        if(n == 3) return 4;

        int dp[] = new int[n];
        dp[0] = 1;
        dp[1] = 2;
        dp[2] = 4;
        for(int i = 3;i < n;i++){
            dp[i] = ((dp[i-3] + dp[i-2])% 1000000007 + dp[i-1]) % 1000000007;
        } 
        return dp[n-1];
    }
}

【11.17】连续数组

分析：最基础的动态规划，一遍AC，心情非常好嘻嘻。

//执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
//内存消耗：35 MB, 在所有 Java 提交中击败了92.71%的用户
class Solution {
    public int climbStairs(int n) {
        if(n <= 2) return n;

        int[] dp = new int[n];
        dp[0] = 1;
        dp[1] = 2;
        for(int i = 2;i < n;i++){
            dp[i] = dp[i-1] + dp[i-2];
        } 
        return dp[n-1];
    }
}

第二题：连续数列

分析：注意，是后边的数加上前面的最优解假如非最佳，那么就不加；
时刻要清醒，自己的dp数组存的到底是什么。

//执行用时：1 ms, 在所有 Java 提交中击败了94.95%的用户
//内存消耗：38.4 MB, 在所有 Java 提交中击败了84.27%的用户

class Solution {
    public int maxSubArray(int[] nums) {
        
        int len = nums.length;
        if(len == 0) return 0;
        if(len == 1) return nums[0];

         int[] dp= new int[len];
         dp[0] = nums[0];
        
        int max = nums[0];
        for(int i = 1;i < len;i++){
            dp[i] = Math.max(nums[i],nums[i]+dp[i-1]);
            max = Math.max(dp[i],max);//这句非常重要,可以少循环一次
        }
        return max;
    }
}

第三题：判断子序列

分析：设置双指针，一个指向待判断序列，一个指向原始字符串，在没有遍历完原始字符串之前，假如待判断序列的所有序列全部找到，那么返回true，否则返回false。因为相对顺序和原字符串一致才算是真的子字符串。
另外要注意的是，在原始字符串上遍历时，当找到一个待判断序列中的一个字符后，需要从当前位置继续循环过程，而不是重新来一次。

//执行用时：0 ms, 在所有 C 提交中击败了100.00%的用户
//内存消耗：5.6 MB, 在所有 C 提交中击败了18.97%的用户
bool isSubsequence(char * s, char * t){
    while(*s && *t){
        if(*s == *t){
            s++;
        }
        t++;
    }
    if(*s == '\0'){
        return true;
    }
    else{
        return false;
    }
}

//执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
//内存消耗：36.6 MB, 在所有 Java 提交中击败了64.27%的用户
class Solution {
    public boolean isSubsequence(String s, String t) {
        int index = -1;
        for(char c:s.toCharArray()){
            index = t.indexOf(c,index+1);
            if(index == -1) return false;
        }
        return true;
    }
}

##小葵花java课堂开课啦——java方法###
toCharArray方法：将字符串转换为字符数组；
s.toCharArray();

indexOf方法：

public int indexOf(int ch )

//1.返回指定字符在字符串中第一次出现处的索引，如果字符串中没有，则返回-1

public int indexOf(int ch, int fromIndex)

//2.返回从fromIndex位置开始查找指定字符在字符串中第一次出现处的索引，如果没有，返回-1；

int indexOf(String str)

//3.返回指定字符在字符串中第一次出现处的索引，没有返回-1

int indexOf(String str, int fromIndex)
//4.同2

【11.18】滑动窗口的最大值

分析：由示例出发，如果是普通的比较，那么每一次滑动窗口的移动都要遍历整个滑动窗口，显然重复的工作量较大。合理的做法是，当滑动窗口还没有移动的时候，比较出滑动窗口里边的k个值，用一个变量存放最大值，然后每移动一次滑动窗口，就和最新进来的那个元素进行比较

（Q：这里要注意的是，如果刚好窗口移动丢失了之前的最大值，该怎么处理？）
（A：用一个条件语句判断，如果max == nums[i]，那么需要重新遍历一次窗口）

窗口的位置主要有：nums.length - k + 1

动态规划的动态方程：

//执行用时：3 ms, 在所有 Java 提交中击败了93.73%的用户
//内存消耗：46.6 MB, 在所有 Java 提交中击败了76.60%的用户
//其实也就是在暴力搜索上稍微优化了一丢丢
class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 0 || nums == null) return new int[0];

        int[] dp = new int[nums.length - k + 1];
        int max = nums[0];
        for(int j = 1;j < k;j++){
            max = Math.max(max,nums[j]);
        }
        dp[0] = max;

        for(int i = 1;i <= nums.length-k;i++){
            if(dp[i-1] == nums[i-1]){
                max = nums[i];
                for(int j = i;j < i+k;j++){
                    max = Math.max(max,nums[j]);
                }
                dp[i] = max;
            }
            else{
                dp[i] = Math.max(dp[i-1],nums[i+k-1]);
            }
        }
        return dp;
    }
}

//单调栈：实现随意入栈、出栈情况下O(1)时间获取栈内最小值。
//与本题不同的是，“出栈操作”删除的是“列表尾部元素”
//而“窗口滑动”删除的是“列表首部元素”
//贴一下大佬的单调栈解法
class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 0 || k == 0) return new int[0];
        Deque<Integer> deque = new LinkedList<>();
        int[] res = new int[nums.length - k + 1];
        for(int j = 0, i = 1 - k; j < nums.length; i++, j++) {
            if(i > 0 && deque.peekFirst() == nums[i - 1])
                deque.removeFirst(); // 删除 deque 中对应的 nums[i-1]
            while(!deque.isEmpty() && deque.peekLast() < nums[j])
                deque.removeLast(); // 保持 deque 递减
            deque.addLast(nums[j]);
            if(i >= 0)
                res[i] = deque.peekFirst();  // 记录窗口最大值
        }
        return res;
    }
}

作者：jyd
链接：https://leetcode-cn.com/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof/solution/mian-shi-ti-59-i-hua-dong-chuang-kou-de-zui-da-1-6/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

//减少冗余的判断操作
class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 0 || k == 0) return new int[0];
        Deque<Integer> deque = new LinkedList<>();
        int[] res = new int[nums.length - k + 1];
        for(int i = 0; i < k; i++) { // 未形成窗口
            while(!deque.isEmpty() && deque.peekLast() < nums[i])
                deque.removeLast();
            deque.addLast(nums[i]);
        }
        res[0] = deque.peekFirst();
        for(int i = k; i < nums.length; i++) { // 形成窗口后
            if(deque.peekFirst() == nums[i - k])
                deque.removeFirst();
            while(!deque.isEmpty() && deque.peekLast() < nums[i])
                deque.removeLast();
            deque.addLast(nums[i]);
            res[i - k + 1] = deque.peekFirst();
        }
        return res;
    }
}

作者：jyd
链接：https://leetcode-cn.com/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof/solution/mian-shi-ti-59-i-hua-dong-chuang-kou-de-zui-da-1-6/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

###小葵花Java课堂开课啦——关于Deque###
参考链接：https://blog.csdn.net/u013967628/article/details/85210036