BUPT2019计院软院机试Java题解

题目搜集于各位前辈，侵删。

第一题

题目描述：
输入 32 位的二进制 01 串，输出这个数+1 和+3 后的 32 位二进制串
输入描述：
先输入 T，表示输入的组数
然后输入 T 行二进制串
输出描述：
输出+1 和+3 后的二进制串
输入样例：
2
00000000000000000000000000000000
00000000000000000000000000000001
输出样例：
00000000000000000000000000000001
00000000000000000000000000000011
00000000000000000000000000000010
00000000000000000000000000000100

//java大数类还是香，建议选C、C艹的同学也学一下
import java.util.Scanner;

public class c1901 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		for(int i = 0;i<n;i++) {
			String s  = sc.next();
			StringBuilder sb = new StringBuilder(s);
			for(int j = 1;j<=3;j++) {
				for(int k = sb.length()-1;k>=0;k--) {
					if(sb.charAt(k)=='0') {
						sb.setCharAt(k, '1');
						break;
					}else {
						sb.setCharAt(k, '0');
					}
				}
				if(j==1||j==3) {
					System.out.println(sb);
				}
			}
		}
	}
}

第二题

题目描述：
大概意思就是根据输入父节点的两个子节点，根据输入构建一棵树，然后输入两个节点，
寻找两个节点之间的距离
距离定义：

输入描述：
先输入 T，表示输入的组数
再输入 n,m，n 表示父节点个数(n>=1),其中 1 号节点默认为根节点，
m 表示查询的组数
输出描述：
每组查询的两个点之间的距离
输入样例：
1
5 2
2 3
4 5
6 -1
-1 -1
7 -1
6 7
2 3
输出样例：
52

/*
两个难点。
一个是树的建立，利用了队列。
另一个是用并查集找爹，不过解法稍微暴力，应该有更简单的吧
*/
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class c1902 {

	static int[] parent;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int sum = sc.nextInt();
		for(int k = 0;k<sum;k++) {
			int n = sc.nextInt();
			int m = sc.nextInt();
			parent = new int[2*n+1];
			Arrays.fill(parent, -1);
			Queue<Integer> queue = new LinkedList<Integer>();
			queue.add(1);
			for(int i  = 0;i<n;i++) {
				int a = sc.nextInt();
				int b = sc.nextInt();
				int father = queue.peek();
				queue.remove();
				if(a!=-1) {
					parent[a] = father;
					queue.add(a);
				}
				if(b!=-1) {
					parent[b] = father;
					queue.add(b);
				}
			}
			for(int i = 0;i<m;i++) {
				int a = sc.nextInt();
				int b = sc.nextInt();
				//遍历a的每个爹，看哪一个爹也是b的爹
				int bothfather = 0;
				int tempa = a;
				int tempb = b;
				while(tempa!=-1) {
					if(isfather(tempa,tempb)) {
						bothfather = tempa;
						break;
					}
					tempa = parent[tempa];
				}
				
				int ans = 0;
				tempa = a;
				tempb = b;
				while(tempa!=bothfather) {
					ans++;
					tempa = parent[tempa];
				}
				while(tempb!=bothfather) {
					ans++;
					tempb = parent[tempb];
				}
				System.out.println(ans);
			}
		}
		
		sc.close();
	}
	
	static boolean isfather(int a,int b) {
		while(parent[b]!=-1) {
			if(parent[b]==a) {
				return true;
			}
			b=parent[b];
		}
		return false;
	}
}

第三题

输入描述：
有 n（n<=50）个城市，保证每个城市与其他城市之间必然有连接，
但是两个城市之间会存在多条道路（即有重边，这点考试开始没
说，之后发公告才知道，我想基本 3A 的原因在此），输入道路连接
的两个城市号及道路长度。同时在夜晚，某些道路会封路。请输出
在白天和夜晚从城市 1 到城市 n 之间的最短路径。
输入描述：
先输入 T，表示有 T 组数据
再输入 n，m，k，n 表示有 n 个城市，表示总共有 m 条边，k 表示
在夜晚有 k 条路封路
接下来 n 行，输入 n 条边的两个端点及长度
接下来 k 行，输入夜晚要封第几条路
输出描述：
输出白天和夜晚从 1 号城市到 n 号城市的最短距离
输入样例：
1
4 5 1
1 2 1
2 3 2
3 4 3
1 3 1
1 4 7
4
输出样例：
4 6

//单源最短距离，模板题
import java.util.Scanner;

public class c1903 {
	
	static int n;
	static int[] vis;
	static int[][] dis;
	static int[] min;
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int T = sc.nextInt();
		for(int i = 0;i<T;i++) {
			n = sc.nextInt();
			int m = sc.nextInt();
			int k = sc.nextInt();
			vis = new int[n+1];
			dis = new int[n+1][n+1];
			min = new int[n+1];
			Edge[] edge = new Edge[m+1];
			init();
			for(int j = 1;j<=m;j++) {
				int p1 = sc.nextInt();
				int p2 = sc.nextInt();
				int len = sc.nextInt();
				dis[p1][p2] = len;
				dis[p2][p1] = len;
				edge[j] = new Edge(p1,p2,len);
			}
			
			System.out.println(Dij());
			
			init();
			for(int j = 1;j<=m;j++) {
				int p1 = edge[j].p1;
				int p2 = edge[j].p2;
				int len = edge[j].len;
				dis[p1][p2] = len;
				dis[p2][p1] = len;
			}
			
			for(int j = 0;j<k;j++) {
				int dark = sc.nextInt();
				int p1 = edge[dark].p1;
				int p2 = edge[dark].p2;
				dis[p1][p2] = Integer.MAX_VALUE/2;
				dis[p2][p1] = Integer.MAX_VALUE/2;
			}

			System.out.println(Dij());
			
		}
		
		sc.close();
	}
	static class Edge{
		int p1;
		int p2;
		int len;
		public Edge(int p1, int p2,int len) {
			super();
			this.p1 = p1;
			this.p2 = p2;
			this.len = len;
		}
		
	}
	
	static void init() {
		for(int j = 1;j<=n;j++) {
			vis[j] = 0;
			min[j] = Integer.MAX_VALUE/2;
			for(int l = 1;l<=n;l++) {
				if(j==l) {
					dis[j][l] = 0;
				}else {
					dis[j][l] = Integer.MAX_VALUE/2;
				}
			}
		}
	}
	
	static int Dij() {
		vis[1] = 1;
		min[1] = 0;
		
		for(int i = 2;i<=n;i++) {
			int temp = Integer.MAX_VALUE/2;
			int minp = 0;
			for(int j = 2;j<=n;j++) {
				if(vis[j]==0&&dis[1][j]<temp) {
					temp = dis[1][j];
					minp = j;
				}
			}
			vis[minp] = 1;
			min[minp] = temp;
			
			for(int j = 2;j<=n;j++) {
				if(vis[j]==0&&(dis[1][minp]+dis[minp][j]<dis[1][j])) {
					dis[1][j] = dis[1][minp]+dis[minp][j];
				}
			}
		}
			
		return min[n];
	}
}

第四题

第四题：
题目描述（具体太长，只说大意，我也没 A 出来，额，发现我好像
理解错题目意思了，大家别看我写的这题了，有点错误）：
给出一张从原图片中沿横纵向剪切后的图片，判断原图片中 nn
（n>=1）矩阵的大小
（原图片肯定存在该 nn 的矩阵，且唯一）
输入描述：
先输入 T，表示输入的组数
再输入 n，m，表示矩阵的行列
再输入该剪切后的图片，·表示空白，#表示图片中矩阵的内容
输出描述：
输出原图片中最小 n*n 矩阵的大小，即 n 的值，如果不存在则输出- 1

举例说明吧
如果原图片是这样：
......###..
......###..
......###..
...........
...........
剪切后的图片可能是：
1）不变
......###..
......###..
......###..
...........
...........
2）
##..
##..
##..
....
....
所以一个原图片可能对应很多剪切后的图片
样例1输入：
##..
##..
##..
....
....
样例1输出：
2
说明：该剪切后的图片中有

代码贴的是另一个帖子里的题目举例，不过没看懂，暴力肯定不行，可能类似最大子矩阵问题可以减少时间？
我也没看懂题，有知道的烦请告知。