Leetcode Weekly Contest 260（前缀和、模拟、DP）

题目链接： Leetcode Weekly Contest 260

1、2016. Maximum Difference Between Increasing Elements

难度：Easy

代码：

class Solution {
    public int maximumDifference(int[] nums) {
        int n=nums.length;
        int min=nums[0];
        int res=-1;
        for(int i=1;i<n;i++){
            if(nums[i]>min){
                res=Math.max(res,nums[i]-min);
            }
            min=Math.min(min,nums[i]);
        }
        return res;
    }
}

2、2017. Grid Game

难度：Medium

思路：

参考高赞回答，注意robot1得分最高时不一定能使robot2得分最低，因为矩阵只有两行，所以对robot1转弯的位置进行遍历。

代码：

class Solution {
    public long gridGame(int[][] grid) {
        int n=grid[0].length;
        long[] prefix1=new long[n+1];
        long[] prefix2=new long[n+1];
        for(int i=0;i<n;i++){
            prefix1[i+1]=prefix1[i]+grid[0][i];
            prefix2[i+1]=prefix2[i]+grid[1][i];
        }
        long max=0;
        long res=Long.MAX_VALUE;
        //res是long类型，之前用Integer.MAX_VALUE然后debug了好久没找到原因(呜呜呜)
        for(int col=0;col<n;col++){
            //要么取第一行不是0的剩余部分，要么取第二行不是0的剩余部分
            max=Math.max(prefix1[n]-prefix1[col+1],prefix2[col]);
            res=Math.min(max,res);
        }
        return res;
    }
}

3、2018. Check if Word Can Be Placed In Crossword

难度：Medium

思路：

参考高赞回答，遍历每一行和每一列，将两个# 之间的字符当作一个槽位（矩阵边界也视作 #），遍历（正序+倒序）每个槽位，判断 word 能否恰好填入该槽位。

代码

class Solution {
    public boolean placeWordInCrossword(char[][] board, String word) {
        int m=board.length,n=board[0].length;
        char[] s=word.toCharArray();
        int len=s.length;
        //按行遍历
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(board[i][j]=='#'){
                    continue;
                }
                int j0=j;
                boolean forward=true,back=true;//正向匹配和逆向匹配
                for(j=j0;j<n&&board[i][j]!='#';j++){
                    if(j>=j0+len||(board[i][j]!=' '&&board[i][j]!=s[j-j0])){
                        forward=false;
                    }
                    if(j>=j0+len||(board[i][j]!=' '&&board[i][j]!=s[len-1-(j-j0)])){
                        back=false;
                    }
                }
                if(j-j0==len&&(forward||back)){
                    return true;
                }
            }
        }
        //按列遍历
        for(int j=0;j<n;j++){
            for(int i=0;i<m;i++){
                if(board[i][j]=='#'){
                    continue;
                }
                int i0=i;
                boolean down=true,up=true;//正向匹配和逆向匹配
                for(i=i0;i<m&&board[i][j]!='#';i++){
                    if(i>=i0+len||(board[i][j]!=' '&&board[i][j]!=s[i-i0])){
                        down=false;
                    }
                    if(i>=i0+len||(board[i][j]!=' '&&board[i][j]!=s[len-1-(i-i0)])){
                        up=false;
                    }
                }
                if(i-i0==len&&(down||up)){
                    return true;
                }
            }
        }
        return false;
    }
}

4、2019. The Score of Students Solving Math Expression

难度：Hard

思路

动态规划算出表达式所有可能的结果。

代码

class Solution {
    public int scoreOfStudents(String s, int[] answers) {
        char[] arr=s.toCharArray();
        int ans=getValue(s);
        //System.out.println("ans="+ans);
        int len=s.length();
        Set<Integer>[][] dp=new Set[len][len];
        //dp[i][j]表示s[i,j]所有运算结果的集合
        for(int i=0;i<len;i+=2){
            dp[i][i]=new HashSet<>();
            dp[i][i].add(arr[i]-'0');
        }
        for(int end=2;end<len;end+=2){
            for(int start=end-2;start>=0;start-=2){
                dp[start][end]=new HashSet<>();
                for(int k=start;k<end;k+=2){
                    for(Integer a:dp[start][k]){
                        for(Integer b:dp[k+2][end]){
                            if(arr[k+1]=='*'){
                                if(a*b<=1000){//剪枝
                                    dp[start][end].add(a*b);
                                }
                            }
                            else{
                                if(a+b<=1000){
                                    dp[start][end].add(a+b);
                                }
                            }
                        }
                    }
                }
            }
        }
        int[] count=new int[1010];
        for(int n:answers){
            count[n]++;
        }
        int score=0;
        for(Integer n:dp[0][len-1]){
            //System.out.println(n);
            if(n==ans){
                score+=(5*count[n]);
            }
            else{
                score+=(2*count[n]);
            }
        }
        return score;
    }
    public int getValue(String s){
        char[] arr=s.toCharArray();
        Stack<Integer> stack=new Stack<>();
        int ans=0;
        stack.push(arr[0]-'0');
        for(int i=1;i<arr.length;i++){
            if(arr[i]=='+'){
                stack.push(arr[i+1]-'0');
            }
            if(arr[i]=='*'){
                int temp=stack.pop()*(arr[i+1]-'0');
                stack.push(temp);
            }
        }
        while(!stack.isEmpty()){
            ans+=stack.pop();
        }
        return ans;
    } 
}