Leetcode Weekly Contest 276（贪心、DFS、动态规划）

题目链接： Leetcode Weekly Contest 276

1、2133. Check if Every Row and Column Contains All Numbers

难度：Easy

思路

模拟

代码：

class Solution {
    public String[] divideString(String s, int k, char fill) {
        int size=s.length()%k==0?s.length()/k:s.length()/k+1;
        String[] res=new String[size];
        for(int i=0;i<s.length()/k;i++){
            if((i+1)*k<=s.length()){
                res[i]=s.substring(i*k,(i+1)*k);
            }
        }
        if(s.length()%k!=0){
            String s1=s.substring(s.length()/k*k);
            int num=k-s1.length();
            while(num-->0){
                s1=s1+fill;
            }
            res[size-1]=s1;
        }
        return res;
    }
}

2、2134. Minimum Swaps to Group All 1’s Together II

难度：Medium

思路：

贪心，将target变为1，优先采取除2的操作，如果不能整除则减1。

代码：

class Solution {
    public int minMoves(int target, int maxDoubles) {
        int res=0;
        while(target!=1){
            if(maxDoubles>0){
                 if(target%2==0){
                     target/=2;
                     res++;
                     maxDoubles--;
                 }
                else{
                    target--;
                    res++;
                    if(target>1){
                        target/=2;
                        res++;
                        maxDoubles--;
                    }
                }
            }
            else{
                res+=(target-1);
                target=1;
            }
        }
        return res;
    }
}

3、2140. Solving Questions With Brainpower

难度：Medium

思路：

动态规划或DFS。

代码

DFS+Memoization

class Solution {
    public long mostPoints(int[][] questions) {
        int n=questions.length;
        long[] dp=new long[n];
        return dfs(questions,0,dp);
    }
    public long dfs(int[][] Q,int i,long[] dp){
        if(i>=Q.length){
            return 0;
        }
        if(dp[i]>0){
            return dp[i];
        }
        int point=Q[i][0],jump=Q[i][1];
        return dp[i]=Math.max(point+dfs(Q,i+Q[i][1]+1,dp),dfs(Q,i+1,dp));
    }
}

DP

   public long mostPoints(int[][] questions) {
       int n=questions.length;
       long[] dp=new long[n];
       //dp[i]表示从下标i处开始所能获得的最高分数
       long res=0;
       for(int i=n-1;i>=0;i--){
           int next=i+questions[i][1]+1;
           if(next<n){
               dp[i]=Math.max(questions[i][0]+dp[next],res);
           }
           else{
               dp[i]=Math.max(questions[i][0],res);
           }
           res=Math.max(res,dp[i]);
       }
       return res;
   } 

4、2141. Maximum Running Time of N Computers

难度：Hard

思路

参考高赞回答。
如果电池所有的能量都用完，则n台电脑能一起工作 sum/n，如果数组中的最大值大于sum/n，则这个电池会有一些电量不会全部用完，会有一些电量被浪费，将这个电池一直给某台电脑供电，问题转化为剩下的电池给n-1台电脑供电，最多能让这n-1台电脑一起工作多久。知道新数组中的最大值小于等于新数组的最大值，说明电量最多的电池能量不会被浪费，所有的电池的电量都能全部用完。

代码

class Solution {
    public long maxRunTime(int n, int[] batteries) {
        long sum=0;
        for(int b:batteries){
            sum+=b;
        }
        Arrays.sort(batteries);
        long res=0;
        for(int i=batteries.length-1;i>=0;i--){
            if(batteries[i]>sum/n){
                sum-=batteries[i];
                n--;
            }
            else{
                res=sum/n;
                break;
            }
        }
        return res;
    }
}