1 容量单位
【问题描述】
在计算机存储中，12.5MB是多少字节？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
答案
13107200
2 最多边数
【问题描述】
一个包含有2019个结点的有向图，最多包含多少条边？（不允许有重边）
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
解析
任意两点组成边，边有向，一来一回算两条边
所以是n中选2的组合数乘以2级n*(n-1)
答案
4074342
3 单词重排
【问题描述】
将LANQIAO中的字母重新排列，可以得到不同的单词，如LANQIAO、AAILNOQ等，注意这7个字母都要被用上，单词不一定有具体的英文意义。
请问，总共能排列如多少个不同的单词。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
解析
求全排列，去重，计数
代码
import java.util.HashSet;
import java.util.Set;
/**
* @Author zhengwei
* @Date 2020/5/17 5:32 PM
* @Version 1.0
*/
public class _03单词重排 {
private static char[] a = "LANQIAO".toCharArray();
private static Set<String> ans = new HashSet<>();
private static char[] tmp = new char[7];
private static boolean[] vis = new boolean[7];
public static void main(String[] args) {
dfs(0);
System.out.println(ans.size());
}
private static void dfs(int k) {
if (k == 7) {
ans.add(new String(tmp));
return;
}
for (int i = 0; i < 7; i++) {
if (!vis[i]) {
tmp[k] = a[i];
vis[i] = true;
dfs(k + 1);
vis[i] = false;
}
}
}
}
答案
2520
4 括号序列
【问题描述】
由1对括号，可以组成一种合法括号序列：()。
由2对括号，可以组成两种合法括号序列：()()、(())。
由4对括号组成的合法括号序列一共有多少种？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
解析
典型的递归结构，每个位置有两种选择，要么左括号，要么右括号。
选左括号的条件：可选数>0 且 变化后存在的左括号数量始终大于等于已存在的右括号数量。
选右括号类似。
代码
/**
* @Author zhengwei
* @Date 2020/5/17 5:42 PM
* @Version 1.0
*/
public class _04括号序列 {
public static void main(String[] args) {
System.out.println(solve(4, 4, 4));
}
/**
*
* @param n 对的数量
* @param l 剩余左括号数量
* @param r 剩余右括号的数量
* @return
*/
private static int solve(int n, int l, int r) {
if (l == 0 && r == 0)
return 1;
int ans = 0;
// # 要么选左括号，要么选右括号
// # 选左括号的条件：l>0 且 变化后存在的左括号数量始终大于等于已存在的右括号数量
if (l > 0 && n - (l - 1) >= n - r)
ans += solve(n, l - 1, r);
if (r > 0 && n - l >= n - (r - 1))
ans += solve(n, l, r - 1);
return ans;
}
}
答案
14
5 反倍数
【问题描述】
给定三个整数 a, b, c，如果一个整数既不是 a 的整数倍也不是 b 的整数倍还不是 c 的整数倍，则这个数称为反倍数。
请问在 1 至 n 中有多少个反倍数。
【输入格式】
输入的第一行包含一个整数 n。
第二行包含三个整数 a, b, c，相邻两个数之间用一个空格分隔。
【输出格式】
输出一行包含一个整数，表示答案。
【样例输入】
30
2 3 6
【样例输出】
10
【样例说明】
以下这些数满足要求：1, 5, 7, 11, 13, 17, 19, 23, 25, 29。
【评测用例规模与约定】
对于 40% 的评测用例，1 <= n <= 10000。
对于 80% 的评测用例，1 <= n <= 100000。
对于所有评测用例，1 <= n <= 1000000，1 <= a <= n，1 <= b <= n，1 <= c <= n。
解析
迭代+check
代码
import java.util.Scanner;
/**
* @Author zhengwei
* @Date 2020/5/17 5:45 PM
* @Version 1.0
*/
public class _05反倍数 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
long sum = 0;
for (int i = 1; i < n + 1; i++) {
if (i % a != 0 && i % b != 0 && i % c != 0) {
sum++;
}
}
System.out.println(sum);
}
}
6 凯撒密码
【问题描述】
给定一个单词，请使用凯撒密码将这个单词加密。
凯撒密码是一种替换加密的技术，单词中的所有字母都在字母表上向后偏移3位后被替换成密文。即a变为d，b变为e，...，w变为z，x变为a，y变为b，z变为c。
例如，lanqiao会变成odqtldr。
【输入格式】
输入一行，包含一个单词，单词中只包含小写英文字母。
【输出格式】
输出一行，表示加密后的密文。
【样例输入】
lanqiao
【样例输出】
odqtldr
【评测用例规模与约定】
对于所有评测用例，单词中的字母个数不超过100。
解析
遍历+转换，再拼成字符串
代码
import java.util.Scanner;
/**
* @Author zhengwei
* @Date 2020/5/17 5:51 PM
* @Version 1.0
*/
public class _06凯撒密码 {
private static char add(char letter) {
if (letter < 'x')
return (char) (letter + 3);
else if (letter == 'x')
return 'a';
else if (letter == 'y')
return 'b';
else
return 'c';
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
char[] ans = new char[s.length()];
for (int i = 0; i < s.length(); i++) {
ans[i] = add(s.charAt(i));
}
System.out.println(new String(ans));
}
}
7 螺旋
【问题描述】
对于一个 n 行 m 列的表格，我们可以使用螺旋的方式给表格依次填上正整数，我们称填好的表格为一个螺旋矩阵。
例如，一个 4 行 5 列的螺旋矩阵如下：
1 2 3 4 5
14 15 16 17 6
13 20 19 18 7
12 11 10 9 8
【输入格式】
输入的第一行包含两个整数 n, m，分别表示螺旋矩阵的行数和列数。
第二行包含两个整数 r, c，表示要求的行号和列号。
【输出格式】
输出一个整数，表示螺旋矩阵中第 r 行第 c 列的元素的值。
【样例输入】
4 5
2 2
【样例输出】
15
【评测用例规模与约定】
对于 30% 的评测用例，2 <= n, m <= 20。
对于 70% 的评测用例，2 <= n, m <= 100。
对于所有评测用例，2 <= n, m <= 1000，1 <= r <= n，1 <= c <= m。
解析
按题意生成网格，再取单元格中的数据
代码
import java.util.Scanner;
/**
* @Author zhengwei
* @Date 2020/5/17 6:36 PM
* @Version 1.0
*/
public class _07螺旋 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int r = sc.nextInt();
int c = sc.nextInt();
int[][] grid = new int[n][m];
int num = 1;
int up = 0, down = n, left = 0, right = m;
while (true) {
for (int col = left; col < right; col++) {
grid[up][col] = num;
num++;
}
up++;
if (up == down)
break;
for (int row = up; row < down; row++) {
grid[row][right - 1] = num;
num++;
}
right--;
if (left == right)
break;
for (int col = right - 1; col >= left; col--) {
grid[down - 1][col] = num;
num++;
}
down -= 1;
if (up == down)
break;
for (int row = down - 1; row >= up; row--) {
grid[row][left] = num;
num++;
}
left++;
if (left == right)
break;
}
System.out.println(grid[r - 1][c - 1]);
}
}
8 摆动序列
【问题描述】
如果一个序列的奇数项都比前一项大，偶数项都比前一项小，则称为一个摆动序列。即 a[2i]<a[2i-1], a[2i+1]>a[2i]。
小明想知道，长度为 m，每个数都是 1 到 n 之间的正整数的摆动序列一共有多少个。
【输入格式】
输入一行包含两个整数 m，n。
【输出格式】
输出一个整数，表示答案。答案可能很大，请输出答案除以10000的余数。
【样例输入】
3 4
【样例输出】
14
【样例说明】
以下是符合要求的摆动序列：
2 1 2
2 1 3
2 1 4
3 1 2
3 1 3
3 1 4
3 2 3
3 2 4
4 1 2
4 1 3
4 1 4
4 2 3
4 2 4
4 3 4
【评测用例规模与约定】
对于 20% 的评测用例，1 <= n, m <= 5；
对于 50% 的评测用例，1 <= n, m <= 10；
对于 80% 的评测用例，1 <= n, m <= 100；
对于所有评测用例，1 <= n, m <= 1000。
解法1：dfs
多数人都能想到：第1位，可选为[2,n]
选定第1位（last1），开始选第2位，可选为[1,last1-1]，对所有last1结果求和
选定第2位（last2），开始选第3位，可选为[last2+1,n]，对所有last2结果求和
……
选定奇数位（last），开始选下一个偶数位，可选为[1,last-1]，对所有last结果求和
选定偶数位（last），开始选下一个奇数位，可选为[last+1,n]，对所有last结果求和
……
递归式为：
dfs(last, k) = Σdfs(i, k + 1) | k为奇数，i from 1 to last-1
dfs(last, k) = Σdfs(i, k + 1) | k为偶数，i from last+1 to n
而递归起点（选定第一位，可选是2 to n）也是一个循环：
for i in range(2, n + 1):
ans = (ans + dfs(i, 1)) % MOD
这里面有大量重复子问题，所以可以记忆型递归；但只能过80%的数据，因为复杂度是O(N³)
代码1
import java.util.Scanner;
/**
* @Author zhengwei
* @Date 2020/5/17 6:53 PM
* @Version 1.0
*/
public class _08摆动序列 {
private static final int MOD = 10000;
private static int[][] mem = new int[1000][1000];
private static int n, m;
// 第k个数确定为last时，序列总数是多少
// param last:确定的最后一个数
// param k:last是第k个
private static int dfs(int last, int k) {
if (k == m)
return 1;
if (mem[last][k] != 0)
return mem[last][k];
// k是奇数，k+1是偶数，偶数位比前一个小
if ((k & 1) == 1)
for (int i = 1; i < last; i++)
mem[last][k] = (mem[last][k] + dfs(i, k + 1)) % MOD;
else
for (int i = last + 1; i < n + 1; i++)
mem[last][k] = (mem[last][k] + dfs(i, k + 1)) % MOD;
return mem[last][k];
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
m = sc.nextInt();
n = sc.nextInt();
int ans = 0;
//第一位可以选2到n
for (int i = 2; i < n + 1; i++)
ans = (ans + dfs(i, 1)) % MOD;
System.out.println(ans);
}
}
优化1：修改递归式
这种在递归中加总的递归形态，往往可以通过优化递归式来改进，将递归式变成有汇总 or 集合的意义，就可以减少一层循环，从而把复杂度变为O(N²)
可以从递归起点的那个循环考虑，我们既然要加总第1位选2到n的这若干种情况的结果，为什么不用dfs(2,1)直接表示第一位选[2,n]这所有情况的和呢？这就是集合的概念了。
更通用地：
k为奇数时，dfs(x,k)表示第k位选[x,n]这若干种情况的种数和；
k为偶数时，dfs(x,k)表示第k位选[1,x]这若干种情况的种数和；
但是怎么拆呢？技巧是拆成一个元素+一个（少了该元素的）小集合，小集合动一个变量（往往代表规模），那拆出来的元素往往可以转换成另外一个集合。
就本题来说，k为奇数时，dfs(x,k)可以这样拆：
k为偶数时，dfs(x,k)可以这样拆：
那么可得递归式：
dfs(x, k) = dfs(x+1, k) + dfs(x-1,k+1) | k为奇数
dfs(x, k) = dfs(x-1, k) + dfs(x+1,k+1) | k为偶数
递归起点为：ans = dfs(2, 1)
代码2
import java.util.Scanner;
/**
* @Author zhengwei
* @Date 2020/5/17 6:53 PM
* @Version 1.0
*/
public class _08摆动序列2 {
private static final int MOD = 10000;
private static int[][] mem = new int[1000][1000];
private static int n, m;
// 第k个数确定为last时，序列总数是多少
// param last:确定的最后一个数
// param k:last是第k个
private static int dfs(int last, int k) {
if (last < 1 || last > n)
return 0;
if (k == m) {
// 奇数，return 大于等于last的个数；偶数，小于等于last的个数
if ((k & 1) == 1) {
mem[last][k] = n - last + 1;
} else {
mem[last][k] = last;
}
return mem[last][k];
}
if (mem[last][k] != 0)
return mem[last][k];
if ((k & 1) == 1)
//注意看这里的拆解：当前函数的含义是第k位选last~n的序列数总和，切成两块
//1：第k位选(last+1)到n的序列数总和，函数含义不变，第一个参数变为last+1==》dfs(last + 1, k)
//2：第k位固定为last，那么第k+1位的选择是从1到last-1（因k+1是偶数）==》dfs(last - 1, k + 1)
mem[last][k] = (dfs(last + 1, k) + dfs(last - 1, k + 1)) % MOD;
else //偶数
mem[last][k] = (dfs(last - 1, k) + dfs(last + 1, k + 1)) % MOD;
return mem[last][k];
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
m = sc.nextInt();
n = sc.nextInt();
System.out.println(dfs(2, 1));
}
}
优化2：改为递推
为什么还要优化呢？因为这样递归层次太深，会超出栈空间限制。
递推是递归的逆过程，因此我们观察上述递归函数的出口，就知道怎么初始化dp数组，再按照与递归相逆的顺序逐步生成递推数组。
递归出口：
if (k == m) {
// 奇数，return 大于等于last的个数；偶数，小于等于last的个数
if ((k & 1) == 1) {
mem[last][k] = n - last + 1;
} else {
mem[last][k] = last;
}
return mem[last][k];
}
转变为数组初始化：
//初始化最后一列
for (int x = 1; x < n + 1; x++) {
if ((m & 1) == 1)
dp[x][m] = n - x + 1;
else
dp[x][m] = x;
}
递归中，列数k是逐渐增大，直至最后一列，那么递推中，应该从最后一列反推到第一列。
代码3
import java.util.Scanner;
/**
* @Author zhengwei
* @Date 2020/5/17 6:53 PM
* @Version 1.0
*/
public class _08摆动序列3 {
private static final int MOD = 10000;
private static int[][] dp;
private static int n, m;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
m = sc.nextInt();
n = sc.nextInt();
dp = new int[n + 1][m + 1];
//初始化最后一列
for (int x = 1; x < n + 1; x++) {
if ((m & 1) == 1)
dp[x][m] = n - x + 1;
else
dp[x][m] = x;
}
for (int k = m - 1; k > 0; k--) {
// # 奇数，x从大到小遍历
if ((k & 1) == 1)
for (int x = n; x > 0; x--)
dp[x][k] = ((x + 1 <= n ? dp[x + 1][k] : 0) + dp[x - 1][k + 1]) % MOD;
// # 偶数，x从小到大遍历
else
for (int x = 1; x < n + 1; x++)
dp[x][k] = (dp[x - 1][k] + (x + 1 <= n ? dp[x + 1][k + 1] : 0)) % MOD;
}
System.out.println(dp[2][1]);
}
}
9 通电
【问题描述】
2015年，全中国实现了户户通电。作为一名电力建设者，小明正在帮助一带一路上的国家通电。
这一次，小明要帮助 n 个村庄通电，其中 1 号村庄正好可以建立一个发电站，所发的电足够所有村庄使用。
现在，这 n 个村庄之间都没有电线相连，小明主要要做的是架设电线连接这些村庄，使得所有村庄都直接或间接的与发电站相通。
小明测量了所有村庄的位置（坐标）和高度，如果要连接两个村庄，小明需要花费两个村庄之间的坐标距离加上高度差的平方，形式化描述为坐标为 (x_1, y_1) 高度为 h_1 的村庄与坐标为 (x_2, y_2) 高度为 h_2 的村庄之间连接的费用为
sqrt((x_1-x_2)*(x_1-x_2)+(y_1-y_2)*(y_1-y_2))+(h_1-h_2)*(h_1-h_2)。
在上式中 sqrt 表示取括号内的平方根。请注意括号的位置，高度的计算方式与横纵坐标的计算方式不同。
由于经费有限，请帮助小明计算他至少要花费多少费用才能使这 n 个村庄都通电。
【输入格式】
输入的第一行包含一个整数 n ，表示村庄的数量。
接下来 n 行，每个三个整数 x, y, h，分别表示一个村庄的横、纵坐标和高度，其中第一个村庄可以建立发电站。
【输出格式】
输出一行，包含一个实数，四舍五入保留 2 位小数，表示答案。
【样例输入】
4
1 1 3
9 9 7
8 8 6
4 5 4
【样例输出】
17.41
【评测用例规模与约定】
对于 30% 的评测用例，1 <= n <= 10；
对于 60% 的评测用例，1 <= n <= 100；
对于所有评测用例，1 <= n <= 1000，0 <= x, y, h <= 10000。
解析
可以说是最小生成树的裸题了——连通==树，代价最小==最小生成
用Kruskal算法一气呵成。
不过要进行一些处理：
每个村庄看做是一个顶点，编号存储
两两组成边，用费用做边的权重
做好数据处理，然后就是排序，从小到大把边添加到最小生成树的边集（也不用真正添加，符合的边把代价累加就行，不符合的边忽略）
符合与不符合，当然要用并查集了。
代码
import java.util.*;
/**
* @Author zhengwei
* @Date 2020/5/18 10:44 AM
* @Version 1.0
*/
public class _09通电 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
// 接下来 n 行，每个三个整数 x, y, h
int[][] data = new int[n + 1][3];
for (int i = 1; i <= n; i++) {
data[i][0] = sc.nextInt();
data[i][1] = sc.nextInt();
data[i][2] = sc.nextInt();
}
//# 将原始数据处理成边集，每两个点一条边，计算代价
List<Edge> edges = new ArrayList<>(n * n);
for (int i = 1; i <= n - 1; i++) {
for (int j = i + 1; j <= n; j++) {
edges.add(new Edge(i, j, cost(data[i], data[j])));
}
}
// 对边集排序
Collections.sort(edges);
//初始化并查集工具
UF uf = new UF(n);
int edge_cnt = 0;
double ans = 0;
for (Edge e : edges) {
if (uf.find(e.x) != uf.find(e.y)) {
uf.union(e.x, e.y);
edge_cnt++;
ans += e.cost;
if (edge_cnt == n - 1)
break;
}
}
System.out.printf("%.2f", ans);
}
/**
* 封装并查集操作
*/
private static class UF {
int n;
int[] parent;
public UF(int n) {
this.n = n;
parent = new int[n + 1];
for (int i = 1; i <= n; i++) {
parent[i] = i;
}
}
int find(int x) {
if (parent[x] == x)
return x;
HashSet<Integer> path = new HashSet<>();
while (parent[x] != x) {
path.add(x);
x = parent[x];
}
for (Integer xx : path) {
parent[xx] = x;
}
return x;
}
void union(int a, int b) {
parent[find(b)] = find(a);
}
}
/**
* 计算a，b两个村庄的建设代价
* @param a
* @param b
* @return
*/
private static double cost(int[] a, int[] b) {
return Math.sqrt((a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1])) + (a[2] - b[2]) * (a[2] - b[2]);
}
/**
* 注意实现Comparable接口
*/
private static class Edge implements Comparable<Edge> {
int x;
int y;
double cost;
public Edge(int x, int y, double cost) {
this.x = x;
this.y = y;
this.cost = cost;
}
@Override
public int compareTo(Edge o) {
return this.cost < o.cost ? -1 : (this.cost == o.cost ? 0 : 1);
}
}
}
10 植树
【问题描述】
小明和朋友们一起去郊外植树，他们带了一些在自己实验室精心研究出的小树苗。
小明和朋友们一共有 n 个人，他们经过精心挑选，在一块空地上每个人挑选了一个适合植树的位置，总共 n 个。他们准备把自己带的树苗都植下去。
然而，他们遇到了一个困难：有的树苗比较大，而有的位置挨太近，导致两棵树植下去后会撞在一起。
他们将树看成一个圆，圆心在他们找的位置上。如果两棵树对应的圆相交，这两棵树就不适合同时植下（相切不受影响），称为两棵树冲突。
小明和朋友们决定先合计合计，只将其中的一部分树植下去，保证没有互相冲突的树。他们同时希望这些树所能覆盖的面积和（圆面积和）最大。
【输入格式】
输入的第一行包含一个整数 n ，表示人数，即准备植树的位置数。
接下来 n 行，每行三个整数 x, y, r，表示一棵树在空地上的横、纵坐标和半径。
【输出格式】
输出一行包含一个整数，表示在不冲突下可以植树的面积和。由于每棵树的面积都是圆周率的整数倍，请输出答案除以圆周率后的值（应当是一个整数）。
【样例输入】
6
1 1 2
1 4 2
1 7 2
4 1 2
4 4 2
4 7 2
【样例输出】
12
【评测用例规模与约定】
对于 30% 的评测用例，1 <= n <= 10；
对于 60% 的评测用例，1 <= n <= 20；
对于所有评测用例，1 <= n <= 30，0 <= x, y <= 1000，1 <= r <= 1000。
解析
每个圆可以选也可以不选，但不知道哪种决策结果最大，只能先考虑暴力搜索每种情况，总可选数为2的n次方的深度优先搜索。
某一个圆在准备选入的时候，可以判断是否与之前已入选的圆冲突，如果冲突了，这条分支就可以不继续了，这可以视为剪枝；但是判断是否冲突的check函数要遍历已入选的圆，复杂度依然高；
【代码1】在n等于30的时候会吃不消。
代码1
import java.util.Scanner;
/**
* @Author zhengwei
* @Date 2020/5/18 11:48 AM
* @Version 1.0
*/
public class _10植树 {
static Scanner sc = new Scanner(System.in);
static int n;
static int ans = 0;
static Tree[] trees;
static int[][] adjaTable;
public static void main(String[] args) {
n = sc.nextInt();
initTrees();
initAdjaTable();
dfs(0, 0);
System.out.println(ans);
}
/**
* 初始化邻接矩阵
*/
private static void initAdjaTable() {
adjaTable = new int[n][n];
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (trees[i].intersected(trees[j])) {
adjaTable[i][j] = 1;
adjaTable[j][i] = 1;
}
}
}
}
/**
* 初始化每棵树并加入数组
*/
private static void initTrees() {
trees = new Tree[n];
for (int i = 0; i < n; i++) {
trees[i] = new Tree(sc.nextInt(), sc.nextInt(), sc.nextInt());
}
}
private static void dfs(int sum, int index) {
//边界
if (index == n) {
ans = Math.max(ans, sum);
return;
}
// 2.选这棵树（是有条件的）
if (ok(index)) {
trees[index].selected = true;
int r = trees[index].r;
dfs(sum + r * r, index + 1);
trees[index].selected = false; //回溯
}
//1.不选当前这棵树
trees[index].selected = false;
dfs(sum, index + 1);
}
private static boolean ok(int index) {
for (int i = 0; i < index; i++) {
//i被选入，且i与当前准备入选的index相交，则index代表的树不能入选
if (trees[i].selected && adjaTable[i][index] == 1)
return false;
}
return true;
}
private static class Tree {
int x, y, r;
boolean selected; // 是否入选
public Tree(int x, int y, int r) {
this.x = x;
this.y = y;
this.r = r;
}
/**与另一颗树是否相交*/
public boolean intersected(Tree other) {
int dis = (this.x - other.x) * (this.x - other.x) + (this.y - other.y) * (this.y - other.y);
return dis < (this.r + other.r) * (this.r + other.r);
}
}
}
优化
优化的关键点在于用类似贪心的办法（但不是贪心）：将圆按半径从大到小排序，这样优先考虑半径大的圆的选与不选问题；另外把“选”这个分支放在“不选”这个分支前面执行，这样我们相信会尽早地遇到最优解。
基于这个假设，在递归之前我们可以以O(N)的复杂度存储所有圆的“半径的平方”的后缀和，计为数组s；在递归函数dfs中，参数sum代表index之前的选择策略所得到的sum，s[index]代表包括index索引及之后续所有圆的半径的平方和，如果sum+s[index]小于等于已经求得的ans，那就不必进行任何后续的选择试探了，可立即退出递归。
实测，【代码2】在n=30时能秒出结果。
代码
import java.time.Duration;
import java.time.Instant;
import java.util.Arrays;
import java.util.Scanner;
/**
* @Author zhengwei
* @Date 2020/5/18 11:48 AM
* @Version 1.0
*/
public class _10植树2 {
static Scanner sc = new Scanner(System.in);
static int n;
static int ans = 0;
static Tree[] trees;
static int[][] adjaTable;
/**半径的平方后缀和*/
static int[] suffix;
public static void main(String[] args) {
//Instant now = Instant.now();
n = sc.nextInt();
initTrees();
initSuffix();
initAdjaTable();
dfs(0, 0);
System.out.println(ans);
//System.err.println("Duration:" + Duration.between(now, Instant.now()).toMillis());
}
private static void initSuffix() {
suffix = new int[n];
suffix[n - 1] = trees[n - 1].pow_r;
for (int i = n - 2; i >= 0; i--) {
//后缀和加当前项的平方
suffix[i] = suffix[i + 1] + trees[i].pow_r;
}
}
/**
* 初始化邻接矩阵
*/
private static void initAdjaTable() {
adjaTable = new int[n][n];
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (trees[i].intersected(trees[j])) {
adjaTable[i][j] = 1;
adjaTable[j][i] = 1;
}
}
}
}
/**
* 初始化每棵树并加入数组
*/
private static void initTrees() {
trees = new Tree[n];
for (int i = 0; i < n; i++) {
trees[i] = new Tree(sc.nextInt(), sc.nextInt(), sc.nextInt());
}
//!!!!排序
Arrays.sort(trees);
}
private static void dfs(int sum, int index) {
//边界
if (index == n) {
ans = Math.max(ans, sum);
return;
}
//！！！如果index之前的sum加上自index开始的半径的平方和小于ans，则没必要继续
if (sum + suffix[index] <= ans)
return;
// 2.选这棵树（是有条件的）
if (ok(index)) {
trees[index].selected = true;
dfs(sum + trees[index].pow_r, index + 1);
trees[index].selected = false; //回溯
}
//1.不选当前这棵树
trees[index].selected = false;
dfs(sum, index + 1);
}
private static boolean ok(int index) {
for (int i = 0; i < index; i++) {
//i被选入，且i与当前准备入选的index相交，则index代表的树不能入选
if (trees[i].selected && adjaTable[i][index] == 1)
return false;
}
return true;
}
private static class Tree implements Comparable<Tree> {
int x, y, r, pow_r;
boolean selected; // 是否入选
public Tree(int x, int y, int r) {
this.x = x;
this.y = y;
this.r = r;
pow_r = r * r;
}
/**与另一颗树是否相交*/
public boolean intersected(Tree other) {
int dis = (this.x - other.x) * (this.x - other.x) + (this.y - other.y) * (this.y - other.y);
return dis < (this.r + other.r) * (this.r + other.r);
}
@Override
public int compareTo(Tree o) {
return this.r - o.r;
}
}
}