以赛促练-力扣第86场双周赛反思（持续更新中）

本次双周赛是晚上和兄弟们组队打的，慢慢把大家刷题的积极性调动起来，会让我觉得其实刷题也不是那么无趣的。

本次周赛A了三题，第3题本身是不想在写了，在兄弟们刷题的氛围讨论中，尝试去写，最后在1小时28分才A掉。

T1第一眼没注意到是长度为2的「子数组」，子数组必然是连着的两个，因此用O(N)从前往后枚举所有的和的情况，并用Set记录是否出现过就可以。

T2.严格回文的数字

这题没想到是道脑筋急转弯，因为它说一个整数 n 在 b 进制下（b 为 2 到 n - 2 之间的所有整数），这个b的范围是比较大了，可以尝试着找找规律了。

先贴上我的暴力枚举解法：

class Solution {
    public boolean isStrictlyPalindromic(int n) {
        for(int b=2;b<=n-2;b++){
            if(!isValid(n,b)) return false;
        }
        return true;
    }
    public boolean isValid(int n,int b){
        StringBuilder sb=new StringBuilder();
        while(n!=0){
            int digit=n%b;
            n/=b;
            sb.append(digit);
        }
        int len=sb.length();
        int i=0;
        int j=len-1;
        while(i<=j){
            if(sb.charAt(i)!=sb.charAt(j)) return false;
            i++;
            j--;
        }
        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

别人的脑筋急转弯解法：
对于n>=5，他们的(n-2)进制表示都是12，不是回文数字，直接返回false。特殊的，当n=4的时候，其2进制表示还会在2² 的上面有一位，100，但是也不是回文的。

class Solution {
    public boolean isStrictlyPalindromic(int n) {
        return false;
    }
}
1
2
3
4
5

T3.被列覆盖的最多行数

这题关键在于如何枚举选中的cols列，把所有可选列的情况列举出来，然后分别进行覆盖的运算。那就是两个问题，怎么去枚举列以及在选定列的情况下，怎么计算当前的行覆盖数。

枚举列的话相当于就是在n个数中枚举cols个数的组合情况，想到了回溯法，在叶子节点即depth==cols的时候计算覆盖行数并return。然后计算行覆盖数，我们得考虑到位运算和补集思想，没选到的列中存在1的那行，最后一定不能被覆盖，因此我们将非选中列中的1能够组成的二进制数cur表示出来，然后统计cur中1的个数，就是不能覆盖的行数。

class Solution {
    int[][]mat;
    int m;
    int n;
    boolean[]vis;
    int cols;
    int res;
    public int maximumRows(int[][] _mat, int _cols) {
        mat=_mat;
        m=mat.length;
        n=mat[0].length;
        cols=_cols;
        vis=new boolean[n];
        backTracing(0,0);
        
        return res;
    }
    
    public void backTracing(int start,int depth){
        if(depth==cols){
            res=Math.max(res,maxRow(mat,vis));
            return;
        } 
        for(int i=start;i<n;i++){
            if(!vis[i]){
                vis[i]=true;
                backTracing(i+1,depth+1);
                vis[i]=false;
            }
        }
    }
    
    public int maxRow(int[][]mat,boolean[]vis){
        int res=0;
        int cur=0;
        //位运算表示非选中列中的1能够组成的二进制数cur表示出来
        for(int i=0;i<n;i++){
            if(!vis[i]){
                for(int j=0;j<m;j++){
                    cur|=mat[j][i]<<j;
                }
            }
        }
        //统计cur中1的个数，就是不能覆盖的行数
        for(int j=0;j<m;j++){
            res+=(cur>>j&1)==1?1:0;
        }
        return m-res;
    }    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

还可以通过另一种枚举的方式把所有选中的列找出来，即通过二进制表示列，把0到1<

在进行行覆盖判断的时候，如果当前位置是1并且没有被覆盖，则该行没被覆盖。

class Solution {
    public int maximumRows(int[][] mat, int cols) {
        int m=mat.length;
        int n=mat[0].length;
        int res=0;
        //枚举列表示的所有二进制
        for(int i=0;i<1<<n;i++){
            int cnt=0;
            int temprow=0;
            //当前枚举的选中列
            for(int j=0;j<n;j++) cnt+=(i>>j&1)==1?1:0;
            if(cnt!=cols) continue;

            for(int ii=0;ii<m;ii++){
                int jj;
                for(jj=0;jj<n;jj++){
                    //当前行中有1，但是对应的列却没有被选中
                    if(mat[ii][jj]==1&&(i>>jj&1)!=1) break;
                }
                //当前行全部满足条件，没有提前break
                if(jj==n)temprow++;
            }
            res=Math.max(temprow,res);
        }
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

T4.预算内的最多机器人数目

单调队列+滑动窗口求最大窗口。单调队列可以O(N)的复杂度记录当前数组的最大值，队列中存储下标，同时滑动窗口的限制条件需要满足求最大窗口，我们就可以维护一个左边界left。对于单调队列不熟悉的话，可以参考我写的另一篇文章->算法学习-单调双端队列。

class Solution {
    public int maximumRobots(int[] chargeTimes, int[] runningCosts, long budget) {
        long sum=0;
        Deque<Integer> maxq=new ArrayDeque<>();
        int len=chargeTimes.length;
        int res=0;
        for(int left=0,right=0;right<len;right++){
            //维护到当前为止的和
            sum+=runningCosts[right];
            //维护到当前为止的最大值
            while(!maxq.isEmpty()&&chargeTimes[right]>chargeTimes[maxq.peekLast()]){
                maxq.pollLast();
            }
            maxq.offerLast(right);

            //维护当前窗口的范围
            while(!maxq.isEmpty()&&chargeTimes[maxq.peekFirst()]+1L*(right-left+1)*sum>budget){
                //左边界缩小时检查队列中的数字是否需要跟着改变
                if(maxq.peekFirst()==left) maxq.pollFirst();
                sum-=runningCosts[left++];
            }
            res=Math.max(res,right-left+1);
        }
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26