[LeetCode] 第166场周赛题解

第一题：

按题意模拟。

public class Solution {
    public int subtractProductAndSum(int n) {
        String s=Integer.toString(n);
        int a=1;
        int b=0;
        for(int i=0;i<s.length();i++) {
        	a*=s.charAt(i)-'0';
        	b+=s.charAt(i)-'0';
        }
        return a-b;
    }
}

第二题:

每种分组开个桶记录一下就好了。

public class Solution {
    public List<List<Integer>> groupThePeople(int[] g) {
    	ArrayList<Integer>[] buc=new ArrayList[g.length+1];
    	ArrayList<List<Integer>> ans=new ArrayList<>();
    	
    	for(int i=0;i<g.length;i++) {
    		if(buc[g[i]]==null)
    			buc[g[i]]=new ArrayList<Integer>();
    		buc[g[i]].add(i);
    		if(buc[g[i]].size()==g[i]) {
    			ans.add((List<Integer>) buc[g[i]].clone());
    			buc[g[i]].clear();
    		}
    	}
    	return ans;
    }
}

第三题：

一眼二分。

public class Solution {
	public boolean check(int k,int[] nums,int x) {
		int sum=0;
		for(int v:nums)
			sum+=(v+x-1)/x;
		return sum<=k;
	}
	
    public int smallestDivisor(int[] nums, int k) {
        int l=1;
        int r=(int) 1e6;
        int ans=-1;
        
        while(l<=r) {
        	int mid=(l+r)>>1;
        	if(check(k,nums,mid)) {
        		r=mid-1;
        		ans=mid;
        	}
        	else
        		l=mid+1;
        }
        return ans;
    }
}

第四题：

最多有2^9种状态，直接记录每种状态的最小花费，然后dfs即可。

public class Solution {
	public int[] cost;
	
	public int calc(int[][] mat) {
		int ans=0;
		for(int[] temp:mat)
        	for(int v:temp)
        		ans=ans*2+v;
		return ans;
	}
	
	public void change(int[][] mat,int i,int j,int n,int m) {
		mat[i][j]^=1;
		if(i-1>=0)
			mat[i-1][j]^=1;
		if(i+1<n)
			mat[i+1][j]^=1;
		if(j-1>=0)
			mat[i][j-1]^=1;
		if(j+1<m)
			mat[i][j+1]^=1;
	}
	
	public void dfs(int[][] mat,int step,int n,int m) {
		int state=calc(mat);
		cost[state]=Math.min(cost[state], step);
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				change(mat,i,j,n,m);
				int nowState=calc(mat);
				if(cost[nowState]>step+1) {
					dfs(mat,step+1,n,m);
				}
				change(mat,i,j,n,m);
			}
		}
	}
	
    public int minFlips(int[][] mat) {
        int n=mat.length;
        int m=mat[0].length;
        int all=1<<(n*m);
        cost=new int[all];
        Arrays.fill(cost, Integer.MAX_VALUE);
        int now=0;
        for(int[] temp:mat)
        	for(int v:temp)
        		now=now*2+v;
        cost[now]=0;
        dfs(mat,0,n,m);
        return cost[0]==Integer.MAX_VALUE?-1:cost[0];
    }
}