[LeetCode]第163场周赛题解

第一题：

首先让k%(n*m），再把二维数组转换成一维，后面比较容易处理。

public class Solution {
	 public List<List<Integer>> shiftGrid(int[][] g, int k) {
		 int n=g.length;
		 int m=g[0].length;
		 List<List<Integer>> ans=new ArrayList<List<Integer>>();
		 int[] buf=new int[n*m];
		 k%=n*m;
		 int index=0;
		 for(int[] temp:g) {
			 for(int v:temp) {
				 buf[index++]=v;
			 }
		 }
		 for(int i=0;i<n*m;i+=m) {
			 ArrayList<Integer> temp=new ArrayList<Integer>();
			 for(int j=i;j<i+m;j++) {
				 temp.add(buf[(j-k+n*m)%(n*m)]);
			 }
			 ans.add(temp);
		 }
		 
		 return ans;
	 }
}

第二题：

直接对这棵树dfs，在遍历的过程中记录值即可。

public class FindElements {
	public HashSet<Integer> set=new HashSet<Integer>();
	public TreeNode root;
	
	public FindElements(TreeNode root) {
		this.root=root;
		dfs(root,null,false);
	}
    
	public void dfs(TreeNode u,TreeNode fa,boolean flag) {
		if(u==null)
			return ;
		if(fa==null) {
			u.val=0;
			set.add(0);
		}
		else {
			if(flag) 
				u.val=2*fa.val+1;
			else
				u.val=2*fa.val+2;
	        set.add(u.val);
		}
		if(u.left!=null)
			dfs(u.left,u,true);
		if(u.right!=null)
			dfs(u.right,u,false);
	}
	
    public boolean find(int target) {
        return set.contains(target);
    }
}


class TreeNode{
	TreeNode left,right;
	int val;
}

第三题:

dp[i][j]表示取到第i位数时模3为j的最大值，转移的要注意，若由模3非0项转移而来时注意它的值不能为0。

public class Solution {
	public static void main(String[] args) {
		Solution solution= new Solution();
		solution.maxSumDivThree(new int[] {3,6,5,1,8});
	}
	
	public int maxSumDivThree(int[] num) {
        int n=num.length;
        int[][] dp=new int[n][3];
        
        dp[0][num[0]%3]=num[0];
        for(int i=1;i<n;i++) {
        	int last=num[i]%3;
        	for(int j=0;j<3;j++)
        		dp[i][j]=dp[i-1][j];
        	if(last==0) {
        		dp[i][0]=dp[i-1][0]+num[i];
        		if(dp[i-1][1]!=0)
        			dp[i][1]=dp[i-1][1]+num[i];
        		if(dp[i-1][2]!=0)
        			dp[i][2]=dp[i-1][2]+num[i];
        	}
        	if(last==1) {
        		if(dp[i-1][2]!=0)
        	    	dp[i][0]=Math.max(dp[i][0], dp[i-1][2]+num[i]);
        		dp[i][1]=Math.max(dp[i][1], dp[i-1][0]+num[i]);
        		if(dp[i-1][1]!=0)
        			dp[i][2]=Math.max(dp[i][2], dp[i-1][1]+num[i]);
        	}
        	if(last==2) {
        		if(dp[i-1][1]!=0)
        			dp[i][0]=Math.max(dp[i][0], dp[i-1][1]+num[i]);
        		if(dp[i-1][2]!=0)
        			dp[i][1]=Math.max(dp[i][1], dp[i-1][2]+num[i]);
        		dp[i][2]=Math.max(dp[i][2], dp[i-1][0]+num[i]);
        	}
        }
        
        return dp[n-1][0];
    }
}

第四题：

bfs，use[i][j][k][o]表示当人位于第i行第j列箱子位于第k行第o列时的最小推箱子次数，由于是单bfs所以要进行迭代，由于数据小，实际还是跑的很快。

public class Solution {
	public static int n,m;
	public static final int[] dx=new int[] {0,0,-1,1};
	public static final int[] dy=new int[] {-1,1,0,0};
	
	public int minPushBox(char[][] G) {
        int bx=0;
        int by=0;
        int tx=0;
        int ty=0;
        int x=0;
        int y=0;
        n=G.length;
        m=G[0].length;
        for(int i=0;i<n;i++) {
        	for(int j=0;j<m;j++) {
        		if(G[i][j]=='S') {
        			x=i;
        			y=j;
        		}
        		if(G[i][j]=='B') {
        			bx=i;
        			by=j;
        		}
        		if(G[i][j]=='T') {
        			tx=i;
        			ty=j;
        		}
        	}
        }
        return bfs(bx,by,tx,ty,x,y,G);
    }
	
	public boolean check(int x,int y,char[][]G) {
		return x>=0&&x<n&&y>=0&&y<m&&G[x][y]!='#';
	}
	
	public int bfs(int bx,int by,int tx,int ty,int x,int y,char[][] G) {
		Queue<Node> que=new ArrayDeque<Node>();
		que.offer(new Node(x,y,bx,by,0));
		int ans=Integer.MAX_VALUE;
		int[][][][] use=new int[n][m][n][m];
		for(int[][][] temp1:use)
			for(int[][] temp2:temp1)
				for(int[] temp:temp2)
					Arrays.fill(temp, Integer.MAX_VALUE);
		
		while(!que.isEmpty()) {
			Node temp=que.poll();
			if(temp.bx==tx&&temp.by==ty) {
				ans=Math.min(ans, temp.step);
				continue;
			}
			int tempx=temp.x;
			int tempy=temp.y;
			
			int step=temp.step;
			for(int i=0;i<4;i++) {
				int nowx=tempx+dx[i];
				int nowy=tempy+dy[i];
				int nowbx=temp.bx;
				int nowby=temp.by;
				int cnt=0;
				if(nowx==nowbx&&nowy==nowby) {
					nowbx+=dx[i];
					nowby+=dy[i];
					cnt=1;
				}
				if(check(nowx,nowy,G)&&check(nowbx,nowby,G)&&use[nowx][nowy][nowbx][nowby]>step+cnt) {
					use[nowx][nowy][nowbx][nowby]=Math.min(use[nowx][nowy][nowbx][nowby], step+cnt);
					que.offer(new Node(nowx,nowy,nowbx,nowby,use[nowx][nowy][nowbx][nowby]));
				}
			}
		}
		
		return ans==Integer.MAX_VALUE?-1:ans;
	}
	
	static class Node{
		int x;
		int y;
		int bx;
		int by;
		int step;
		
		public Node(int x, int y, int bx, int by, int step) {
			this.x = x;
			this.y = y;
			this.bx = bx;
			this.by = by;
			this.step = step;
		}
	}
}