LeetCode每日刷题：（单调队列+队列+二叉树+字符串）&（动态规划+递归）

1.单调队列：滑动窗口的最大值

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        // //1.暴力法
        // int n=nums.length;
        // if(n==0 || k==0) return new int[0];
        // int[] res=new int[n-k+1];
        // for(int i=0;i<n-k+1;i++){
        //     int max=nums[i];
        //     for(int j=i;j<i+k;j++){
        //         max=Math.max(max,nums[j]);
        //     }
        //     res[i]=max;
        // }
        // return res;

        //2.单调队列
        //队列里存放的是当前窗口的值，并且要单调递减，这样队列首部就是窗口最大值
        //（1）当窗口要右移时，如果nums[i-1]是当前窗口最大值，要从队列中移除nums[i-1]
        //（2）当向窗口中添加元素nums[j]时，要移除窗口中小于nums[j]的值
        //（3）向队列尾部添加元素nums[j]
        int n=nums.length;
        if(n==0 || k==0) return new int[0];
        int[] res=new int[n-k+1];
        Deque<Integer> deque=new LinkedList<>();
        for(int j=0,i=1-k;j<nums.length;j++,i++){
            if(i>0 && deque.peekFirst()==nums[i-1]){
                deque.removeFirst();
            }
            while(!deque.isEmpty() && nums[j]>deque.peekLast()){
                deque.removeLast();
            }
            deque.addLast(nums[j]);
            if(i>=0){
                res[i]=deque.peekFirst();
            }
        }
        return res;
    }
}

2.队列：队列的最大值

class MaxQueue {
    Deque<Integer> quque;//数据队列
    Deque<Integer> deque;//辅助双端队列
    public MaxQueue() {
        quque=new LinkedList<Integer>();
        deque=new LinkedList<Integer>();
    }
    
    public int max_value() {
        if(deque.isEmpty()){
            return -1;
        }else{
            return deque.peekFirst();
        }
    }
    
    public void push_back(int value) {
        quque.offer(value);
        while(!deque.isEmpty() && deque.peekLast()<value){
            deque.removeLast();
        }
        deque.offerLast(value);
    }
    
    public int pop_front() {
        if(quque.isEmpty()){
            return -1;
        }
        int res=quque.poll();
        if(res==deque.peekFirst()){
            deque.pollFirst();
        }        
        return res;
    }
}

/**
 * Your MaxQueue object will be instantiated and called as such:
 * MaxQueue obj = new MaxQueue();
 * int param_1 = obj.max_value();
 * obj.push_back(value);
 * int param_3 = obj.pop_front();
 */

借助双端队列做辅助

3.动态规划：n个骰子的点数

大神的题解。。。懵懵的

class Solution {
    public double[] dicesProbability(int n) {
        //动态规划：
        //状态：（1）已经使用骰子的个数（2）骰子总和 dp[i][j]
        int[][] dp=new int[n+1][6*n+1];
        //base case
        for(int i=1;i<=6;i++){
            dp[1][i]=1;
        }
        for(int i=2;i<=n;i++){//骰子个数
            for(int j=i;j<=6*i;j++){//骰子总和
                for(int k=1;k<=6 && k<=j;k++){//骰子拆分dianshu
                    dp[i][j]+=dp[i-1][j-k];
                }
            }
        }
        double[] ans=new double[6*n-n+1];
        for(int i=n;i<=6*n;i++){
            ans[i-n]=((double)dp[n][i])/Math.pow(6,n);
        }
        return ans;
    }
}

4.二叉树递归：二叉树的最近公共祖先

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root== null || root==p || root==q){
            return root;
        }
        TreeNode left=lowestCommonAncestor(root.left,p,q);
        TreeNode right=lowestCommonAncestor(root.right,p,q);
        if(left==null) return right;
        if(right==null) return left;
        return root;
    }
}

5.字符串：把字符串转换成整数

class Solution {
    public int strToInt(String str) {
        char[] c = str.trim().toCharArray();
        if(c.length == 0) return 0;

        int res = 0, bndry = Integer.MAX_VALUE / 10;
        int i = 1, sign = 1;
        if(c[0] == '-') sign = -1;
        else if(c[0] != '+') i = 0;

        for(int j = i; j < c.length; j++) {
            if(c[j] < '0' || c[j] > '9') break;
            if(res > bndry || res == bndry && c[j] > '7') return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
            res = res * 10 + (c[j] - '0');
        }
        
        return sign * res;
    }
}