leetcode第216场周赛

第216场周赛

5605. 检查两个字符串数组是否相等

流程题，按部就班。。。。

class Solution {
    public boolean arrayStringsAreEqual(String[] word1, String[] word2) {
        String s1="";
        String s2="";
        for(String word:word1){
            s1+=word;
        }
        for(String word:word2){
            s2+=word;
        }
        return s1==s2;
    }
}

5606. 具有给定数值的最小字符串

看数据的大小范围可以得到一定有解，利用贪心算法，从后面推算前面的最小字符：

class Solution {
    public String getSmallestString(int n, int k) {
        StringBuilder res=new StringBuilder();
        //贪心算法，从后面推算前面：
        for(int i=0;i<n;i++){
            int index=n-i-1;
            if(k<=index*26){
                res.append("a");
                k--;
            }else{
                char cur=(char)('a'+k-index*26-1);
                res.append(cur);
                k-=k-index*26;
            }
        }
        return res.toString();
    }
}

5607. 生成平衡数组的方案数

我最开始的傻瓜做法，运行是没有问题的，但是时间复杂度超了。。。。。因为我不熟悉前缀和的做法。

class Solution {
    private int count=0;
    private int sum=0;
    public int waysToMakeFair(int[] nums) {
        
        for(int num:nums){
            sum+=num;
        }
        
        for(int i=0;i<nums.length;i++){
            help(nums,i,sum);
        }
        
        return count;
    }
    public void help(int []nums,int index,int sum){
        int sum1=0;
        int left=index-1;
        int right=index+2;
        while(left>=0){
            sum1+=nums[left];
            left-=2;
        }
        while(right<nums.length){
            sum1+=nums[right];
            right+=2;
        }
        if(sum-sum1-nums[index]==sum1){
            count++;
        }
    }
}

思路：前缀和

对于被删除的index，index之前的奇数和与index之后的偶数和之和，index之间的偶数和与index之后的奇数和，二者是不是相等，如果相等，count就++：

class Solution {
    public int waysToMakeFair(int[] nums) {
        int n=nums.length;
        int []jishu=new int [n+1];
        int []oushu=new int [n+1];
        for(int i=1;i<=n;i++){
            jishu[i]=jishu[i-1]+((i-1)%2==0?0:nums[i-1]);
            oushu[i]=oushu[i-1]+((i-1)%2==0?nums[i-1]:0);
        }
        int count=0;
        for(int i=1;i<=n;i++){
            int sum1=jishu[i-1]+oushu[n]-oushu[i];
            int sum2=oushu[i-1]+jishu[n]-jishu[i];
            if (sum1 == sum2) count++;
        }
        return count;
    }
}

优化空间复杂度，用一个奇数和和一个偶数和，不断计算去代替奇数和数组和偶数和数组：

class Solution {
    public int waysToMakeFair(int[] nums) {
        int len=nums.length;
        int jishu=0;
        int oushu=0;
        //统计数组中奇数和偶数的和：
        for(int i=0;i<len;i++){
            if(i%2==0){
                oushu+=nums[i];
            }else{
                jishu+=nums[i];
            }
        }
        int count=0;
        for(int i=len-1;i>=0;i--){
            //如果被删除的是奇数：
            if(i%2==1){
                jishu-=nums[i];
                if(jishu==oushu){
                    count++;
                }
                oushu+=nums[i];
            }
            //如果被删除的是偶数：
            else{
                oushu-=nums[i];
                if(jishu==oushu){   
                    count++;
                }
                jishu+=nums[i];
            }
        }
        return count;
    }
}

5608. 完成所有任务的最少初始能量

minimum - actual 的结果，就是”完成这个任务以后，剩余的能量值的最小值“。根据minimum - actual 的结果排序，为了完成所有的任务，显然希望剩余的能量值越多越好。所以，我们应该先完成“使得剩余的能量值多的任务”，即 minimum - actual 大的任务；这样有更多的能量，去完成别的任务。

class Solution {
    public int minimumEffort(int[][] tasks) {
        Arrays.sort(tasks,(a,b) ->((b[1]-b[0])-(a[1]-a[0])));
        int res=0;
        int sum=0;
        for(int []task:tasks){
            res=Math.max(res,sum+task[1]);
            sum+=task[0];
        }
        return res;
    }
}