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