Leetcode Weekly Contest 277（二进制枚举）

吐槽一下本次周赛，前三题都是简单的模拟题，完全拼手速。

题目链接： Leetcode Weekly Contest 277

1、2148. Count Elements With Strictly Smaller and Greater Elements

难度：Easy

代码：

class Solution {
public:
    int countElements(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        int n=nums.size();
        int min=nums[0];
        int max=nums[n-1];
        int res=0;
        for(int i=0;i<n;i++){
            if(nums[i]>min&&nums[i]<max){
                res++;
            }
        }
        return res;
    }
};

2、2149. Rearrange Array Elements by Sign

难度：Medium

代码：

class Solution {
public:
    vector<int> rearrangeArray(vector<int>& nums) {
        vector<int> res;
        int n=nums.size();
        int i=0,j=0;
        while(res.size()!=n){
            while(i<n&&nums[i]<0){
                i++;
            }
            res.push_back(nums[i]);
            i++;
            while(j<n&&nums[j]>0){
                j++;
            }
            res.push_back(nums[j]);
            j++;
        }
        return res;
    }
};

3、2150. Find All Lonely Numbers in the Array

难度：Medium

代码

class Solution {
    public List<Integer> findLonely(int[] nums) {
        List<Integer> res=new ArrayList<>();
        Map<Integer,Integer> map=new HashMap<>();
        for(int n:nums){
            map.put(n,map.getOrDefault(n,0)+1);
        }
        for(int k:map.keySet()){
            if(map.get(k)==1&&!map.containsKey(k-1)&&!map.containsKey(k+1)){
                res.add(k);
            }
        }
        return res;
    }
}

4、2151. Maximum Good People Based on Statements

难度：Hard

思路

因为数据量比较小，可以对哪些人是好人进行暴力枚举，然后再判断枚举的情况是否符合题意。假设有$n$个人，用一个$n$位的二进制数来进行枚举，每一位代表一个人，1表示是好人，0表示不是好人。二进制数的范围是0…0 ~ 1…1（$n$个1）,转换到十进制就是0~ $2^n-1$。这里假设最低位表示person[0]是不是好人，最高位表示person[n-1]是不是好人。对每种枚举的情况进行判断，看是否会产生矛盾，如果不矛盾，说明这种情况是符合题意的。

因为坏人可能说真话也可能说假话，所以我们不关心坏人。好人说的话一定是真话，我们要判断所有好人说的真话之间会不会产生矛盾。好人认为的好人一定是好人，我们需要把好人以及被好人认为是好人的人都找出来，然后判断他们所说的话是否会相互矛盾。矛盾的情况有以下两种：

1. 一个人是好人，但被另一个好人认为是坏人。
2. 两个好人A和B对于除他们以外的其他人的判断不同，如A认为这个人是好人但B认为这个人是坏人。

代码

class Solution {
    public int maximumGood(int[][] a) {
        int n=a.length;
        int m=(1<<n)-1;
        int[] good=new int[n];
        int res=0;
        for(int i=0;i<=m;i++){
            int pos=0;
            int count=0;
            Arrays.fill(good,0);
            int state=i;
            while(state>0){//状态压缩
                good[pos]=state&1;
                if(good[pos]==1){
                    count++;
                }
                state=state>>1;
                pos++;
            }
            //找出所有的好人
            for(int idx=0;idx<n;idx++){
                if(good[idx]==1){
                    //好人说的话为真，所以好人认为的好人一定是好人
                    for(int j=0;j<n;j++){
                        if(a[idx][j]==1){
                            good[j]=1;
                        }
                    }
                }
            }
            //将以上代码重复一次，防止遗漏好人。
            //比如person[n-1]认为person[0]是好人，那么需要回过头把person[0]
            //认为的好人都标记为好人
            for(int idx=0;idx<n;idx++){
                if(good[idx]==1){
                    //好人说的话为真，所以好人认为的好人一定是好人
                    for(int j=0;j<n;j++){
                        if(a[idx][j]==1){
                            good[j]=1;
                        }
                    }
                }
            }

            boolean flag=true;
            for(int j=0;flag&&j<n;j++){
                if(good[j]==1){
                    for(int k=0;k<n;k++){
                        //k认为j是坏人或者j认为k是坏人，矛盾
                        if(k!=j&&good[k]==1&&(a[k][j]==0||a[j][k]==0)){
                            flag=false;
                            break;
                        }
                        //如果j和k两个好人之间对其它人的判断相互矛盾
                        if(k!=j&&good[k]==1){
                            for(int idx=0;idx<n;idx++){
                                if(a[j][idx]!=a[k][idx]&&(a[j][idx]!=2)&&(a[k][idx]!=2)){
                                    flag=false;
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            if(flag){
                res=Math.max(res,count);
            }
        }
        return res;
    }
}