本文详细介绍了分治算法，包括分治法的基本步骤、汉诺塔问题的分治解法及二分查找的实现细节，如左边界处理、溢出预防和查重优化。接着探讨了动态规划，以背包问题为例展示了动态规划的思路和代码实现。此外，还讲解了贪心算法的应用，通过集合覆盖问题阐述了贪心策略的思路和代码。
1.分治与二分查找
1.1分治算法介绍
分治法即“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法(快速排序，归并排序)，傅立叶变换(快速傅立叶变换)……
分治算法可以求解的一些经典问题
- 二分搜索
- 大整数乘法
- 棋盘覆盖
- 合并排序
- 快速排序
- 线性时间选择
- 最接近点对问题
- 循环赛日程表
- 汉诺塔
1.2分治算法基本步骤
分治法在每一层递归上都有三个步骤：
- **分解：**将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题
- **解决：**若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题
- **合并：**将各个子问题的解合并为原问题的解
1.3分治算法设计模式
if |P|≤n0
then return(ADHOC(P))
//将P分解为较小的子问题 P1 ,P2 ,…,Pk
for i←1 to k
do yi ← Divide-and-Conquer(Pi) // 递归解决Pi
T ← MERGE(y1,y2,…,yk) // 合并子问题
return(T)
- 其中|P|表示问题P的规模；n0为一阈值，表示当问题P的规模不超过n0时，问题已容易直接解出，不必再继续分解。
- ADHOC§是该分治法中的基本子算法，用于直接解小规模的问题P。 因此，当P的规模不超过n0时直接用算法ADHOC§求解。
- 算法MERGE(y1,y2,…,yk)是该分治法中的合并子算法，用于将P的子问题P1 ,P2
,…,Pk的相应的解y1,y2,…,yk合并为P的解
1.4汉诺塔
在一根柱子上从下往上按照大小顺序摞着64片圆盘，圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
1.4.1分治思路
- 如果 A 塔上只有一个盘子：
- 直接将 A 塔的盘子移动到 C 塔：A —> C
- 如果 A 塔上有两个盘子：
- 先将 A 塔上面的盘子移动到 B 塔：A —> B
- 再将 A 塔最下面的盘子移动到 C 塔：A --> C
- 最后将 B 塔上面的盘子移动到 C 塔：B --> C
- 如果 A 塔上有三个盘子：
- n >= 2 时，就体现出了分治算法的思想：我们将 A 塔上面的盘子看作一个整体，最下面的单个盘子单独分离出来，分三步走
- 先将 A 塔上面的盘子看作一个整体，移动到 B 塔（把 C 塔当做中转站）
- 这样 A 塔就只剩下一个最大的盘子，将 A 塔剩下的盘子移动到 C 塔
- 最后将 B 塔上面的盘子移动到 C 塔（把 A 塔当做中转站）
1.4.2代码实现
解决汉诺塔问题：
public class Hanoitower {
public static void main(String[] args) {
hanoiTower(3, 'A', 'B', 'C');
}
//汉诺塔的移动的方法
//使用分治算法
public static void hanoiTower(int num, char a, char b, char c) {
//如果只有一个盘
if(num == 1) {
System.out.println("第1个盘从 " + a + "->" + c);
} else {
//如果我们有 n >= 2 情况，我们总是可以看做是两个盘 1.最下边的一个盘 2. 上面的所有盘
//1. 先把 最上面的所有盘 A->B， 移动过程会使用到 c
hanoiTower(num - 1, a, c, b);
//2. 把最下边的盘 A->C
System.out.println("第" + num + "个盘从 " + a + "->" + c);
//3. 把B塔的所有盘 从 B->C , 移动过程使用到 a塔
hanoiTower(num - 1, b, a, c);
}
}
}
程序运行结果
第1个盘从 A->C
第2个盘从 A->B
第1个盘从 C->B
第3个盘从 A->C
第1个盘从 B->A
第2个盘从 B->C
第1个盘从 A->C
我想捋一下，这个代码虽然见的很多，但感觉还是很新颖的，首先必须具有参数num也就是盘子的个数，其次如果按顺序把ABC作为参数，即代表一种解决方案，把A上的移动到C以B作为中转塔，那么此代码的核心出是你怎么体现思想里面的即把上面的所有盘子单独作为一个整体，分离出下面的大盘子，就当作是两个盘子来进行分治，
1.5二分查找
1.5.1二分查找基础版(一定要流畅写出)
public static int binarySearch(int[] arr,int value){
int left = 0;
int right = arr.length-1;
while(left <= right){
int midIndex = (left+right)/2;
if(arr[midIndex] > value){
right = midIndex-1;
}else if(arr[midIndex] < value){
left = midIndex+1;
}else {
return midIndex;
}
}
return -1;
}
1.5.2细节处理：
1.界限left<=right
首先最重要的细节就是为什么是left<=right，如果没注意到这个细节没事自己去手写的时候很容易就left<right，试想面试真的问这个问题你又如何去简单精炼的描述出这个问题，二分查找是建立在分治的基础上，那这里的left=0，right=arr.length-1就代表的是一个区间也就是问题的规模，如果while循环条件是left<right，也就是说当left=right的时候不再进入循环，但是left=right左右下标重合的时候此时还有一个数据没有进行比较处理，只有当退出条件是left>right两个下标进行错位，代表着整个问题的区域已经完全涵盖完全一个不漏，再去进行最后的return返回退出
2.溢出处理
如果数组的元素非常多，假如大约有20亿个数据，那么数据元素小标对应的区间也在0到20亿，这样是可以的，因为整形的最大值是2的31次方-1在21亿左右，那初始的midIndex下标就是在10亿，如果用上述代码去计算midIndex时首先要计算left+right=30亿左右，已经超过整形最大值溢出了，这里最好的做法是midIndex=(right-left+1)/2+left，这个计算方式也很好理解，right-left+1就是实际的left下标到right下标的元素个数，由于是只是纯粹的元素个数所以再除以2后想要得到真正的物理下标位置就要再加上left的起始下标，这样尽量以减法的形式进行运算可以更有效地避免类型溢出的问题
3.查重处理
我想要稍微改进一下，这个太过于呆板，我觉得至少要考虑一下查重问题，
比如一组数据{12,12,12,12,12,12,23,23,23,23,23,23,23,34,45,56,67}
我可能通过midIndex最后找到中间某个位置的12或23，能不能去最后返回特定位置的你想要的数据，比如最左边的12，最右边的23？那其实也很好写，就给最后return midIndex之前再加个while循环判断一下就ok,但是mid必须要大于left不然会越界
4.运算效率处理
有计算机底子的朋友都知道用>>运算符比除以2效率会更高，所以midIndex=(right-left)>>1+left，如果你不加思索直接这样写那就又上当了，右移运算符的优先级是小于加法的，所以表达式会先计算1+left，这就完的蛋蛋了，而且如果写代码时编译器本身不提示就会很难看出来，你要用右移的话得加括号midIndex=((right-left)>>1)+left
5.黄金分割
还是针对于除2操作，不过这次是从数学角度，除以2相当于乘0.5，熟悉数学的朋友应该会有内个感觉，就是乘0.618，黄金分割点，虽然说我们的二分查找是对数据区域进行折半不停的除2操作，但是这里乘黄金分割点和单纯乘0.5还是有着天差地别的，黄金分割点的效率更高
1.5.3二分查找进阶版
public static int FindValue(int[] arr,int left,int right,int val){
int pos = -1
if(left <= right){
int mid = (right - left + 1) / 2 + left;
if(val < arr[mid]){
pos = FindValue(arr,left,mid-1,vla);
}else if(val > arr[mid]){
pos = FindValue(arr,mid+1,right,val);
}else{
while(mid > left && arr[mid-1] == val){
--mid;
pos = mid;
}
}
}
}
2.动态规划
2.1动态规划算法介绍
- 动态规划(Dynamic Programming)算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法
- 动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
- 与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。 (即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解 )
- 动态规划可以通过填表的方式来逐步推进，得到最优解
2.2背包问题
2.2.1背包问题介绍
背包问题主要是指一个给定容量的背包、若干具有一定价值和重量的物品，如何选择物品放入背包使物品的价值最大。其中又分01背包和完全背包(完全背包指的是：每种物品都有无限件可用)
这里的问题属于01背包，即每个物品最多放一个。而无限背包可以转化为01背包。
2.2.2代码思路
背包容量为 4 磅，物品价格以及重量表如下：
| 物品 | 重量 | 价格 |
|---|---|---|
| 吉他(G) | 1 | 1500 |
| 音响(S) | 4 | 3000 |
| 电脑(L) | 3 | 2000 |
先来填表 v ，对应着数组 v[][]，我来解释下这张表：
- 算法的主要思想：利用动态规划来解决。
- 每次遍历到的第 i 个物品，根据 w[i - 1]（物品重量）和 val[i -
1]（物品价值）来确定是否需要将该物品放入背包中，C为背包的容量 v[i][j]表示在前 i 个物品中能够装入容量为 j 的背包中的最大价值
| 物品 | 0磅 | 1磅 | 2磅 | 3磅 | 4磅 |
|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | |
| 吉他(G) | 0 | ||||
| 音响(S) | 0 | ||||
| 电脑(L) | 0 |
- 对于第一行(i=1)，目前只有吉他可以选择，这时不管背包容量多大，也只能放一把吉他
| 物品 | 0磅 | 1磅 | 2磅 | 3磅 | 4磅 |
|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | |
| 吉他(G) | 0 | 1500(G) | 1500(G) | 1500(G) | 1500(G) |
| 音响(S) | 0 | ||||
| 电脑(L) | 0 |
- 对于第二行(i=2)，目前存在吉他和音响可以选择，新物品为音响，重量为 4 磅，尝试将其放入背包
- 在 v[2][4] 单元格，尝试将音响放入容量为 4 磅的背包中，看看背包还剩多少容量？还剩 0 磅，再去找找 0磅能放入最大价值多高的物品：v[1][0] = 0
- 与上一次 v[1][4] 比较 ， v[1][4] < v[2][4] ，发现确实比之前放得多，采取此方案
| 物品 | 0磅 | 1磅 | 2磅 | 3磅 | 4磅 |
|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | |
| 吉他(G) | 0 | 1500(G) | 1500(G) | 1500(G) | 1500(G) |
| 音响(S) | 0 | 1500(G) | 1500(G) | 1500(G) | 3000(S) |
| 电脑(L) | 0 |
- 对于第三行(i=3)，目前存在吉他和音响、电脑可以选择，新物品为电脑,重量为 3 磅，尝试将其放入背包
- 当背包容量为 3 磅时，可以放入电脑
-
在
v[3][3]单元格，尝试将电脑放入容量为 3 磅的背包中，看看背包还剩多少容量？还剩 0 磅，再去找找 0磅能放入最大价值多高的物品：v[2][0] = 0 -
与上一次
v[2][3]比较 ，v[2][3] < v[3][3]，发现确实比之前放得多，采取此方案
-
- 当背包容量为 4 磅时，可以放入电脑
- 在
v[3][4]单元格，尝试将电脑放入容量为 4 磅的背包中，看看背包还剩多少容量？还剩 1 磅，再去找找 1磅能放入最大价值多高的物品：v[2][1] = 1500，所以总共能放入的重量为v[3][4] = 3500 - 与上一次
v[2][4]比较 ，v[2][4] < v[3][4]，发现确实比之前放得多，采取此方案
- 在
- 当背包容量为 3 磅时，可以放入电脑
| 物品 | 0磅 | 1磅 | 2磅 | 3磅 | 4磅 |
|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | |
| 吉他(G) | 0 | 1500(G) | 1500(G) | 1500(G) | 1500(G) |
| 音响(S) | 0 | 1500(G) | 1500(G) | 1500(G) | 3000(S) |
| 电脑(L) | 0 | 1500(G) | 1500(G) | 2000(L) | 3500(L+G) |
总结公式：
- 当前新增物品的重量 > 背包的重量，则直接拷贝上次的方案
if (w[i - 1] > j) { // 因为我们程序i 是从1开始的，所以是 w[i-1]
v[i][j] = v[i - 1][j];
}
- 当前新增物品的重量 <= 背包的重量
- 尝试将新物品放入背包，看看还剩多少容量
- 尝试剩余的容量填满，看看此时背包里物品的价值和上次比，哪个更大，取价格更大的方案即可
if (w[i - 1] <= j) { // 因为我们程序i 是从1开始的，所以是 w[i-1]
v[i][j] = Math.max(v[i - 1][j], val[i - 1] + v[i - 1][j - w[i - 1]]);
}
为什么可以这样做？将大问题拆成小问题
- 第一步：求得第一步步骤的最优解
- 第二步：求得第二步步骤的最优解，第二步的最优解依赖于第一步的最优解
…
- 第 n 步：求得第 n 步步骤的最优解，第 n 步的最优解依赖于第 n-1 步的最优解
2.2.3代码实现
背包问题算法
public class KnapsackProblem {
public static void main(String[] args) {
int[] w = { 1, 4, 3 };// 物品的重量
int[] val = { 1500, 3000, 2000 }; // 物品的价值 这里val[i]
int m = 4; // 背包的容量
int n = val.length; // 物品的个数
// 创建二维数组，
// v[i][j] 表示在前i个物品中能够装入容量为j的背包中的最大价值
int[][] v = new int[n + 1][m + 1];
// 为了记录放入商品的情况，我们定一个二维数组
int[][] path = new int[n + 1][m + 1];
// 初始化第一行和第一列, 这里在本程序中，可以不去处理，因为默认就是0
for (int i = 0; i < v.length; i++) {
v[i][0] = 0; // 将第一列设置为0
}
for (int i = 0; i < v[0].length; i++) {
v[0][i] = 0; // 将第一行设置0
}
// 根据前面得到公式来动态规划处理
for (int i = 1; i < v.length; i++) { // 不处理第一行 i是从1开始的
for (int j = 1; j < v[0].length; j++) {// 不处理第一列, j是从1开始的
// 公式
if (w[i - 1] > j) { // 因为我们程序i 是从1开始的，所以是 w[i-1]
v[i][j] = v[i - 1][j];
} else {
// 说明:
// 因为我们的i 从1开始的， 因此公式需要调整成
// v[i][j] = Math.max(v[i - 1][j], val[i - 1] + v[i - 1][j - w[i - 1]]);
// 为了记录商品存放到背包的情况，我们不能直接的使用上面的公式，需要使用if-else来体现公式
if (v[i - 1][j] < val[i - 1] + v[i - 1][j - w[i - 1]]) {
v[i][j] = val[i - 1] + v[i - 1][j - w[i - 1]];
// 把当前的情况记录到path
path[i][j] = 1;
} else {
v[i][j] = v[i - 1][j];
}
}
}
}
// 输出一下v 看看目前的情况
for (int i = 0; i < v.length; i++) {
for (int j = 0; j < v[i].length; j++) {
System.out.print(v[i][j] + "\t ");
}
System.out.println();
}
System.out.println("============================");
// 动脑筋
int i = path.length - 1; // 行的最大下标
int j = path[0].length - 1; // 列的最大下标
while (i > 0 && j > 0) { // 从path的最后开始找
if (path[i][j] == 1) {
System.out.printf("第%d个商品放入到背包\n", i);
j -= w[i - 1]; // w[i-1]
}
i--;
}
}
}
程序运行结果
0 0 0 0 0
0 1500 1500 1500 1500
0 1500 1500 1500 3000
0 1500 1500 2000 3500
============================
第3个商品放入到背包
第1个商品放入到背包
2.3爬楼梯问题
2.3.1代码思路
- 当 n < 0 时，无解
- 当 n = 1 时，f (n) = 1
- 当 n = 2 时，有两种方法：
- 走两次一级楼梯
- 一下走两级楼梯
- 当 n > 2 时，设总共的跳法为 f(n) 中，第一次跳一级还是两级，决定了后面剩下的台阶的跳法数目的不同：
- 如果第一次只跳一级，则后面剩下的n-1级台阶的跳法数目为 f(n-1)
- 如果第一次跳两级，则后面剩下的 n-2 级台阶的跳法数目为 f(n-2)
- 所以，得出递归方程，f(n) = f(n-1) + f(n-2)，问题本质是斐波那契数列。
2.3.2代码实现
/**上台阶问题，dp**/
public static int climbStairs(int n) {
if(n==0) return -1;
if(n==1) return 1;
int []dp = new int [n];
dp[0] =1;
dp[1] =2;
for(int i=0;i<n-2;i++) {
dp[i+2]=dp[i]+dp[i+1];
}
return dp[n-1];
}
3.贪心算法
3.1应用场景(集合覆盖问题)
假设存在下面需要付费的广播台，以及广播台信号可以覆盖的地区。 如何选择最少的广播台，让所有的地区都可以接收到信号
| 广播台 | 覆盖地区 |
|---|---|
| K1 | “北京”, “上海”, “天津” |
| K2 | “广州”, “北京”, “深圳” |
| K3 | “成都”, “上海”, “杭州” |
| K4 | “上海”, “天津” |
| K5 | “杭州”, “大连” |
3.2贪心算法介绍
贪婪算法(贪心算法)是指在对问题进行求解时，在每一步选择中都采取最好或者最优(即最有利)的选择，从而希望能够导致结果是最好或者最优的算法
贪婪算法所得到的结果不一定是最优的结果(有时候会是最优解)，但是都是相对近似(接近)最优解的结果
3.2.1穷举法缺点
如何找出覆盖所有地区的广播台的集合呢，使用穷举法实现,列出每个可能的广播台的集合，这被称为幂集。假设总的有n个广播台，则广播台的组合总共有 2ⁿ -1 个,假设每秒可以计算10个子集
| 广播台数量n | 子集数2^n | 需要的时间 |
|---|---|---|
| 5 | 32 | 3.2秒 |
| 10 | 1024 | 102.4秒 |
| 32 | 4294967296 | 13.6年 |
| 100 | 1.26*100³º | 4x10²³年 |
3.2.2代码思路
- 目前并没有算法可以快速计算得到准备的值， 使用贪婪算法，则可以得到非常接近的解，并且效率高
- 在选择策略上，因为需要覆盖全部地区的最小集合，大致思路如下： 声明
- 几个辅助变量：
ArrayList<String> selects;：存放已经选取的电台，比如 { K1, K2, …}HashSet<String> allAreas;：存放当前还未覆盖的地区String maxKey = null;：存放当前能覆盖最多未覆盖地区的电台，比如 K1、K2
- 在所有电台中，找到一个能覆盖最多还未覆盖地区的电台（此电台可能包含一些已覆盖的地区，但没有关系）：maxKey
- 将其加入到 selects 集合中，表示已经选了该电台
- 将 maxKey 电台中的地区从 allAreas 中移除
重复如上步骤，直至 allAreas 为空
3.2.3代码实现
使用贪心算法解决集合覆盖问题
public class GreedyAlgorithm {
public static void main(String[] args) {
// 创建广播电台,放入到Map
HashMap<String, HashSet<String>> broadcasts = new HashMap<String, HashSet<String>>();
// 将各个电台放入到broadcasts
HashSet<String> hashSet1 = new HashSet<String>();
hashSet1.add("北京");
hashSet1.add("上海");
hashSet1.add("天津");
HashSet<String> hashSet2 = new HashSet<String>();
hashSet2.add("广州");
hashSet2.add("北京");
hashSet2.add("深圳");
HashSet<String> hashSet3 = new HashSet<String>();
hashSet3.add("成都");
hashSet3.add("上海");
hashSet3.add("杭州");
HashSet<String> hashSet4 = new HashSet<String>();
hashSet4.add("上海");
hashSet4.add("天津");
HashSet<String> hashSet5 = new HashSet<String>();
hashSet5.add("杭州");
hashSet5.add("大连");
// 加入到map
broadcasts.put("K1", hashSet1);
broadcasts.put("K2", hashSet2);
broadcasts.put("K3", hashSet3);
broadcasts.put("K4", hashSet4);
broadcasts.put("K5", hashSet5);
// allAreas 存放所有的地区
HashSet<String> allAreas = new HashSet<String>();
for (Entry<String, HashSet<String>> broadcast : broadcasts.entrySet()) {
allAreas.addAll(broadcast.getValue());
}//set集合的addAll方法可去重
// 创建ArrayList, 存放选择的电台集合
ArrayList<String> selects = new ArrayList<String>();
// 定义一个临时的集合， 在遍历的过程中，存放遍历过程中的电台覆盖的地区和当前还没有覆盖地区的交集
HashSet<String> tempSet = new HashSet<String>();
// 定义给maxKey ， 保存在一次遍历过程中，能够覆盖最大未覆盖的地区对应的电台的key
// 如果maxKey 不为null , 则会加入到 selects
String maxKey = null;
Integer maxCount = 0;
Integer curCount = 0;
while (allAreas.size() != 0) { // 如果allAreas 不为0, 则表示还没有覆盖到所有的地区
// 每进行一次while，需要重置指针，重置计数器
maxKey = null;
maxCount = 0;
// 遍历 broadcasts, 取出对应key
for (String key : broadcasts.keySet()) {
// 每进行一次for清除tempSet
tempSet.clear();
// 当前这个key能够覆盖的地区
HashSet<String> areas = broadcasts.get(key);
tempSet.addAll(areas);
// 求出tempSet 和 allAreas 集合的交集, 交集会赋给 tempSet
tempSet.retainAll(allAreas);
// 当前站台可以覆盖额外的多少个城市
curCount = tempSet.size();
// 如果当前这个集合包含的未覆盖地区的数量，比maxKey指向的集合地区还多，就需要重置maxKey
// curCount > maxCount 体现出贪心算法的特点,每次都选择最优的
if (curCount > maxCount) {
maxKey = key;
maxCount = curCount;
}
}
// maxKey != null, 就应该将maxKey 加入selects
if (maxKey != null) {
selects.add(maxKey);
// 将maxKey指向的广播电台覆盖的地区，从 allAreas 去掉
allAreas.removeAll(broadcasts.get(maxKey));
}
}
System.out.println("得到的选择结果是" + selects);// [K1,K2,K3,K5]
}
}
程序运行结果
得到的选择结果是[K1, K2, K3, K5]
4.普里姆算法
4.1应用场景(修路问题)
- 看一个应用场景和问题：
- 有胜利乡有7个村庄(A, B, C, D, E, F, G) ，现在需要修路把7个村庄连通 各个村庄的距离用边线表示(权) ，比如 A –
B 距离 5公里 - 问：如何修路保证各个村庄都能连通，并且总的修建公路总里程最短?
- 有胜利乡有7个村庄(A, B, C, D, E, F, G) ，现在需要修路把7个村庄连通 各个村庄的距离用边线表示(权) ，比如 A –
- 正确的思路，就是尽可能的选择少的路线，并且每条路线最小，保证总里程数最少
4.2最小生成树
- 修路问题本质就是就是最小生成树问题， 先介绍一下最小生成树(Minimum Cost Spanning Tree)，简称MST。
- 给定一个带权的无向连通图，如何选取一棵生成树，使树上所有边上权的总和为最小，这叫最小生成树
- N个顶点，一定有N-1条边
- 包含全部顶点
- N-1条边都在图中
- 求最小生成树的算法主要是普里姆算法和克鲁斯卡尔算法
4.3普里姆算法介绍
-
普利姆(Prim)算法求最小生成树，也就是在包含n个顶点的连通图中，找出只有(n-1)条边包含所有n个顶点的连通子图，也就是所谓的极小连通子图
-
普利姆的算法如下:
- 设G=(V,E)是连通网，T=(U,D)是最小生成树，V,U是顶点集合，E,D是边的集合
- 若从顶点u开始构造最小生成树，则从集合V中取出顶点u放入集合U中，标记顶点v的visited[u]=1
- 若集合U中顶点ui与集合V-U中的顶点vj之间存在边，则寻找这些边中权值最小的边，但不能构成回路，将顶点vj加入集合U中，将边（ui,vj）加入集合D中，标记visited[vj]=1
- 重复上述步骤，直到U与V相等，即所有顶点都被标记为访问过，此时D中有n-1条边
- 提示: 单独看步骤很难理解，我们通过实例和代码来讲解，比较好理解
4.4代码思路
- 举例来说明，就用下面这张图，起始顶点起始无所谓，因为顶点有 7 个，边数最少为 6 条边，最后得到的 6
条边中，其路径长度都是所有边中路径长度最短的 - 第一步：选取顶点 A ，并标记顶点 A 已被访问，求取最短路径
- A – > B ：路径长度为 5
- A – > C ：路径长度为 7
- A – > G ：路径长度为 2
- 选取最短路径 <A, G> ，其长度为 2
- 标记顶点 G 已被访问过
- 第二步：同样也是求取最短路径
- A – > B ：路径长度为 5
- A – > C ：路径长度为 7
- A – > G ：G 已经被访问过，不考虑
- G – > B ：路径长度为 3
- G – > E ：路径长度为 4
- G – > F ：路径长度为 6
- 选取最短路径 <G, B> ，其长度为 3
- 标记顶点 B 已被访问过
- 第三步：同样也是求取最短路径
- A – > B ：B 已经被访问过，不考虑
- A – > C ：路径长度为 7
- A – > G ：G 已经被访问过，不考虑
- G – > B ：B 已经被访问过，不考虑
- G – > E ：路径长度为 4
- G – > F ：路径长度为 6
- B --> A ：A 已经被访问过，不考虑
- B --> D ：路径长度为 9
- 选取最短路径 <G, E> ，其长度为 4
- 标记顶点 E 已被访问过
- 第 n 步：以此类推
- 什么时候停止？n 个顶点最少需要 n - 1 条边
4.5代码实现
4.5.1图的定义
使用邻接矩阵法，定义一张图
class MGraph {
int verxs; // 表示图的节点个数
char[] data;// 存放结点数据
int[][] weight; // 存放边，就是我们的邻接矩阵
public MGraph(int verxs) {
this.verxs = verxs;
data = new char[verxs];
weight = new int[verxs][verxs];
}
//创建图的邻接矩阵
/**
*
* @param graph 图对象
* @param verxs 图对应的顶点个数
* @param data 图的各个顶点的值
* @param weight 图的邻接矩阵
*/
public void createGraph(MGraph graph, int verxs, char data[], int[][] weight) {
int i, j;
for (i = 0; i < verxs; i++) {// 顶点
graph.data[i] = data[i];
for (j = 0; j < verxs; j++) {
graph.weight[i][j] = weight[i][j];
}
}
}
// 显示图的邻接矩阵
public void showGraph(MGraph graph) {
for (int[] link : graph.weight) {
System.out.println(Arrays.toString(link));
}
}
}
4.5.2普林姆算法
编写普林姆算法
//创建最小生成树->村庄的图
class MinTree {
//编写prim算法，得到最小生成树
/**
*
* @param graph 图
* @param v 表示从图的第几个顶点开始生成，'A'->0 'B'->1...
*/
public void prim(MGraph graph, int v) {
// visited[] 标记结点(顶点)是否被访问过
int visited[] = new int[graph.verxs];
// 把当前这个结点标记为已访问
visited[v] = 1;
// h1 和 h2 记录两个顶点的下标
int h1 = -1;
int h2 = -1;
int minWeight = 10000; // 将 minWeight 初始成一个大数，后面在遍历过程中，会被替换
for (int k = 1; k < graph.verxs; k++) {// 因为有 graph.verxs顶点，普利姆算法结束后，有 graph.verxs-1边
// 这个是确定每一次生成的子图 ，和哪个结点的距离最近
for (int i = 0; i < graph.verxs; i++) {// i结点表示被访问过的结点
for (int j = 0; j < graph.verxs; j++) {// j结点表示还没有访问过的结点
if (visited[i] == 1 && visited[j] == 0 && graph.weight[i][j] < minWeight) {
// 替换minWeight(寻找已经访问过的结点和未访问过的结点间的权值最小的边)
minWeight = graph.weight[i][j];
h1 = i;
h2 = j;
}
}
}
// 找到一条边是最小
System.out.println("边<" + graph.data[h1] + "," + graph.data[h2] + "> 权值:" + minWeight);
// 将当前这个结点标记为已经访问
visited[h2] = 1;
// minWeight 重新设置为最大值 10000
minWeight = 10000;
}
}
}
程序运行结果
[10000, 5, 7, 10000, 10000, 10000, 2]
[5, 10000, 10000, 9, 10000, 10000, 3]
[7, 10000, 10000, 10000, 8, 10000, 10000]
[10000, 9, 10000, 10000, 10000, 4, 10000]
[10000, 10000, 8, 10000, 10000, 5, 4]
[10000, 10000, 10000, 4, 5, 10000, 6]
[2, 3, 10000, 10000, 4, 6, 10000]
边<A,G> 权值:2
边<G,B> 权值:3
边<G,E> 权值:4
边<E,F> 权值:5
边<F,D> 权值:4
边<A,C> 权值:7
5.克鲁斯卡尔算法
5.1应用场景(公交站问题)
看一个应用场景和问题：
- 某城市新增7个站点(A, B, C, D, E, F, G) ，现在需要修路把7个站点连通
- 各个站点的距离用边线表示(权) ，比如 A – B 距离 12公里
- 问：如何修路保证各个站点都能连通，并且总的修建公路总里程最短?
5.2克鲁斯卡尔算法介绍
克鲁斯卡尔(Kruskal)算法，是用来求加权连通图的最小生成树的算法。
基本思想：按照权值从小到大的顺序选择n-1条边，并保证这n-1条边不构成回路
具体做法：首先构造一个只含n个顶点的森林，然后依权值从小到大从连通网中选择边加入到森林中，并使森林中不产生回路，直至森林变成一棵树为止
5.3代码思路
5.3.1最小生成树
- 在含有n个顶点的连通图中选择n-1条边，构成一棵极小连通子图，并使该连通子图中n-1条边上权值之和达到最小，则称其为连通网的最小生成树
- 例如，对于如上图G4所示的连通网可以有多棵权值总和不相同的生成树。
5.3.2克鲁斯卡尔算法图解
- 以上图G4为例，来对克鲁斯卡尔进行演示(假设，用数组R保存最小生成树结果)
- 第1步：将边<E,F>加入R中。 边<E,F>的权值最小，因此将它加入到最小生成树结果R中。
- 第2步：将边<C,D>加入R中。 上一步操作之后，边<C,D>的权值最小，因此将它加入到最小生成树结果R中。
- 第3步：将边<D,E>加入R中。 上一步操作之后，边<D,E>的权值最小，因此将它加入到最小生成树结果R中。
- 第4步：将边<B,F>加入R中。上一步操作之后，边<C,E>的权值最小，但<C,E>会和已有的边构成回路；因此，跳过边<C,E>。同理，跳过边<C,F>。将边<B,F>加入到最小生成树结果R中。
- 第5步：将边<E,G>加入R中。 上一步操作之后，边<E,G>的权值最小，因此将它加入到最小生成树结果R中。
- 第6步：将边<A,B>加入R中。上一步操作之后，边<F,G>的权值最小，但<F,G>会和已有的边构成回路；因此，跳过边<F,G>。同理，跳过边<B,C>。将边<A,B>加入到最小生成树结果R中。
- 此时，最小生成树构造完成！它包括的边依次是：<E,F> <C,D> <D,E> <B,F> <E,G> <A,B>。
总结：
- 将所有边按照权值排序，从小到大依次加入森林中
- 前提条件：森林中不产生回路，因为产生回路，这条路就相当于是多余的，就算它权值再小也没卵用
5.4克鲁斯卡尔算法分析
- 根据前面介绍的克鲁斯卡尔算法的基本思想和做法，我们能够了解到，克鲁斯卡尔算法重点需要解决的以下两个问题：
- 问题一：对图的所有边按照权值大小进行排序？采用排序算法进行排序即可。
- 问题二：将边添加到最小生成树中时，怎么样判断是否形成了回路？处理方式是：
- 记录顶点在"最小生成树"中的终点，顶点的终点是"在最小生成树中与它连通的最大顶点"
- 然后每次需要将一条边添加到最小生存树时，判断该边的两个顶点的终点是否重合，重合的话则会构成回路
想想为什么能这样判断是否形成了回路？下面举例说明
- 在将<E,F> <C,D> <D,E>加入到最小生成树R中之后，这几条边的顶点就都有了终点
- C的终点是F
- D的终点是F
- E的终点是F
- F的终点是F
关于终点的说明：
- 就是将所有顶点按照从小到大的顺序排列好之后；某个顶点的终点就是与它连通的最大顶点。
- 因此，接下来，虽然<C,E>是权值最小的边。但是C和E的终点都是F，即它们的终点相同，因此，将<C,E>加入最小生成树的话，会形成回路。
- 这就是判断回路的方式。也就是说，我们加入的边的两个顶点不能都指向同一个终点，否则将构成回路
- 为啥添加边时，该边的两个顶点的终点重合，他们两就指向同一个构成回路？两个顶点的终点重合，就说明这两个顶点都能寻找到一条路径，跑到终点处，再为这两个顶点添加一条边，就是画蛇添足，只会增加总路径的长度
5.5代码实现
5.5.1边的定义
定义 EdgeData 类，用于表示一条边
//创建一个类EData ，它的对象实例就表示一条边
class EdgeData {
char start; // 边的一个点
char end; // 边的另外一个点
int weight; // 边的权值
// 构造器
public EdgeData(char start, char end, int weight) {
this.start = start;
this.end = end;
this.weight = weight;
}
// 重写toString, 便于输出边信息
@Override
public String toString() {
return "EData [<" + start + ", " + end + ">= " + weight + "]";
}
}
5.5.2克鲁斯卡尔算法
- sortEdges() 方法：按照边的路径长度，对边进行排序
- getPosition() 方法：根据顶点的名称返回其索引值
- getEdges() 方法：根据邻接矩阵返回边的数组（EdgeData[]）
- getEnd() 方法：返回索引为 i 的顶点的终点，具体做法如下：
- ends[i] 拿到索引为 i 的节点的邻接点
- 令 i = ends[i] ，再通过 ends[i] 拿到其邻接点
- 直至 ends[i] == 0 时，说明索引为 i 的节点（注意 i 一直在变化）就是终点
- kruskal() 方法：利用克鲁斯卡尔算法生成最小生成树：
- 首选按照边的路径长度，对边进行排序
- 遍历每条边的顶点，计算两个顶点的终点
- 如果顶点的终点不重合，则记录当前当前边两个顶点共同的终点
- 否则，该路径构成回路，啥也不做
- 再来看看精髓之处，如何记录顶点的终点？ends[endPointOfPoint1] = endPointOfPoint2;
- 就以上面的例子来说明，现在有 7 个顶点，ends 数组长度为 7 ，用于记录顶点的索引
- 第一次遍历时 <E, F>= 2 ，其路径最短 ，记录 E（索引为 4） 的终点为 F （索引为 5 ） ，即 ends[4] = 5
- 第二次遍历时 <C, D>= 3 ，其路径最短 ，记录 C（索引为 2） 的终点为 D（索引为 3 ） ，即 ends[2] = 3
- 第三次遍历时 <D, E>= 3 ，其路径最短 ，记录 D（索引为 3） 的终点为 E（索引为 4 ） ，即 ends[3] = 4
- 其实，这有点链表的意思，我们通过 C 能找到 E
- C --> D ：顶点 C 的索引为 2 ，令 i = 2 ，i = ends[i] = 3 ，即通过顶点 C 找到了顶点 D（索引为 3
） - D --> E ：顶点 D 的索引为 3 ，令 i = 3 ，i = ends[i] = 4 ，即通过顶点 D 找到了顶点 E（索引为 4）
- C --> D ：顶点 C 的索引为 2 ，令 i = 2 ，i = ends[i] = 3 ，即通过顶点 C 找到了顶点 D（索引为 3
- 数组中元素值为零是什么意思？表示该顶点没有邻接点，即孤零零的一个，每个孤立点的终点我们认为就是他自己
class KruskalCase{
private int edgeNum; //边的个数
private char[] vertexs; //顶点数组
private int[][] matrix; //邻接矩阵
//使用 INF 表示两个顶点不能连通
private static final int INF = Integer.MAX_VALUE;
// 构造器
public KruskalCase(char[] vertexs, int[][] matrix) {
// 初始化顶点数和边的个数
int vlen = vertexs.length;
// 初始化顶点, 复制拷贝的方式
this.vertexs = new char[vlen];
for (int i = 0; i < vertexs.length; i++) {
this.vertexs[i] = vertexs[i];
}
// 初始化边, 使用的是复制拷贝的方式
this.matrix = new int[vlen][vlen];
for (int i = 0; i < vlen; i++) {
for (int j = 0; j < vlen; j++) {
this.matrix[i][j] = matrix[i][j];
}
}
// 统计边的条数
for (int i = 0; i < vlen; i++) {
for (int j = i + 1; j < vlen; j++) {
if (this.matrix[i][j] != INF) {
edgeNum++;
}
}
}
}
//打印邻接矩阵
public void print() {
System.out.println("邻接矩阵为: \n");
for (int i = 0; i < vertexs.length; i++) {
for (int j = 0; j < vertexs.length; j++) {
System.out.printf("%12d", matrix[i][j]);
}
System.out.println();// 换行
}
}
/**
* 功能：对边进行排序处理, 冒泡排序
* @param edges 边的集合
*/
private void sortEdges(EdgeData[] edges) {
for (int i = 0; i < edges.length - 1; i++) {
for (int j = 0; j < edges.length - 1 - i; j++) {
if (edges[j].weight > edges[j + 1].weight) {// 交换
EdgeData tmp = edges[j];
edges[j] = edges[j + 1];
edges[j + 1] = tmp;
}
}
}
}
/**
*
* @param ch 顶点的值，比如'A','B'
* @return 返回ch顶点对应的下标，如果找不到，返回-1
*/
private int getPosition(char ch) {
for (int i = 0; i < vertexs.length; i++) {
if (vertexs[i] == ch) {// 找到
return i;
}
}
// 找不到,返回-1
return -1;
}
/**
* 功能: 获取图中边，放到EData[] 数组中，后面我们需要遍历该数组
* 是通过matrix 邻接矩阵来获取
* EData[] 形式 [['A','B', 12], ['B','F',7], .....]
* @return
*/
private EdgeData[] getEdges() {
int index = 0;
EdgeData[] edges = new EdgeData[edgeNum];
for (int i = 0; i < vertexs.length; i++) {
for (int j = i + 1; j < vertexs.length; j++) {
if (matrix[i][j] != INF) {
edges[index++] = new EdgeData(vertexs[i], vertexs[j], matrix[i][j]);
}
}
}
return edges;
}
/**
* 功能: 获取下标为i的顶点的终点, 用于后面判断两个顶点的终点是否相同
* @param ends ： 数组就是记录了各个顶点对应的终点是哪个,ends 数组是在遍历过程中，逐步形成
* @param i : 表示传入的顶点对应的下标
* @return 返回的就是 下标为i的这个顶点对应的终点的下标, 一会回头还有来理解
*/
private int getEnd(int[] ends, int i) { // i = 4 [0,0,0,0,5,0,0,0,0,0,0,0]
while (ends[i] != 0) {
i = ends[i];
}
return i;
}
public void kruskal() {
int index = 0; // 表示最后结果数组的索引
int[] ends = new int[vertexs.length]; // 用于保存"已有最小生成树" 中的每个顶点在最小生成树中的终点
// 创建结果数组, 保存最后的最小生成树
EdgeData[] rets = new EdgeData[edgeNum];
// 获取图中 所有的边的集合 ， 一共有12边
EdgeData[] edges = getEdges();
System.out.println("排序前，图的边的集合=" + Arrays.toString(edges) + " 共" + edges.length); // 12
// 按照边的权值大小进行排序(从小到大)
sortEdges(edges);
System.out.println("排序后，图的边的集合=" + Arrays.toString(edges) + " 共" + edges.length); // 12
// 遍历edges 数组，将边添加到最小生成树中时，判断是准备加入的边否形成了回路，如果没有，就加入 rets, 否则不能加入
for (int i = 0; i < edgeNum; i++) {
// 获取到第i条边的第一个顶点(起点)
int p1 = getPosition(edges[i].start); // p1 = 4
// 获取到第i条边的第2个顶点
int p2 = getPosition(edges[i].end); // p2 = 5
// 获取p1这个顶点在已有最小生成树中的终点
int m = getEnd(ends, p1); // m = 4
// 获取p2这个顶点在已有最小生成树中的终点
int n = getEnd(ends, p2); // n = 5
// 是否构成回路
if (m != n) { // 没有构成回路
ends[m] = n; // 设置m 在"已有最小生成树"中的终点 <E,F> [0,0,0,0,5,0,0,0,0,0,0,0]
rets[index++] = edges[i]; // 有一条边加入到rets数组
}
}
// <E,F> <C,D> <D,E> <B,F> <E,G> <A,B>。
// 统计并打印 "最小生成树", 输出 rets
System.out.println("最小生成树为");
for (int i = 0; i < index; i++) {
System.out.println(rets[i]);
}
}
}
测试代码
//使用 INF 表示两个顶点不能连通
private static final int INF = Integer.MAX_VALUE;
public static void main(String[] args) {
char[] vertexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
//克鲁斯卡尔算法的邻接矩阵
int matrix[][] = {
/*A*//*B*//*C*//*D*//*E*//*F*//*G*/
/*A*/ { 0, 12, INF, INF, INF, 16, 14},
/*B*/ { 12, 0, 10, INF, INF, 7, INF},
/*C*/ { INF, 10, 0, 3, 5, 6, INF},
/*D*/ { INF, INF, 3, 0, 4, INF, INF},
/*E*/ { INF, INF, 5, 4, 0, 2, 8},
/*F*/ { 16, 7, 6, INF, 2, 0, 9},
/*G*/ { 14, INF, INF, INF, 8, 9, 0}};
//大家可以在去测试其它的邻接矩阵，结果都可以得到最小生成树.
//创建KruskalCase 对象实例
KruskalCase kruskalCase = new KruskalCase(vertexs, matrix);
//输出构建的
kruskalCase.print();
kruskalCase.kruskal();
}
程序运行结果
邻接矩阵为:
0 12 2147483647 2147483647 2147483647 16 14
12 0 10 2147483647 2147483647 7 2147483647
2147483647 10 0 3 5 6 2147483647
2147483647 2147483647 3 0 4 2147483647 2147483647
2147483647 2147483647 5 4 0 2 8
16 7 6 2147483647 2 0 9
14 2147483647 2147483647 2147483647 8 9 0
排序前，图的边的集合=[EData [<A, B>= 12], EData [<A, F>= 16], EData [<A, G>= 14], EData [<B, C>= 10], EData [<B, F>= 7], EData [<C, D>= 3], EData [<C, E>= 5], EData [<C, F>= 6], EData [<D, E>= 4], EData [<E, F>= 2], EData [<E, G>= 8], EData [<F, G>= 9]] 共12
排序后，图的边的集合=[EData [<E, F>= 2], EData [<C, D>= 3], EData [<D, E>= 4], EData [<C, E>= 5], EData [<C, F>= 6], EData [<B, F>= 7], EData [<E, G>= 8], EData [<F, G>= 9], EData [<B, C>= 10], EData [<A, B>= 12], EData [<A, G>= 14], EData [<A, F>= 16]] 共12
最小生成树为
EData [<E, F>= 2]
EData [<C, D>= 3]
EData [<D, E>= 4]
EData [<B, F>= 7]
EData [<E, G>= 8]
EData [<A, B>= 12]
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
