【问题描述】
将LANQIAO中的字母重新排列，可以得到不同的单词，如LANQIAO、AAILNOQ等，注意这7个字母都要被用上，单词不一定有具体的英文意义。
请问，总共能排列如多少个不同的单词。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
求全排，去重，计数
代码如下：
package com.mike.linda;
import java.util.HashSet;
import java.util.Set;
/*
* 3 单词重排
【问题描述】
将LANQIAO中的字母重新排列，可以得到不同的单词，如LANQIAO、AAILNOQ等，注意这7个字母都要被用上，单词不一定有具体的英文意义。
请问，总共能排列如多少个不同的单词。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
*/
//解析，求全排，去重，计数
public class Class_3单词重排 {
//Set集合存储无序唯一的元素，HashSet底层是哈希表存储无序唯一的元素
//LinkedHashSet存储有序唯一的元素，它的底层是链表和哈希表，链表保证元素有序
//哈希表保证元素唯一，TreeSet底层是红黑树，自平衡二叉树，存储有序唯一的元素，
//通过元素比较保证唯一。
//ans存储全排列的所有字符串，重复的字符串在集合中只保留一份。
private static Set<String> ans=new HashSet<>();
private static char[] a="LANQIAO".toCharArray();
private static char[] tmp=new char[7];
//标记字符是否赋值给tmp，true表示已赋值，false未赋值
private static boolean[] vis=new boolean[7];
public static void main(String[] args) {
dfs(0);
System.out.println(ans.size());
}
//递归实现全排列,此处递归不好理解，debug一下吧
//总而言之有关递归的问题需要反反复复的去理解，自己一步步走程序
//深刻理解的递归的运行过程。
//递归回溯。把递归理解成一层一层的。这一层的变量tmp与上一层的变量tmp不一样
//虽然名字一样，在内存里面是放在递归栈中。有关递归问题这里不再详述。自己百度看视频
//等等。
private static void dfs(int k){
if (k==7) {
ans.add(new String(tmp));
return;
}
//每次递归都要遍历a字符数组，判断它的赋值情况
for (int i = 0; i < 7; i++) {
if (!vis[i]) {
tmp[k]=a[i];
vis[i]=true;
dfs(k+1);//a[i]赋给tmp后，以a[i]开始所有的字符序列
vis[i]=false;//重置，使a[i]先不赋值给tmp,后面的递归会将其再次赋值给tmp
}
}
}
}
运行结果如下图：
2520
此题还可以使用高中的数学知识求解即排列组合。对“LANQIAO”而言，因为有两个A
故第一步先安排好2个A的位置，它们放在7个位子上，有C(7,2)=21种，第二步放剩下的五个位置，剩余5个字母不同，故全排列即有A(5,5)=120种.如此本题最终结果：21*120=2520种。
【问题描述】
由1对括号，可以组成一种合法括号序列：()。
由2对括号，可以组成两种合法括号序列：()()、(())。
由4对括号组成的合法括号序列一共有多少种？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
因为只有4对括号，本题可以穷举所有的结果。如有更多的括号，则穷举不是人可以做的，需要交给程序执行。典型的递归结构，每个位置只有两种选择，要么选最括号，要么选右括号
package com.mike.linda;
/**
*
* @Description
* @author mike
* @version
* @date 2021-3-22上午10:53:14
*
*/
public class Class_4括号序列 {
public static void main(String[] args) {
System.out.println(solve(1, 1, 1));
System.out.println(solve(2, 2, 2));
System.out.println(solve(3, 3, 3));
System.out.println(solve(4, 4, 4));
System.out.println(solve(10, 10, 10));
}
/**
*
* @Description
* @author mike
* @date 2021-3-22上午10:53:55
* @param n 括号对的数量
* @param k 剩余左括号的数量
* @param r 剩余右括号的数量
*/
private static int solve(int n,int k,int r){//递归慢慢地将规模变小
if (k==0&&r==0) {//递归出口
return 1;
}
int ans=0;
//要么选左括号，要么选右括号
//选左括号的条件：k>0且变化后存在的左括号的数量始终大于或等于已存在的右括号的数量
if (k>0&&n-(k-1)>=n-r) {
ans+=solve(n, k-1, r);
}
//选右括号的条件：r>0且变化后存在的右括号的数量始终小于或等于已存在的左括号的数量
if (r>0&&n-(r-1)<=n-k) {
ans+=solve(n, k, r-1);
}
return ans;
}
}
测试情况如下：
1
2
5
14
16796
【问题描述】
对于一个 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。
本题核心的思想就在于模拟填数的过程。
代码如下：
package com.mike.linda;
import java.util.Scanner;
/**
*
* @Description
* @author mike
* @version
* @date 2021-3-22下午3:10:26
*
*/
public class Class_7螺旋 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
int m=scanner.nextInt();
int r=scanner.nextInt();
int c=scanner.nextInt();
//矩阵(包含0索引)
int[][] arr=new int[n][m];
int sum=1;
int i=0,j=0;
int a=0,b=n-1;//记录行的位置范围外圈向内圈时，a++,b--
int d=0,e=m-1;//记录列的位置范围
//模拟填数的过程(核心思想程序模拟填数的过程)
while(true){
// //向右
// for(;j<m-1;j++){
// arr[i][j]=sum;
// sum++;
// }
//
// //上述循环结束后j指向最后一列
// //向下
// for(;i<n-1;i++){
// arr[i][j]=sum;
// sum++;
// }
//
// //上述循环结束后i指向最后一行
// //向左
// for(;j>0;j--){
// arr[i][j]=sum;
// sum++;
// }
//
// //上述循环结束后j指向第一列
// //向上
// for(;i>0;i--){
// arr[i][j]=sum;
// sum++;
// }
//
// //上述一轮循环把矩阵外圈的位置都填了数字，现在开始填里面的一圈
//进行下一轮循环，sum等于矩阵个数退出循环。
// i++;
// j++;
//向右
for(;j<e;j++){
arr[i][j]=sum;
sum++;
}
//上述循环结束后j指向e列
//向下
for(;i<b;i++){
arr[i][j]=sum;
sum++;
}
//上述循环结束后i指向b行
//向左
for(;j>d;j--){
arr[i][j]=sum;
sum++;
}
//上述循环结束后j指向d列
//向上
for(;i>a;i--){
arr[i][j]=sum;
sum++;
}
//上述循环结束后i指向a行
//上述四个循环完后，此时的i，j指向a行，d列与第一个数重叠
//故i++,j++且a++,d++,b--,e--,开始下一轮循环
//上述一轮循环把矩阵外圈的位置都填了数字，现在开始填里面的一圈
i++;
j++;
a++;
d++;
b--;
e--;
if (sum==n*m+1) {//说明已填完
break;
}
}
//验证输出数组是否正确。
// for (int k = 0; k < arr.length; k++) {
// for (int k2 = 0; k2 < arr[k].length; k2++) {
// System.out.print(arr[k][k2]+" ");
// }
// System.out.println();
// }
System.out.println(arr[r-1][c-1]);//数组索引从0开始，特别注意这一点，题目所说的几行几列是从1开始的
}
}
运行结果如下：
4 5
2 2
15
郑未老师的代码解读如下：
package com.mike.linda;
import java.util.Scanner;
/**
*
* @Description
* @author mike
* @version
* @date 2021-3-22下午4:08:11
*
*/
public class Class_7螺旋2 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
int m=scanner.nextInt();
int r=scanner.nextInt();
int c=scanner.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--;
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]);
}
}
运行结果如下：
4 5
2 2
15
【问题描述】
如果一个序列的奇数项都比前一项大，偶数项都比前一项小，则称为一个摆动序列。即 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。
解法一：（我的思路）得益于前面的全排列的递归思想，可以枚举出所有的序列（注意这里序列是可以重合的，所以不需要布尔数组标记此数字是否使用过），看他是否符合a[2i]<a[2i-1], a[2i+1]>a[2i]。这种暴力算法效率最低啦。
package com.mike.linda;
import java.util.Arrays;
import java.util.Scanner;
public class Class_8摆动序列 {
private static int[] temp;
static int m;
static int n;
private static int count;
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
m=scanner.nextInt();
n=scanner.nextInt();
temp=new int[m];
dfs(0);//递归回溯
System.out.println(count%10000);
}
private static void dfs(int t){
if (t==m) {
boolean flag=true;
//对于temp而言索引为0的位置即为题目所说的1的位置即奇数项
for (int i = 1; i < temp.length; i++) {
if (i%2==0) {
flag=(temp[i]>temp[i-1]);
}else{
flag=(temp[i]<temp[i-1]);
}
if(!flag){
break;//说明此时序列不符合要求
}
}
if (flag) {
// System.out.println(Arrays.toString(temp));
count++;
}
return;
}
for (int i = 1; i <=n ; i++) {
temp[t]=i;
dfs(t+1);
}
}
}
测试结果：
10 10
3256
本程序测试这个结果花了至少30多秒，才出结果，显然算法效率不高。只适用于20%的评测用例。一般好的算法程序是1秒内即出结果。
解法二：第1位可选[2,n]
选定第一位（last1），开始选第二位，可选[1,last1-1],对所有以last1开头的序列求和
选定第二位（last2），开始选第三位，可选[last1+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
这里面有大量重复子问题，所以可以记忆型递归；但只能过80%的数据，因为复杂度是O(N³) 。 (dfs递归最多有n层递归，每层最多n次循环，为O(n^2))
package com.mike.linda;
import java.util.Scanner;
/**
*
* @Description
* @author mike
* @version
* @date 2021-3-22下午7:44:55
*
*/
public class Class_8摆动序列2 {
private static final int MOD=10000;
//men[last][k]表示第k个位置确定为last的所有结果的数目
private static long[][] mem=new long[1001][1001];//数字很大，int不够用。
private static int n,m;
/**
* 第k个数确定为last时，序列总数即dfs(last,k)=mem[last][k]
* @Description
* @author mike
* @date 2021-3-22下午7:02:40
* @param last 确定的最后一个数
* @param k 第k个
* @return
*/
private static long dfs(int last,int k){
if (k==m) {
return 1;
}
if (mem[last][k]!=0) {//这步优化，记忆一些子问题的结果，直接返回
//这里面有大量重复子问题，所以可以记忆型递归
return mem[last][k];
}
//k是奇数，k+1是偶数，偶数位比前一位小
if (k%2==1) {
for (int i = 1; i < last; i++) {
mem[last][k]=mem[last][k]+dfs(i, k+1);
}
}else{//k是偶数，k+1是奇数数，奇数位比前一位大
for (int i = last+1; i < n+1; i++) {
mem[last][k]=mem[last][k]+dfs(i, k+1);
}
}
return mem[last][k];
}
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
m=scanner.nextInt();
n=scanner.nextInt();
long ans=0;
//第一位可以选2到n，不能选1，否则第二位是偶数不能比前一位小。
for (int i = 2; i < n+1; i++) {
ans+=dfs(i, 1);
}
System.out.println(ans%MOD);//10秒左右
}
}
测试用例如下：
3 4
14
100 100
1220
//一秒就出结果啦，很快
1000 1000
9783
//这个结果大概8秒左右才出，显然这种算法只能解决80%的用例。所以需要优化此算法或另寻思路。
解法三：对解法二进行优化。这种在递归中加总的递归形态，往往可以通过优化递归式来改进。将递归式变成有汇总或集合的含义。从而减少一层循环。
可从递归起点的那个循环考虑，既然要加总第一位选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)
package com.mike.linda;
import java.util.Scanner;
/**
*
* @Description
* @author mike
* @version
* @date 2021-3-22下午8:31:53
*
*/
public class Class_8摆动序列3 {
private static final int MOD=10000;
private static int[][] mem=new int[1001][1001];
private static int n,m;
/**
* dfs(last,k)表示第k（偶数或奇数）位选[1,last]或[last,n]
* 这若干情况的所有结果的和,也即等于mem[last][k]
* @Description
* @author mike
* @date 2021-3-22下午8:34:17
* @param last 第k位可以确定的一个值
* @param k 第k位
* @return
*/
private static int dfs(int last,int k){
if (last<1||last>n) {//last有加减故有判断，越界即返回0
return 0;
}
if (k==m) {
//奇数，return大于等于last的个数；偶数，return小于等于last的个数
if (k%2==1) {
//最后一位选[last,n]若干种情况的和
mem[last][k]=n-last+1;
}else{
//最后一位选[1,last]若干种情况的和
mem[last][k]=last;
}
return mem[last][k];
}
if (mem[last][k]!=0) {//记录了一些子问题的解，可直接返回
return mem[last][k];
}
if (k%2==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 scanner=new Scanner(System.in);
m=scanner.nextInt();
n=scanner.nextInt();
System.out.println(dfs(2, 1));
}
}
测试用例：
3 4
14
90 100
3776
100 100
Exception in thread "main" java.lang.StackOverflowError
at com.mike.linda.Class_8摆动序列3.dfs(Class_8摆动序列3.java:51)
at com.mike.linda.Class_8摆动序列3.dfs(Class_8摆动序列3.java:51)
由此可见这种递归算法递归层次太深，会超出栈空间限制。虽然速度变快啦，但内存不够用。
解法四：对解法三进行优化。
为什么还要优化呢？因为这样递归层次太深，会超出栈空间限制。
递推是递归的逆过程，因此我们观察上述递归函数的出口，就知道怎么初始化dp数组，再按照与递归相逆的顺序逐步生成递推数组。
递归出口：
if (last<1||last>n) {//last有加减故有判断，越界即返回0
return 0;
}
if (k==m) {
//奇数，return大于等于last的个数；偶数，return小于等于last的个数
if (k%2==1) {
//最后一位选[last,n]若干种情况的和
mem[last][k]=n-last+1;
}else{
//最后一位选[1,last]若干种情况的和
mem[last][k]=last;
}
return mem[last][k];
}
转变为数组初始化：
//初始化最后一列
for (int i = 1; i < n+1; i++) {
if (m%2==1) {
mem[i][m]=n-i+1;
}else{
mem[i][m]=i;
}
}
递归中列数是逐渐增加的，递推从最后一列往前推至第一列
代码优化如下：
package com.mike.linda;
import java.util.Scanner;
/**
*
* @Description
* @author mike
* @version
* @date 2021-3-22下午9:20:58
*
*/
public class Class_8摆动序列4 {
private static final int MOD=10000;
private static int[][] mem=new int[1001][1001];
private static int m,n;
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
m=scanner.nextInt();
n=scanner.nextInt();
//初始化最后一列
for (int i = 1; i < n+1; i++) {
if (m%2==1) {
mem[i][m]=n-i+1;
}else{
mem[i][m]=i;
}
}
for (int k = m-1; k >0; k--) {//从后列往前列递推赋值
if (k%2==1) {
//奇数，i从大到小遍历
for (int i = n; i >0; i--) {
//考虑边界条件i+1<=n?mem[i+1][k]:0
mem[i][k]=((i+1<=n?mem[i+1][k]:0)+(i-1>0?mem[i-1][k+1]:0))%MOD;
}
}else{
//偶数，i从小到大遍历
for (int i = 1; i < n+1; i++) {
考虑边界条件(i-1>0?mem[i-1][k]:0
mem[i][k]=((i-1>0?mem[i-1][k]:0)+(i+1<=n?mem[i+1][k+1]:0))%MOD;
}
}
}
System.out.println(mem[2][1]);
}
}
测试用例：
1000 1000
679
一秒之内结果出来啦
3 4
14
90 100
3776
总结：递归思路，递归优化（记忆），递归转递推，汇总与集合的概念。分而治之策略。好的算法它必定是高效的，代码是优雅简洁的。
【问题描述】
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算法
村庄看作顶点，编号存储，两两组成边，用cost作为边的权。
做好数据处理，然后排序，从小到大添加边到最小生成树的边集（不用真正添加，累加代价即可，不符合的忽略）。
符合不符合则要用到并查集。
代码如下：
package com.mike.linda;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
/**
* 克鲁斯卡尔算法实现最小生成树
* @Description
* @author mike
* @version
* @date 2021-3-23下午12:09:33
*
*/
public class Class_9通电 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
//接下来n行每行三个数
int[][] data=new int[n+1][3];
for (int i = 1; i <= n; i++) {
data[i][0]=scanner.nextInt();
data[i][1]=scanner.nextInt();
data[i][2]=scanner.nextInt();
}
//将原始数据处理成边集，每两个点一个边，计算代价
List<Edge> edges=new ArrayList<Edge>();
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;
}
}
}
/**
* %f 字段宽度与小数点位数均为系统默认，默认小数点为6位；
%e 小数点左侧1位，即个位，小数点右侧还是6位;
%4.2f 字段长度为4位，保留2位小数，遵从四舍五入；
%3.1f 字段长度为3位，可以自动扩大，小数点后1位，遵从四舍五入;
%10.3f 字段长度为10位，小数点保留3位，遵从四射五入，数字右对齐 字段不够用空格填充；
*/
System.out.printf("%.2f",ans);
}
//封装并查集操作
/**
* 并查集是一种树型的数据结构，用于处理一些不相交集合（disjoint sets）的合并及查询问题。常常在使用中以森林来表示
* 一、初始化
把每个点所在集合初始化为其自身。
通常来说，这个步骤在每次使用该数据结构时只需要执行一次，无论何种实现方式，时间复杂度均为O(N)。
二、查找
查找元素所在的集合，即根节点。
三、合并
将两个元素所在的集合合并为一个集合。
通常来说，合并之前，应先判断两个元素是否属于同一集合，这可用上面的“查找”操作实现。
* @Description
* @author mike
* @version
* @date 2021-3-23下午1:16:15
*
*/
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;
}
}
//寻找x的根节点而非父节点，注意，一个根节点就代表一群集合
//寻找的过程中，把每个顶点的父节点都设为根节点。
/**
* 优化路径压缩
①思想
每次查找的时候，如果路径较长，则修改信息，以便下次查找的时候速度更快。
②实现
第一步，找到根结点。
第二步，修改查找路径上的所有节点，将它们都指向根结点。
* @Description
* @author mike
* @date 2021-3-23下午1:18:58
* @param x
* @return
*/
int find(int x){
if (parent[x]==x) {//x是自己的父节点同时也是自己的根节点
return x;
}
HashSet<Integer> path=new HashSet<>();
while(parent[x]!=x){//沿父节点上寻直至根节点x退出循环
path.add(x);
x=parent[x];
}
for (Integer xx : path) {
//将这些（顶点的父节点不等于自身）的顶点的父节点都设为x
//此时x同时也是这群顶点的根节点，它代表这一个帮派，它是帮主。
parent[xx]=x;
}
return x;
}
//a所在的集合与b所在的集合合并，合并集合的根节点为a所在集合的根节点。
//所谓根节点就是集合的一个代表或帮主。
void union(int a,int b){//集合合并
//b的根节点的父节点设为a的根节点，意味着b的根节点代表的集合融入到
//a的根节点代表的集合成一个大集合，此集合的根节点为a的根节点。
parent[find(b)]=find(a);
}
}
//计算a，b两个村庄的建设代价
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) {
// 以cost为准，Edge从小到大排序
return this.cost<o.cost?-1:(this.cost==o.cost?0:1);
}
}
}
测试结果如下：
4
1 1 3
9 9 7
8 8 6
4 5 4
17.41
解法二：普里姆算法生成最小生成树
G=(V,E)是n个顶点的带权连通图（这里的权即为两个村庄之间的建设成本 ）T=(U,TE)是G的最小生成树，U是T的顶点集，TE是T的边集，则由G构造从起始点v出发的最小生成树T的步骤如下：
（1）初始化U={v}，以v到其他顶点的所有边为侯选边
（2）重复以下步骤n-1次，使得其他n-1个顶点被加入到U中
①从侯选边中选权值最小的边加入TE中，设该边在V-U中的顶点是k，将k加入U中
②考察当前V-U中的所有顶点j，修改侯选边，若(k,j)的权值小于原来和顶点j关联的侯选边，则用(k,j)取代后者作为侯选边。
代码如下：
package com.mike.linda;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
/**
* 普里姆算法实现最小生成树
* @Description
* @author mike
* @version
* @date 2021-3-23下午12:09:33
*
*/
public class Class_9通电2 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
//接下来n行每行三个数
int[][] data=new int[n+1][3];
for (int i = 1; i <= n; i++) {
data[i][0]=scanner.nextInt();
data[i][1]=scanner.nextInt();
data[i][2]=scanner.nextInt();
}
double[][] edges=new double[n+1][n+1];//以1,2,3,...,n代表n个村庄的编号
for (int i = 1; i < n+1; i++) {
for (int j = 1; j < n+1; j++) {
edges[i][j]=cost(data[i], data[j]);
}
}
Graph g=new Graph(n, edges);
double ans=prim(g, 1);
/**
* %f 字段宽度与小数点位数均为系统默认，默认小数点为6位；
%e 小数点左侧1位，即个位，小数点右侧还是6位;
,；
%3.1f 字段长度为3位，可以自动扩大，小数点后1位，遵从四舍五入;
%10.3f 字段长度为10位，小数点保留3位，遵从四射五入，数字右对齐 字段不够用空格填充；
*/
System.out.printf("%.2f",ans);
}
/**
*
* @Description
* @author mike
* @date 2021-3-23下午6:49:11
* @param g 图对象
* @param v 起始顶点,从1开始
* @return
*/
private static double prim(Graph g,int v){
/**
* 对于V-U中的一个顶点j，它的最小边对应U中的某个顶点k,则closest[j]=k,
* 最小边(closest[j],j),其权值为lowcost[j]
* 此外lowcost[j]=0可表示j属于U中，不等于0属于U-V中
*/
double[] lowcost=new double[g.n+1];//0位置不用
int[] closest=new int[g.n+1];//0位置不用
double min;
int k=1;//记录最近顶点的编号
double ans=0;//记录最小生成树的成本
/**
* 初始时，U中只有一个顶点v。对于V-U中所有顶点i，(v,i)就是最小边，
* 置lowcost[i]=g.edges[v][i](没有边时为大数，v到v时为0)
* closest[i]=v,lowcost[v]=0时，表明v已添加在U中
*/
for(int i=1;i<=g.n;i++){//给lowcost和closest置初值
lowcost[i]=g.edges[v][i];
closest[i]=v;
}
for (int i = 2; i <= g.n; i++) {//找出(n-1)个顶点
min=Double.MAX_VALUE;
/**
* 在侯选边中求一条最小边，扫描V-U中的所有顶点j,通过比较lowcost值求出
* 最小lowcost值对应的顶点k，则(closest[k],k)为最小边，输出它
* 并将k加入U中，即置lowcost[k]=0,一次循环确定一个点一条边。
*/
for (int j = 1; j <= g.n; j++) {//在V-U中找出离U最近的顶点k
if (lowcost[j]!=0&&lowcost[j]<min) {
min=lowcost[j];
k=j;//记录最近顶点的编号
}
}
//输出最小生成树的一条边
// System.out.printf("边(%d,%d)权为：%d\n",closest[k],k,min);
ans+=min;
lowcost[k]=0;//标记k已加入U中
/**
* 调整就是修改侯选边，即考虑V-U中的顶点。对于V-U中的j(lowcost[j]!=0)
* 在上一步（顶点k还没有添加到U中）lowcost[j]保存的是顶点j到U中顶点
* closes[j]的最小边，而现在U发生了变化（U中增加了顶点k），所以需要将原来的
* lowcost[j]与g.edges[k][j]比较，若g.edges[k][j]小，选择(k,j)为
* 新的最小边，即lowcost[j]=g.edges[k][j],closest[j]=k,否则顶点j
* 的侯选边不变
*/
for (int j = 1; j <= g.n; j++) {//对(V-U)中的顶点j进行调整
if (lowcost[j]!=0&&g.edges[k][j]<lowcost[j]) {
lowcost[j]=g.edges[k][j];
closest[j]=k;//修改数组closest,lowcost
}
}
}
return ans;
}
//计算a，b两个村庄的建设代价
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]);
}
}
class Graph{
int n;
double[][] edges;
public Graph(int n,double[][] edges){
this.n=n;
this.edges=edges;
}
}
测试用例：
4
1 1 3
9 9 7
8 8 6
4 5 4
17.41
总结：本题考察最小生成树的两种经典算法的求解。
【问题描述】
小明和朋友们一起去郊外植树，他们带了一些在自己实验室精心研究出的小树苗。
小明和朋友们一共有 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次方种，暴力搜索，深度优先搜索，递归。当一个圆准备选入时，可判断其与前面的是否冲突，如冲突则不选，此分支不用继续，此为剪支。
package com.mike.linda;
import java.util.Scanner;
/**
*
* @Description
* @author mike
* @version
* @date 2021-3-23下午8:48:24
*
*/
public class Class_10植树 {
static Scanner sc=new Scanner(System.in);
static int n;
static int ans;
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);//程序结束后，ans存储最大的值
return;
}
//选这棵树是有条件的
if (ok(index)) {
trees[index].selected=true;
int r=trees[index].r;
dfs(sum+r*r, index+1);
trees[index].selected=false;//回溯
}
//不选当前这棵树
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;
}
//与另一棵树是否相交
//返回true，为相交
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);
}
}
}
测试用例：
30
1 2 2
1 7 3
1 6 4
1 9 5
1 10 7
2 2 2
2 7 2
2 6 2
2 3 2
2 5 7
5 5 1
5 1 3
4 5 1
4 6 3
4 3 1
4 9 7
6 1 3
5 3 2
6 7 9
7 8 1
5 7 3
7 8 9
4 6 7
3 9 5
3 5 6
2 3 5
7 8 10
8 9 1
6 7 1
6 9 4
100
30
1 1 2
1 4 2
1 7 2
4 1 2
4 4 2
4 7 2
7 1 2
7 4 2
7 7 2
10 1 2
10 4 2
10 7 2
13 1 2
13 4 2
12 7 2
15 1 2
15 4 2
15 7 2
18 1 2
18 4 2
18 7 2
21 1 2
21 4 2
21 7 2
24 1 2
24 4 2
24 7 2
27 1 2
27 4 2
27 7 2
56
38
38毫秒出结果还是挺快的
感觉速度挺快的呀，郑未老师说n=30就不行啦。可能是测试用例选择的不够极端吧。
解法2：优化的关键点，将圆半径从大到小排序，优先选半径大的圆。把“选”这个分支放在“不选”这个分支前面执行，会尽快得到结果。
基于这个假设，在递归之前我们可以以O(N)的复杂度存储所有圆的“半径的平方”的后缀和，计为数组s；在递归函数dfs中，参数sum代表index之前的选择策略所得到的sum，s[index]代表包括index索引及之后续所有圆的半径的平方和，如果sum+s[index]小于等于已经求得的ans，那就不必进行任何后续的选择试探了，可立即退出递归。
package com.mike.linda;
import java.util.Arrays;
import java.util.Scanner;
/**
*
* @Description
* @author mike
* @version
* @date 2021-3-23下午8:48:24
*
*/
public class Class_10植树2 {
static Scanner sc=new Scanner(System.in);
static int n;
static int ans;
static Tree[] trees;
static int[][] adjaTable;
static int[] suffix;//半径的平方后缀和
public static void main(String[] args) {
n=sc.nextInt();
initTrees();
initSuffix();
initAdjaTable();
dfs(0, 0);
System.out.println(ans);
}
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);//程序结束后，ans存储最大的值
return;
}
//!!!如果index之前的sum加上自index开始的半径的平方和小于ans,则没必要继续
if(sum+suffix[index]<=ans){
return;
}
//选这棵树是有条件的
if (ok(index)) {
trees[index].selected=true;
int r=trees[index].r;
dfs(sum+r*r, index+1);
trees[index].selected=false;//回溯
}
//不选当前这棵树
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;
this.pow_r=r*r;
}
//与另一棵树是否相交
//返回true，为相交
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;
}
}
}
测试用例：
6
1 1 2
1 4 2
1 7 2
4 1 2
4 4 2
4 7 2
12
30
1 1 2
1 4 2
1 7 2
4 1 2
4 4 2
4 7 2
7 1 2
7 4 2
7 7 2
10 1 2
10 4 2
10 7 2
13 1 2
13 4 2
12 7 2
15 1 2
15 4 2
15 7 2
18 1 2
18 4 2
18 7 2
21 1 2
21 4 2
21 7 2
24 1 2
24 4 2
24 7 2
27 1 2
27 4 2
27 7 2
56
n=30秒出结果，本次优化仍然是剪支的思想。
本套题目考察递归的巧妙运用，递归的优化如改递归为递推，最小生成树的两种算法实现，数组填数的模拟过程。递归深度遍历是前面涉及到的排序的问题的实质。也就是说在遍历的基础上我们可以加上输出或统计的操作等等。由此可知，我们一定要亲手去敲代码去模拟实现数据结构上的数据结构及其算法实现，这样才会有更好的理解，以至于达到自己不看书就可以实现其功能的程度。这样才算真正掌握啦。本文是对其原文的解读。
————————————————
版权声明：本文为CSDN博主「小9」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zhengwei223/article/details/106177541
请各位同仁不吝赐教！