[LeetCode] 第167场周赛题解

第一次进第一页QAQ，然而还是手慢，在第二题浪费了好久的时间。

第一题：

public class Solution {
    public int getDecimalValue(ListNode head) {
        int ans=0;
        ListNode temp=head;
        while(temp!=null) {
        	ans=ans*2+temp.val;
        	temp=temp.next;
        }
        return ans;
    }
}

 第二题：

合法的数据很有限，直接暴力即可。

public class Solution {
	
    public  List<Integer> sequentialDigits(int low, int high) {
        ArrayList<Integer> buf=new ArrayList<>();
        for(int i=1;i<=9;i++) {
        	int temp=0;
        	for(int j=1;j<=i;j++)
        		temp=temp*10+j;
        	while(true) {
        		buf.add(temp);
        		String s=Integer.toString(temp);
        		String t="";
        		boolean flag=false;
        		for(int j=0;j<s.length();j++) {
        			int v=s.charAt(j)-'0'+1;
        			if(v>=10) {
        				flag=true;
        				break;
        			}
        			t+=v;	
        		}
        		if(flag)
        			break;
        		temp=Integer.parseInt(t);
        		
        	}
        }
        Collections.sort(buf);
        ArrayList<Integer> ans=new ArrayList<>();
        for(int v:buf) {
        	if(v>high)
        		break;
        	if(v<low)
        		continue;
        	ans.add(v);
        }
        return ans;
    }
}

第三题：

一眼二维前缀和+二分（PS:其实直接暴力就行了）

public class Solution {
	public boolean check(int[][] dp,int k,int max,int n,int m) {
		for(int i=1;n-i+1>=k;i++) {
        	for(int j=1;m-j+1>=k;j++) {
        		if(dp[i+k-1][j+k-1]-dp[i+k-1][j-1]-dp[i-1][j+k-1]+dp[i-1][j-1]<=max)
        			return true;
        	}
        }
		return false;
	}
	
    public int maxSideLength(int[][] map, int max) {
    	int n=map.length;
    	int m=map[0].length;
    	int[][] dp=new int[n+1][m+1];
    	for(int i=1;i<=n;i++)
    		for(int j=1;j<=m;j++)
    			dp[i][j]=dp[i-1][j]+dp[i][j-1]-dp[i-1][j-1]+map[i-1][j-1];
    	int l=0;
    	int r=Math.min(n, m);
    	int ans=0;
    	while(l<=r) {
    		int mid=(l+r)>>1;
    		if(check(dp,mid,max,n,m)) {
    			ans=mid;
    			l=mid+1;
    		}
    		else
    			r=mid-1;
    	}
    	return ans;
        
    }
}

第四题：

一眼BFS，cost[i][j][k]表示在（i , j）还可消除k个障碍时的最小花费。

public class Solution {
	public static final int[] dx=new int[] {0,0,1,-1};
	public static final int[] dy=new int[] {1,-1,0,0};
	public static final int INF=Integer.MAX_VALUE/8;
	
	public boolean check(int x,int y,int n,int m) {
		return x>=0&&x<n&&y>=0&&y<m;
	}
	
    public int shortestPath(int[][] g, int k) {
    	int n=g.length;
    	int m=g[0].length;
        int[][][] cost=new int[n][m][k+1];
        Queue<Node> que=new ArrayDeque<Node>();
        for(int[][] x:cost) {
        	for(int[] y:x)
        		Arrays.fill(y,INF);
        }
        que.offer(new Node(0,0,0,k));
        while(!que.isEmpty()) {
        	Node temp=que.poll();
        	if(temp.x==n-1&&temp.y==m-1)
        		return temp.step;
        	for(int i=0;i<4;i++) {
        		int x=temp.x+dx[i];
        		int y=temp.y+dy[i];
        		if(check(x,y,n,m)) {
        			if(g[x][y]==1&&temp.k==0)
        				continue;
        			if(g[x][y]==1) {
        				if(cost[x][y][temp.k-1]>temp.step+1) {
        					cost[x][y][temp.k-1]=temp.step+1;
        					que.offer(new Node(x,y,temp.step+1,temp.k-1));
        				}
        			}
        			else {
        				if(cost[x][y][temp.k]>temp.step+1) {
        					cost[x][y][temp.k]=temp.step+1;
        					que.offer(new Node(x,y,temp.step+1,temp.k));
        				}
        			}
        		}
        	}
        }
        return -1;
    }
    
    static class Node{
    	int x;
    	int y;
    	int step;
    	int k;
    	
    	public Node(int x,int y,int step,int k) {
    		this.x=x;
    		this.y=y;
    		this.step=step;
    		this.k=k;
    	}
    }
}