百度2020春招Java开发实习生笔试_编程部分总结

1.第一题-最大公约数，最小公倍数

题目描述：两个数a，b，满足1 =< a, b <= n,使得lcm（a，b）- gcd（a，b）的值尽量大，输出最大的res = lcm（a，b）- gcd（a，b）。lcm（a，b）为a，b的最小公倍数，gcd（a，b）为a，b的最大公约数。

输入：n

输出：res

import java.util.Scanner;

public class Baidu_gcd {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
        long n = sc.nextLong();
        System.out.println(n*(n-1)-1);
	}
}

思路：res = lcm - gcd，lcm = a * b / gcd , res = ( a * b / gcd )- gcd

要使res最大，要使a * b最大，gcd最小，当a = n，b = （n-1）时，a，b互为素数，最大公约数gcd为1最小，即res = n*（n- 1）/ 1 - 1。

总结：只AC了30%，原因是做的时候只用了int，没有注意范围，应该使用long进行存储数字。

---

2.第二题-增量数组

题目描述：一个数列a[i]的长度为n，每次从a[i]中取出最大的数减去n，同时让其他的n-1个数字加1，一直重复执行到数列中最大数a[max_i] < n，输出所需执行的最少次数res。

输入：3

​ 1 0 3

输出：1

Solution1：由于不断的进行排序，导致程序超时，无法通过。

import java.util.Arrays;
import java.util.Scanner;
public class Baidu_02add {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int []arr = new int[n];
		for (int i = 0; i < n; i++) {
			arr[i] = sc.nextInt();
		}
		int k = opt(n,arr,0);
		System.out.println(k);
	}

	private static int opt(int n, int[] arr, int step) {
		//用Arrays.sort不断排序会超时
		Arrays.sort(arr);
		System.out.println("step = " + step);
		for (int i : arr) {
			System.out.print(i + " ");
		}
		System.out.println();
		if (arr[n-1] < n) {
			return step;
		}else {
			arr[n-1] -= n;
			for (int i = 0; i < n-1; i++) {
				arr[i] += 1;
			}

			return opt(n, arr, step+1) ;
		}
	}
}

}

思路：模拟题目描述的过程，每次通过排序找出最大的值，将最大值-n，将其它值+1；

总结：超时无法通过，因为步骤执行的太过繁琐，时间复杂度很高，Arrays.sort(arr);每一步都进行排序，并且每步只减去n，程序执行的轮次很多。

Solution2：

import java.util.Arrays;
import java.util.Scanner;
public class Baidu_02add {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int []arr = new int[n];
		for (int i = 0; i < n; i++) {
			arr[i] = sc.nextInt();
		}
		long step = 0;
		while (!isVaild(arr)) {
			long max = 0;
			int idx = 0;
			for (int i = 0; i < arr.length; i++) {
				if (max < arr[i]) {
					max = arr[i];
					idx = i;
				}
			}
			//核心-一次到位
			step += max/n;
			for (int i = 0; i < arr.length; i++) {
				arr[i] += max/n;
			}
			arr[idx] = (int) (max%n);
		}
		System.out.println(step);
	}

	private static boolean isVaild(int[] arr) {
		int n = arr.length;
		for (int i : arr) {
			if (i >= n){
				return false;
			}
		}
		return true;
	}
}

思路：同样是模拟题目描述的过程，通过遍历找出当前最大的值，并且将其的值处理一步到位，即一次计算出满足条件需要执行的轮次max/n，然后讲除最大值之外的所有值加上需要执行的轮次max/n，再进入下一轮循环。

总结：降低轮次执行过多而导致的时间复杂度，并且不进行排序，同样提升了性能。

---

3.第三题

题目描述：在n个节点构成的图中，找出一条最长路径res（u，v），使得从u 到 v 路径所经过的顶点满足权值严格递增。

输入：

​ 第一行：n（顶点个数） 范围 【2,10 ** 5】
​ 第二行：n个数（表示顶点的权值） 范围 【1，n】
​ 接来下 n - 1 行，每行两个数，代表两个顶点之间存在边

输出：最长路径res

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;


public class Bidu_03path {
	static int max = 0;
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int []nodes = new int[n+1];
		for (int i = 1; i < nodes.length; i++) {
			nodes[i] = in.nextInt();
		}
		List<Integer> []graph = new ArrayList[n+1];
		for (int i = 0; i < graph.length; i++) {
			graph[i] = new ArrayList<Integer>();
		}
		for (int i = 0; i < n-1; i++) {
			int l = in.nextInt();
			int r = in.nextInt();
			graph[l].add(r);
			graph[r].add(l);
		}
		for (int i = 1; i < n; i++) {
			dfs(graph, nodes, i, 0);
		}
		System.out.println(max);
	}

	private static void dfs(List<Integer>[] graph, int[] nodes, int cur, int len) {
		len += 1;
		max = Math.max(len, max);
		List<Integer> nexts = graph[cur];
		for (int next : nexts) {
			if (nodes[next] > nodes[cur]) {
				dfs(graph, nodes, cur, len);
			}
		}
	}
}

思路：当做图模型来解题，求图中权值递增的最长路径；根据题意，图中只有N-1条边，且无法从权值大的点走到权值小的点，因此遍历图的时候，并不会出现“往回走”，“死循环”的问题，所以这里可以直接用深度优先遍历。判断节点是否递增，是就接着深搜。

总结：对于图模型的存储记忆，应该多加练习。

参考引用：https://www.nowcoder.com/discuss/395175?type=post&order=time&pos=&page=1