Java數據結構與算法 day13 程序員十大常用算法

第十三章 十大常用算法

本章源碼：https://github.com/name365/Java-Data-structure

二分查找算法(非遞歸)

二分查找算法(非遞歸)介紹

前面我們講過了二分查找算法，是使用遞歸的方式，下面我們講解二分查找算法的非遞歸方式
二分查找法只適用於從有序的數列中進行查找(比如數字和字母等)，將數列排序後再進行查找
二分查找法的運行時間爲對數時間O(㏒₂n) ，即查找到需要的目標位置最多隻需要㏒₂n步，假設從[0,99]的隊列(100個數，即n=100)中尋到目標數30，則需要查找步數爲㏒₂100 , 即最多需要查找7次( 2^6 < 100 < 2^7)

• 數組 {1,3, 8, 10, 11, 67, 100}, 編程實現二分查找， 要求使用非遞歸的方式完成.
• 代碼實現如下：

public class BinarySearchNoRecur {

	public static void main(String[] args) {
		int arr[] = {1,3, 8, 10, 11, 67, 100};
		int index = bSart(arr, 100);
		System.out.println("index:" + index);
	}
	
	//二分查找算法
	/**
	  * 
	  * @Description 
	  * @author subei
	  * @date 2020年6月20日下午3:41:33
	  * @param arr 待查找的數組, arr是升序排序
	  * @param target 需要查找的數
	  * @return 返回對應下標,-1表示沒有找到
	 */
	public static int bSart(int[] arr, int target) {
		int left =0;
		int right = arr.length - 1;
		while(left <= right){	//繼續進行查找
			int mid = (left+right)/2;
			if(arr[mid] == target){
				return mid;
			}else if(arr[mid] > target){
				right = mid - 1;	//向左查找
			}else{
				left = mid + 1;	//向右查找
			}
		}
		return -1;	//沒找到
	}
}

分治算法

分治算法介紹
	分治法是一種很重要的算法。字面上的解釋是“分而治之”，就是把一個複雜的問題分成兩個或更多的相同或相似的子問題，再把子問題分成更小的子問題……直到最後子問題可以簡單的直接求解，原問題的解即子問題的解的合併。這個技巧是很多高效算法的基礎，如排序算法(快速排序，歸併排序)，傅立葉變換(快速傅立葉變換)……
分治算法可以求解的一些經典問題:
	二分搜索
	大整數乘法
	棋盤覆蓋
	合併排序
	快速排序
	線性時間選擇
	最接近點對問題
	循環賽日程表
	漢諾塔

• 分治算法的基本步驟
  • 分治法在每一層遞歸上都有三個步驟：
  • 1.分解：將原問題分解爲若干個規模較小，相互獨立，與原問題形式相同的子問題
  • 2.解決：若子問題規模較小而容易被解決則直接解，否則遞歸地解各個子問題
  • 3.合併：將各個子問題的解合併爲原問題的解。

分治(Divide-and-Conquer§)算法設計模式如下：

其中|P|表示問題P的規模；n0爲一閾值，表示當問題P的規模不超過n0時，問題已容易直接解出，不必再繼續分解。

ADHOC§是該分治法中的基本子算法，用於直接解小規模的問題P。

因此，當P的規模不超過n0時直接用算法ADHOC§求解。

算法MERGE(y1,y2,…,yk)是該分治法中的合併子算法，用於將P的子問題P1 ,P2 ,…,Pk的相應的解y1,y2,…,yk合併爲P的解。

• 分治算法最佳實踐——漢諾塔

  漢諾塔的傳說
  
  漢諾塔：漢諾塔（又稱河內塔）問題是源於印度一個古老傳說的益智玩具。大梵天創造世界的時候做了三根金剛石柱子，在一根柱子上從下往上按照大小順序摞着64片黃金圓盤。大梵天命令婆羅門把圓盤從下面開始按大小順序重新擺放在另一根柱子上。並且規定，在小圓盤上不能放大圓盤，在三根柱子之間一次只能移動一個圓盤。
  
  假如每秒鐘一次，共需多長時間呢？移完這些金片需要5845.54億年以上，太陽系的預期壽命據說也就是數百億年。真的過了5845.54億年，地球上的一切生命，連同梵塔、廟宇等，都早已經灰飛煙滅。
  

  漢諾塔遊戲的演示和思路分析:

  1)如果是有一個盤，A->C

  2)如果我們有 n >= 2 情況，我們總是可以看做是兩個盤:

  1.最下邊的盤

  2.上面的盤

  操作步驟：

  1)先把最上面的盤 A->B

  2)把最下邊的盤 A->C

  3)把B塔的所有盤 從 B->C

• 代碼實現如下：

public class Hanoitower {
	public static void main(String[] args) {
		Htower(10,'A','P','Q');
	}
	//漢諾塔算法
	//用分治算法求解
	public static void Htower(int num,char a,char b,char c){
		//如果只有一個盤
		if(num==1){
			System.out.println("第一個盤從" + a + "->" + c);
		}else{
			//如果我們有 n >= 2 情況,可以假設是兩個盤 1.最下邊的一個盤 2.上面的所有盤
			//1.先把最上面的所有盤 A->B,移動過程會使用到 c
			Htower(num-1,a,c,b);
			//2.把最下邊的盤 A->C
			System.out.println("第" + num + "個盤從 " + a + "->" + c);
			//3.把B塔的所有盤 從 B->C,移動過程使用到 a塔  
			Htower(num-1,b,a,c);
		}
	}
}

動態規劃算法

• 揹包問題：有一個揹包，容量爲4磅 ， 現有如下物品

物品	重量	價格
吉他(G)	1	1500
音響(S)	4	3000
電腦(L)	3	2000

1. 要求達到的目標爲裝入的揹包的總價值最大，並且重量不超出
2. 要求裝入的物品不能重複

動態規劃算法介紹

1.動態規劃(Dynamic Programming)算法的核心思想是：
  將大問題劃分爲小問題進行解決，從而一步步獲取最優解的處理算法

2.動態規劃算法與分治算法類似，其基本思想也是
  將待求解問題分解成若干個子問題，先求解子問題，然後從這些子問題的解得到原問題的解。

3.與分治法不同的是，適合於用動態規劃求解的問題，經分解得到子問題往往不是互相獨立的。
  ( 即下一個子階段的求解是建立在上一個子階段的解的基礎上，進行進一步的求解 )

4.動態規劃可以通過填表的方式來逐步推進，得到最優解.

思路分析和圖解
揹包問題主要是指一個給定容量的揹包、若干具有一定價值和重量的物品，如何選擇物品放入揹包使物品的價值最大。
其中又分01揹包和完全揹包(完全揹包指的是：每種物品都有無限件可用)
這裏的問題屬於01揹包，即每個物品最多放一個。而無限揹包可以轉化爲01揹包。

算法的主要思想，利用動態規劃來解決。
    每次遍歷到的第i個物品，根據w[i]和v[i]來確定是否需要將該物品放入揹包中。
    即對於給定的n個物品，設v[i]、w[i]分別爲第i個物品的價值和重量，C爲揹包的容量。
    再令v[i][j]表示在前i個物品中能夠裝入容量爲j的揹包中的最大價值。則我們有下面的結果：
    (1) v[i][0]=v[0][j]=0; //表示 填入表 第一行和第一列是0
    (2) 當w[i]> j 時：v[i][j]=v[i-1][j]   // 當準備加入新增的商品的容量大於 當前揹包的容量時，就直接使用上一個單元格的裝入策略
    (3) 當j>=w[i]時： v[i][j]=max{v[i-1][j], v[i]+v[i-1][j-w[i]]}  
// 當 準備加入的新增的商品的容量小於等於當前揹包的容量,

// 裝入的方式:
	v[i-1][j]： 就是上一個單元格的裝入的最大值
	v[i] : 表示當前商品的價值 
	v[i-1][j-w[i]] ： 裝入i-1商品，到剩餘空間j-w[i]的最大值
	當j>=w[i]時： v[i][j]=max{v[i-1][j], v[i]+v[i-1][j-w[i]]} :    

上述三步公式進行驗證：
驗證1：v[1][1] = 1500
1. i = 1, j = 1 
2. w[i] = w[1] = 1
   w [1] = 1  j = 1   v[i][j]=max{v[i-1][j], v[i]+v[i-1][j-w[i]]} : 
3. v[1][1] = max {v[0][1], v[1] + v[0][1-1]} = max{0, 1500 + 0} = 1500

驗證2：v[3][4] = 2000+1500
1. i = 3；j = 4
2. w[i] = w[3] =3, j = 4
   j = 4 >= w[i] = 3 => 4 >= 3
3. v[3][4] = max {v[2][4], v[3] + v[2][1]} = max{3000, 2000+1500} = 2000+1500  

• 代碼實現如下：

public class PackTest {
	public static void main(String[] args) {
		int[] arr = {1,4,3};	//物品重量
		int[] var = {1500,3000,2000};	//物品的價值
		int m = 4;	//包的容量
		int n = var.length;	//物品的個數
		
		//創建二維數組,表
		//v[i][j] 表示在前i個物品中能夠裝入容量爲j的揹包中的最大價值
		int[][] v = new int[n+1][m+1]; 
		int[][] path = new int[n+1][m+1];	//記錄放入商品的情況
		
		//初始化第一行和第一列,本程序可不做此步
		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++){	//不處理第一行
			for(int j = 1;j < v[0].length;j++){	//不處理第一列
				if(arr[i-1]> j) { // 因爲程序i是從1開始的,因此原來公式中的 arr[i],修改成 arr[i-1]
					v[i][j]=v[i-1][j];
				} else {
					//說明:
					//因爲i是從1開始的,因此公式需要調整成
					//v[i][j]=Math.max(v[i-1][j], var[i-1]+v[i-1][j-w[i-1]]);
					//v[i][j] = Math.max(v[i - 1][j], var[i - 1] + v[i - 1][j - w[i - 1]]);
					if(v[i - 1][j] < var[i - 1] + v[i - 1][j - arr[i - 1]]) {
						v[i][j] = var[i - 1] + v[i - 1][j - arr[i - 1]];
						//把當前的情況記錄到path
						path[i][j] = 1;
					} else {
						v[i][j] = v[i - 1][j];
					}
				}
			}
		}
		
		//輸出
		for(int i = 0;i < v.length;i++){
			for(int j = 0;j < v[i].length;j++){
				System.out.print(v[i][j] + " ");
			}
			System.out.println();
		}
		
		//輸出最後放入的哪些商品
//		for(int i=0;i< path.length;i++){
//			for(int j=0;j< path[i].length;j++){
//				if(path[i][j] == 1){
//					System.out.printf("第%d個商品放入到揹包\n", i);
//				}
//			}
//		}
		
		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 -= arr[i-1]; //arr[i-1]
			}
			i--;
		}
	}
}

KMP算法

• 應用場景——字符串匹配問題

  • 有一個字符串 str1= “數據 數據結構 數據結構與算法 Java數據結構”，和一個子串 str2=“數據結構Java”
  • 現在要判斷 str1 是否含有 str2, 如果存在，就返回第一次出現的位置, 如果沒有，則返回-1

• 暴力匹配算法

  • 如果用暴力匹配的思路，並假設現在str1匹配到 i 位置，子串str2匹配到 j 位置，則有:
  • 如果當前字符匹配成功（即str1[i] == str2[j]），則i++，j++，繼續匹配下一個字符
  • 如果失配（即str1[i]! = str2[j]），令i = i - (j - 1)，j = 0。相當於每次匹配失敗時，i 回溯，j 被置爲0。
  • 用暴力方法解決的話就會有大量的回溯，每次只移動一位，若是不匹配，移動到下一位接着判斷，浪費了大量的時間。(不可行!)
  • 暴力匹配算法實現.

public class ViolenceMatch {
	public static void main(String[] args) {
		String str1 = "數據 數據結構 數據結構與算法 Java數據結構";
		String str2 ="數據結構";
		int index = violenceMatch(str1, str2);
		System.out.println("index=" + index);
	}

	// 暴力匹配算法實現
	public static int violenceMatch(String str1, String str2) {
		char[] s1 = str1.toCharArray();
		char[] s2 = str2.toCharArray();

		int s1Len = s1.length;
		int s2Len = s2.length;

		int i = 0; // i索引指向s1
		int j = 0; // j索引指向s2

		while (i < s1Len && j < s2Len) { // 保證匹配不會越界
			if (s1[i] == s2[j]) { // 匹配成功
				i++;
				j++;
			} else { // 沒有匹配成功
				// 如果配失敗(即str1[i]! = str2[j]),令i = i - (j - 1),j = 0
				i = i - (j - 1);
				j = 0;
			}
		}

		// 判斷是否匹配成功
		if (j == s2Len) {
			return i - j;
		} else {
			return -1;
		}
	}
}

• KMP算法簡介
  • KMP是一個解決模式串在文本串是否出現過，如果出現過，最早出現的位置的經典算法
  • Knuth-Morris-Pratt 字符串查找算法，簡稱爲 “KMP算法”，常用於在一個文本串S內查找一個模式串P 的出現位置，這個算法由Donald Knuth、Vaughan Pratt、James H. Morris三人於1977年聯合發表，故取這3人的姓氏命名此算法.
  • KMP方法算法就利用之前判斷過信息，通過一個next數組，保存模式串中前後最長公共子序列的長度，每次回溯時，通過next數組找到，前面匹配過的位置，省去了大量的計算時間
  • 參考資料：https://www.cnblogs.com/ZuoAndFutureGirl/p/9028287.html
• 字符串匹配問題：：
  • 有一個字符串 str1= “BBC ABCDAB ABCDABCDABDE”，和一個子串 str2=“ABCDABD”
  • 現在要判斷 str1 是否含有 str2, 如果存在，就返回第一次出現的位置, 如果沒有，則返回-1
  • 要求：使用KMP算法完成判斷，不能使用簡單的暴力匹配算法.
• 思路分析

1. 首先，用Str1的第一個字符和Str2的第一個字符去比較，不符合，關鍵詞向後移動一位

2. 重複第一步，還是不符合，再後移

3. 一直重複，直到Str1有一個字符與Str2的第一個字符符合爲止

4. 接着比較字符串和搜索詞的下一個字符，還是符合。

5. 遇到Str1有一個字符與Str2對應的字符不符合。

6. 這時候，想到的是繼續遍歷Str1的下一個字符，重複第1步。

(其實是很不明智的，因爲此時BCD已經比較過了，沒有必要再做重複的工作，一個基本事實是，當空格與D不匹配時，你其實知道前面六個字符是”ABCDAB”。KMP 算法的想法是，設法利用這個已知信息，不要把”搜索位置”移回已經比較過的位置，繼續把它向後移，這樣就提高了效率。)

7.怎麼做到把剛剛重複的步驟省略掉？可以對Str2計算出一張《部分匹配表》，這張表的產生在後面介紹

8. 已知空格與D不匹配時，前面六個字符”ABCDAB”是匹配的。查表可知，最後一個匹配字符B對應的”部分匹配值”爲2，因此按照下面的公式算出向後移動的位數：

• 移動位數 = 已匹配的字符數 - 對應的部分匹配值

• 因爲 6 - 2 等於4，所以將搜索詞向後移動 4 位。

9. 因爲空格與Ｃ不匹配，搜索詞還要繼續往後移。這時，已匹配的字符數爲2（”AB”），對應的”部分匹配值”爲0。所以，移動位數 = 2 - 0，結果爲 2，於是將搜索詞向後移 2 位。

10. 因爲空格與A不匹配，繼續後移一位。

11. 逐位比較，直到發現C與D不匹配。於是，移動位數 = 6 - 2，繼續將搜索詞向後移動 4 位。

12. 逐位比較，直到搜索詞的最後一位，發現完全匹配，於是搜索完成。如果還要繼續搜索（即找出全部匹配），移動位數 = 7 - 0，再將搜索詞向後移動 7 位，這裏就不再重複了。

13. 介紹《部分匹配表》怎麼產生的?

• 先介紹前綴，後綴是什麼

• “部分匹配值”就是”前綴”和”後綴”的最長的共有元素的長度。以”ABCDABD”爲例，
  • ”A”的前綴和後綴都爲空集，共有元素的長度爲0；
  • ”AB”的前綴爲[A]，後綴爲[B]，共有元素的長度爲0；
  • ”ABC”的前綴爲[A, AB]，後綴爲[BC, C]，共有元素的長度0；
  • ”ABCD”的前綴爲[A, AB, ABC]，後綴爲[BCD, CD, D]，共有元素的長度爲0；
  • ”ABCDA”的前綴爲[A, AB, ABC, ABCD]，後綴爲[BCDA, CDA, DA, A]，共有元素爲”A”，長度爲1；
  • ”ABCDAB”的前綴爲[A, AB, ABC, ABCD, ABCDA]，後綴爲[BCDAB, CDAB, DAB, AB, B]，共有元素爲”AB”，長度爲2；
  • ”ABCDABD”的前綴爲[A, AB, ABC, ABCD, ABCDA, ABCDAB]，後綴爲[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的長度爲0。

14. ”部分匹配”的實質是，有時候，字符串頭部和尾部會有重複。比如，”ABCDAB”之中有兩個”AB”，那麼它的”部分匹配值”就是2（”AB”的長度）。搜索詞移動的時候，第一個”AB”向後移動 4 位（字符串長度-部分匹配值），就可以來到第二個”AB”的位置。

• 到此KMP算法思想分析完畢!

• 具體代碼實現：

import java.util.Arrays;

public class KMPTest {
	public static void main(String[] args) {
		String str1 = "BBC ABCDAB ABCDABCDABDE";
		String str2 = "ABCDABD";
//		String str2 = "BBC";
		
		int[] next = KmpT("ABCDABD");
		System.out.println("neat:" + Arrays.toString(next));
		
		int index = kmpSearch(str1,str2,next);
		System.out.println("index:" + index);
	}
	
	//KMP搜索算法
	/**
	  * 
	  * @Description 
	  * @author subei
	  * @date 2020年6月22日下午6:47:04
	  * @param str1 源字符串
	  * @param str2 字串
	  * @param next 部分匹配表,子串所對應的部分匹配表
	  * @return 如果是-1就是沒有匹配到，否則返回第一個匹配的位置
	 */
	public static int kmpSearch(String str1,String str2,int[] next){
		for(int i=0,j=0;i < str1.length();i++){
			//調整j的大小
			while(j > 0 && str1.charAt(i) != str2.charAt(j)){
				j = next[j-1];
			}
			if(str1.charAt(i) == str2.charAt(j)){
				j++;
			}
			if(j == str2.length()){	//找到了！！！
				return i - j + 1;
			}
		}
		return -1;
	}
	
	//獲取一個字符串(子串) 的部分匹配值表
	public static int[] KmpT(String dest){
		//創建一個next數組保存部分匹配值
		int[] next = new int[dest.length()];
		next[0] = 0; //如果字符串是長度爲1 部分匹配值就是0
		for(int i = 1, j = 0; i < dest.length(); i++) {
			//當dest.charAt(i) != dest.charAt(j) ,此時需要從next[j-1]獲取新的j
			//直到被發現有  dest.charAt(i) == dest.charAt(j)成立才退出
			//這是kmp算法的核心點！！！！
			while(j > 0 && dest.charAt(i) != dest.charAt(j)) {
				j = next[j-1];
			}
			//當dest.charAt(i)==dest.charAt(j) 滿足時,部分匹配值就+1 
			if(dest.charAt(i) == dest.charAt(j)) {
				j++;
			}
			next[i] = j;
		}
		return next;
	}	
}

貪心算法

應用場景

假設存在下面需要付費的廣播臺，以及廣播臺信號可以覆蓋的地區。 如何選擇最少的廣播臺，讓所有的地區都可以接收到信號。

廣播臺	覆蓋地區
K1	“北京”, “上海”, “天津”
K2	“廣州”, “北京”, “深圳”
K3	“成都”, “上海”, “杭州”
K4	“上海”, “天津”
K5	“杭州”, “大連”

• 具體介紹：

  • 貪婪算法(貪心算法)是指在對問題進行求解時，在每一步選擇中都採取最好或者最優(即最有利)的選擇，從而希望能夠導致結果是最好或者最優的算法。
  • 貪婪算法所得到的結果不一定是最優的結果(有時候會是最優解)，但是都是相對近似(接近)最優解的結果

• 思路分析：

  • 如何找出覆蓋所有地區的廣播臺的集合呢，使用窮舉法實現,列出每個可能的廣播臺的集合，這被稱爲冪集。假設總的有n個廣播臺，則廣播臺的組合總共有2ⁿ -1 個,假設每秒可以計算10個子集， 如圖:

廣播臺數量n	子集總數2ⁿ	需要的時間
5	32	3.2秒
10	1024	102.4秒
32	4294967296	13.6年
100	1.26*100³º	4x10²³年

• 使用貪婪算法，效率高:
• 目前並沒有算法可以快速計算得到準備的值， 使用貪婪算法，則可以得到非常接近的解，並且效率高。選擇策略上，因爲需要覆蓋全部地區的最小集合:
  • 遍歷所有的廣播電臺, 找到一個覆蓋了最多未覆蓋的地區的電臺(此電臺可能包含一些已覆蓋的地區，但沒有關係）
  • 將這個電臺加入到一個集合中(比如ArrayList), 想辦法把該電臺覆蓋的地區在下次比較時去掉。
  • 重複第1步直到覆蓋了全部的地區

• 代碼實現如下：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;

public class GreadeTest {
	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>();
		allAreas.add("北京");
		allAreas.add("上海");
		allAreas.add("天津");
		allAreas.add("廣州");
		allAreas.add("深圳");
		allAreas.add("成都");
		allAreas.add("杭州");
		allAreas.add("大連");
		// 創建ArrayList,存放選擇的電臺
		ArrayList<String> selects = new ArrayList<String>();
		// 定義一個臨時的集合,在遍歷的過程中,存放遍歷過程中的電臺覆蓋的地區和當前還沒有覆蓋的地區的交集
		HashSet<String> tempSet = new HashSet<String>();
		// 定義給maxKey,保存在一次遍歷過程中,能夠覆蓋最大未覆蓋的地區對應的電臺的key
		// 如果maxKey不爲null,則會加入到 selects
		String maxKey = null;	//保存臨時變量
		while (allAreas.size() != 0) { // 如果allAreas不爲0, 則表示還沒有覆蓋到所有的地區
			// 每進行一次while,需要
			maxKey = null;
			// 遍歷 broadcasts, 取出對應key
			for (String key : broadcasts.keySet()) {
				// 每進行一次for
				tempSet.clear();
				// 當前這個key能夠覆蓋的地區
				HashSet<String> areas = broadcasts.get(key);
				tempSet.addAll(areas);
				// 求出tempSet 和 allAreas 集合的交集, 交集會賦給 tempSet
				tempSet.retainAll(allAreas);
				// 如果當前這個集合包含的未覆蓋地區的數量,比maxKey指向的集合地區還多
				// 就需要重置maxKey
				// tempSet.size() > broadcasts.get(maxKey).size())
				// 體現出貪心算法的特點,每次都選擇最優的
				if (tempSet.size() > 0 && (maxKey == null || tempSet.size() > broadcasts.get(maxKey).size())) {
					maxKey = key;
				}
			}
			// 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]
	}
}

貪心算法注意事項和細節:

• (1)貪婪算法所得到的結果不一定是最優的結果(有時候會是最優解)，但是都是相對近似(接近)最優解的結果
• (2)比如上題的算法選出的是K1, K2, K3, K5，符合覆蓋了全部的地區
• (3)但是我們發現 K2, K3,K4,K5 也可以覆蓋全部地區，如果K2 的使用成本低於K1,那麼我們上題的 K1, K2, K3, K5 雖然是滿足條件，但是並不是最優的.

普利姆算法

先看一個應用場景和問題：

有勝利鄉有7個村莊(A, B, C, D, E, F, G) ，現在需要修路把7個村莊連通
各個村莊的距離用邊線表示(權) ，比如 A – B 距離 5公里
問：如何修路保證各個村莊都能連通，並且總的修建公路總里程最短?
思路: 將10條邊，連接即可，但是總的里程數不是最小.
正確的思路，就是儘可能的選擇少的路線，並且每條路線最小，保證總里程數最少. 

最小生成樹:

修路問題本質就是就是最小生成樹問題， 先介紹一下最小生成樹(Minimum Cost Spanning Tree)，簡稱MST。

給定一個帶權的無向連通圖,如何選取一棵生成樹,使樹上所有邊上權的總和爲最小,這叫最小生成樹 
N個頂點，一定有N-1條邊
包含全部頂點
N-1條邊都在圖中
舉例說明(如圖:)
求最小生成樹的算法主要是普里姆算法和克魯斯卡爾算法

普利姆算法介紹：

• 普利姆(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條邊

  • 提示: 單獨看步驟很難理解，我們通過代碼來講解，比較好理解.

1.從<A>頂點開始處理  ======> <A,G> 2
A-C [7] A-G[2] A-B[5] => 

2. <A,G> 開始 , 將A 和 G 頂點和他們相鄰的還沒有訪問的頂點進行處理 =》<A,G,B>
A-C[7] A-B[5]  G-B[3] G-E[4] G-F[6]

3. <A,G,B> 開始，將A,G,B 頂點 和他們相鄰的還沒有訪問的頂點進行處理=><A,G,B,E>
A-C[7] G-E[4] G-F[6] B-D[9] 
.....
4.{A,G,B,E}->F//第4次大循環 ，  對應 邊<E,F> 權值：5
5.{A,G,B,E,F}->D//第5次大循環 ， 對應 邊<F,D> 權值：4
6. {A,G,B,E,F,D}->C//第6次大循環 ， 對應 邊<A,C> 權值：7 ===> <A,G,B,E,F,D,C>

代碼實現如下：

import java.util.Arrays;

public class PrimAlgorithm {
	public static void main(String[] args) {
		char[] data = new char[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
		int verxs = data.length;
		// 鄰接矩陣的關係使用二維數組表示,10000這個大數,表示兩個點不聯通
		int[][] weight = new int[][] { { 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 }, };

		// 創建MGraph對象
		MGraph graph = new MGraph(verxs);
		// 創建一個MinTree對象
		MinTree minTree = new MinTree();
		minTree.createGraph(graph, verxs, data, weight);
		// 輸出
		minTree.showGraph(graph);
		//測試普利姆算法
		minTree.prim(graph, 0);
	}
}

// 創建最小生成樹->村莊的圖
class MinTree {
	// 創建圖的鄰接矩陣
	/**
	 * 
	 * @Description
	 * @author subei
	 * @date 2020年6月23日下午3:54:19
	 * @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));
		}
	}

	// 編寫prim算法,得到最小生成樹
	/**
	 * 
	 * @Description
	 * @author subei
	 * @date 2020年6月23日下午5:52:27
	 * @param graph 圖
	 * @param v 表示從圖的第幾個頂點開始生成
	 */
	public void prim(MGraph graph, int v) {
		// visited[] 標記結點(頂點)是否被訪問過
		int visited[] = new int[graph.verxs];
		// visited[] 默認元素的值都是0, 表示沒有訪問過
		// for(int i =0; i <graph.verxs; i++) {
		// visited[i] = 0;
		// }
		// 把當前這個結點標記爲已訪問
		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;
		}
	}
}

class MGraph {
	int verxs; // 圖的節點個數
	char[] data; // 存放節點數據
	int[][] weight; // 存放邊

	public MGraph(int verxs) {
		this.verxs = verxs;
		data = new char[verxs];
		weight = new int[verxs][verxs];
	}
}

克魯斯卡爾算法

看一個應用場景和問題：

• 1)某城市新增7個站點(A, B, C, D, E, F, G) ，現在需要修路把7個站點連通
• 2)各個站點的距離用邊線表示(權) ，比如 A – B 距離 12公里
• 3)問：如何修路保證各個站點都能連通，並且總的修建公路總里程最短?

克魯斯卡爾算法介紹

• 1)克魯斯卡爾(Kruskal)算法，是用來求加權連通圖的最小生成樹的算法。
• 2)基本思想：按照權值從小到大的順序選擇n-1條邊，並保證這n-1條邊不構成迴路
• 3)具體做法：首先構造一個只含n個頂點的森林，然後依權值從小到大從連通網中選擇邊加入到森林中，並使森林中不產生迴路，直至森林變成一棵樹爲止。

克魯斯卡爾算法圖解說明

在含有n個頂點的連通圖中選擇n-1條邊，構成一棵極小連通子圖，並使該連通子圖中n-1條邊上權值之和達到最小，則稱其爲連通網的最小生成樹。

• 例如，對於如上圖G4所示的連通網可以有多棵權值總和不相同的生成樹。

• 以上圖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>。

克魯斯卡爾算法分析

根據前面介紹的克魯斯卡爾算法的基本思想和做法，我們能夠了解到，克魯斯卡爾算法重點需要解決的以下兩個問題：

• 問題一 對圖的所有邊按照權值大小進行排序。
• 問題二 將邊添加到最小生成樹中時，怎麼樣判斷是否形成了迴路。

問題一很好解決，採用排序算法進行排序即可。

問題二，處理方式是：記錄頂點在"最小生成樹"中的終點，頂點的終點是"在最小生成樹中與它連通的最大頂點"。然後每次需要將一條邊添加到最小生存樹時，判斷該邊的兩個頂點的終點是否重合，重合的話則會構成迴路。

如何判斷是否構成迴路-舉例說明？

在將<E,F> <C,D> <D,E>加入到最小生成樹R中之後，這幾條邊的頂點就都有了終點：
(01) C的終點是F。 
(02) D的終點是F。 
(03) E的終點是F。 
(04) F的終點是F。

• 關於終點的說明：
  • 1.就是將所有頂點按照從小到大的順序排列好之後；某個頂點的終點就是"與它連通的最大頂點"。
  • 2.因此，接下來，雖然<C,E>是權值最小的邊。但是C和E的終點都是F，即它們的終點相同，因此，將<C,E>加入最小生成樹的話，會形成迴路。這就是判斷迴路的方式。也就是說，我們加入的邊的兩個頂點不能都指向同一個終點，否則將構成迴路。

魯斯卡爾算法的代碼說明

import java.util.Arrays;

public class KruskalCase {

	private int edgeNum; // 邊的個數
	private char[] vertexs; // 頂點數組
	private int[][] matrix; // 鄰接矩陣
	// 使用 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();
	}

	// 構造器
	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("鄰接矩陣:");
		for(int i = 0;i < vertexs.length;i++){
			for(int j = 0;j< vertexs.length;j++){
				System.out.printf("%10d\t",matrix[i][j]);
			}
			System.out.println();
		}
	}
	
	/**
	  * 
	  * @Description 對邊進行排序處理,冒泡排序
	  * @author subei
	  * @param edges 邊的集合
	 */
	private void sortEdges(EData[] 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) {// 交換
					EData tmp = edges[j];
					edges[j] = edges[j + 1];
					edges[j + 1] = tmp;
				}
			}
		}
	}
	
	/**
	  * 
	  * @Description 
	  * @author subei
	  * @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;
	}
	
	/**
	  * 
	  * @Description 獲取圖中邊,放到EData[] 數組中,因爲需要遍歷該數組
	  * 是通過matrix 鄰接矩陣來獲取
	  * EData[] 形式 [['A','B', 12], ['B','F',7], .....]
	  * @author subei
	  * @return 
	 */
	private EData[] getEdges() {
		int index = 0;
		EData[] edges = new EData[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 EData(vertexs[i], vertexs[j], matrix[i][j]);
				}
			}
		}
		return edges;
	}
	
	/**
	  * i = 4 [0,0,0,0,5,0,0,0,0,0,0,0]
	  * @Description 獲取下標爲i的頂點的終點(), 用於判斷兩個頂點的終點是否相同
	  * @author subei
	  * @param ends 數組就是記錄了各個頂點對應的終點是哪個,ends 數組是在遍歷過程中,逐步形成
	  * @param i 表示傳入的頂點對應的下標
	  * @return 返回的就是下標爲i的這個頂點對應的終點的下標
	 */
	private int getEnd(int[] ends, int i) {
		while (ends[i] != 0) {
			i = ends[i];
		}
		return i;
	}

	public void kruskal() {
		int index = 0; //表示最後結果數組的索引
		int[] ends = new int[edgeNum]; //用於保存"已有最小生成樹" 中的每個頂點在最小生成樹中的終點
		//創建結果數組, 保存最後的最小生成樹
		EData[] rets = new EData[edgeNum];
		
		//獲取圖中 所有的邊的集合 ， 一共有12邊
		EData[] edges = getEdges();
		System.out.println("圖的邊的集合:" + Arrays.toString(edges) + " 共"+ edges.length); //12
		
		//按照邊的權值大小進行排序(從小到大)
		sortEdges(edges);
		
		//遍歷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]);
		}	
	}
	
}
//創建一個類EData,它的對象實例就表示一條邊
class EData {
	char start; // 邊的一個點
	char end; // 邊的另外一個點
	int weight; // 邊的權值
	
	// 構造器
	public EData(char start, char end, int weight) {
		super();
		this.start = start;
		this.end = end;
		this.weight = weight;
	}

	// 輸出邊信息
	@Override
	public String toString() {
		return "EData [<" + start + ", " + end + ">= " + weight + "]";
	}
		
}

迪傑斯特拉算法(這個沒怎麼懂！！！)

看一個應用場景和問題：

• 1)戰爭時期，勝利鄉有7個村莊(A, B, C, D, E, F, G) ，現在有六個郵差，從G點出發，需要分別把郵件分別送到 A, B, C , D, E, F 六個村莊
• 2)各個村莊的距離用邊線表示(權) ，比如 A – B 距離 5公里
• 3)問：如何計算出G村莊到 其它各個村莊的最短距離?
• 如果從其它點出發到各個點的最短距離又是多少?

迪傑斯特拉(Dijkstra)算法是典型最短路徑算法，用於計算一個結點到其他結點的最短路徑。 它的主要特點是以起始點爲中心向外層層擴展(廣度優先搜索思想)，直到擴展到終點爲止。

迪傑斯特拉(Dijkstra)算法過程

設置出發頂點爲v，頂點集合V{v1,v2,vi...}，v到V中各頂點的距離構成距離集合Dis，Dis{d1,d2,di...}，Dis集合記錄着v到圖中各頂點的距離(到自身可以看作0，v到vi距離對應爲di)
從Dis中選擇值最小的di並移出Dis集合，同時移出V集合中對應的頂點vi，此時的v到vi即爲最短路徑

更新Dis集合，更新規則爲：比較v到V集合中頂點的距離值，與v通過vi到V集合中頂點的距離值，保留值較小的一個(同時也應該更新頂點的前驅節點爲vi，表明是通過vi到達的)
重複執行兩步驟，直到最短路徑頂點爲目標頂點即可結束

代碼實現如下：

import java.util.Arrays;

public class DijkstraAlgorithm {
	public static void main(String[] args) {
		char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
		
		// 鄰接矩陣
		int[][] matrix = new int[vertex.length][vertex.length];
		final int N = 65535;// 表示不可以連接
		matrix[0] = new int[] { N, 5, 7, N, N, N, 2 };
		matrix[1] = new int[] { 5, N, N, 9, N, N, 3 };
		matrix[2] = new int[] { 7, N, N, N, 8, N, N };
		matrix[3] = new int[] { N, 9, N, N, N, 4, N };
		matrix[4] = new int[] { N, N, 8, N, N, 5, 4 };
		matrix[5] = new int[] { N, N, N, 4, 5, N, 6 };
		matrix[6] = new int[] { 2, 3, N, N, 4, 6, N };
		
		// 創建 Graph對象
		Graph graph = new Graph(vertex, matrix);
		// 測試圖的鄰接矩陣
		graph.showGraph();
		
		//測試迪傑斯特拉算法
		graph.dsj(2);
        graph.showDijkstra();
	}
}

class Graph {
	private char[] vertex; // 頂點數組
	private int[][] matrix; // 鄰接矩陣
	private VisitedVertex vv; // 已經訪問的頂點的集合

	// 構造器
	public Graph(char[] vertex, int[][] matrix) {
		super();
		this.vertex = vertex;
		this.matrix = matrix;
	}

	// 顯示圖
	public void showGraph() {
		for (int[] link : matrix) {
			System.out.println(Arrays.toString(link));
		}
	}

	// 顯示結果
	public void showDijkstra() {
		vv.show();
	}

	/**
	 * @Description 迪傑斯特拉算法實現
	 * @author subei
	 * @param index 表示出發頂點對應的下標
	 */
	public void dsj(int index) {
		vv = new VisitedVertex(vertex.length, index);
		update(index);// 更新index頂點到周圍頂點的距離和前驅頂點
		for (int j = 1; j < vertex.length; j++) {
			index = vv.updateArr();// 選擇並返回新的訪問頂點
			update(index); // 更新index頂點到周圍頂點的距離和前驅頂點
		}
	}

	// 更新index下標頂點到周圍頂點的距離和周圍頂點的前驅頂點
	private void update(int index) {
		int len = 0;
		// 根據遍歷我們的鄰接矩陣的 matrix[index]行
		for (int j = 0; j < matrix[index].length; j++) {
			// len 含義是: 出發頂點到index頂點的距離 + 從index頂點到j頂點的距離的和
			len = vv.getDis(index) + matrix[index][j];
			// 如果j頂點沒有被訪問過,並且 len 小於出發頂點到j頂點的距離,就需要更新
			if (!vv.in(j) && len < vv.getDis(j)) {
				vv.updatePre(j, index); // 更新j頂點的前驅爲index頂點
				vv.updateDis(j, len); // 更新出發頂點到j頂點的距離
			}
		}
	}
}

// 已訪問頂點集合
class VisitedVertex {
	// 記錄各個頂點是否訪問過 1表示訪問過,0未訪問,會動態更新
	public int[] already_arr;
	// 每個下標對應的值爲前一個頂點下標, 會動態更新
	public int[] pre_visited;
	// 記錄出發頂點到其他所有頂點的距離,比如G爲出發頂點,就會記錄G到其它頂點的距離,會動態更新,求的最短距離就會存放到dis
	public int[] dis;

	/**
	 * @param length 表示頂點的個數 
	 * @param index 出發頂點對應的下標, 比如G頂點,下標就是6
	 */
	public VisitedVertex(int length, int index) {
		this.already_arr = new int[length];
		this.pre_visited = new int[length];
		this.dis = new int[length];
		// 初始化 dis數組
		Arrays.fill(dis, 65535);
		this.already_arr[index] = 1; // 設置出發頂點被訪問過
		this.dis[index] = 0;// 設置出發頂點的訪問距離爲0
	}

	/**
	  * 
	  * @Description 判斷index頂點是否被訪問過
	  * @author subei
	  * @param index
	  * @return 如果訪問過,就返回true, 否則訪問false
	 */
	public boolean in(int index) {
		return already_arr[index] == 1;
	}

	//更新出發頂點到index頂點的距離
	public void updateDis(int index, int len) {
		dis[index] = len;
	}

	//更新pre這個頂點的前驅頂點爲index頂點
	public void updatePre(int pre, int index) {
		pre_visited[pre] = index;
	}

	//返回出發頂點到index頂點的距離
	public int getDis(int index) {
		return dis[index];
	}

	//繼續選擇並返回新的訪問頂點,比如這裏的G完後,就是 A點作爲新的訪問頂點(注意不是出發頂點)
	public int updateArr() {
		int min = 65535, index = 0;
		for (int i = 0; i < already_arr.length; i++) {
			if (already_arr[i] == 0 && dis[i] < min) {
				min = dis[i];
				index = i;
			}
		}
		// 更新 index 頂點被訪問過
		already_arr[index] = 1;
		return index;
	}

	// 顯示最後的結果:即將三個數組的情況輸出
	public void show() {
		System.out.println("++++++++++++++++++++++");
		// 輸出already_arr
		for (int i : already_arr) {
			System.out.print(i + " ");
		}
		System.out.println();
		// 輸出pre_visited
		for (int i : pre_visited) {
			System.out.print(i + " ");
		}
		System.out.println();
		// 輸出dis
		for (int i : dis) {
			System.out.print(i + " ");
		}
		System.out.println();
		// 爲了美觀最後的最短距離,處理
		char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
		int count = 0;
		for (int i : dis) {
			if (i != 65535) {
				System.out.print(vertex[count] + "(" + i + ") ");
			} else {
				System.out.println("N ");
			}
			count++;
		}
		System.out.println();
	}
}

弗洛伊德算法

相關簡介：

和Dijkstra算法一樣，弗洛伊德(Floyd)算法也是一種用於尋找給定的加權圖中頂點間最短路徑的算法。該算法名稱以創始人之一、1978年圖靈獎獲得者、斯坦福大學計算機科學系教授羅伯特·弗洛伊德命名
弗洛伊德算法(Floyd)計算圖中各個頂點之間的最短路徑
迪傑斯特拉算法用於計算圖中某一個頂點到其他頂點的最短路徑。

弗洛伊德算法 VS 迪傑斯特拉算法：迪傑斯特拉算法通過選定的被訪問頂點，求出從出發訪問頂點到其他頂點的最短路徑；弗洛伊德算法中每一個頂點都是出發訪問點，所以需要將每一個頂點看做被訪問頂點，求出從每一個頂點到其他頂點的最短路徑。

弗洛伊德(Floyd)算法圖解分析:

• 1)設置頂點vi到頂點vk的最短路徑已知爲Lik，頂點vk到vj的最短路徑已知爲Lkj，頂點vi到vj的路徑爲Lij，則vi到vj的最短路徑爲：min((Lik+Lkj),Lij)，vk的取值爲圖中所有頂點，則可獲得vi到vj的最短路徑
• 2)至於vi到vk的最短路徑Lik或者vk到vj的最短路徑Lkj，是以同樣的方式獲得
• 3)弗洛伊德(Floyd)算法圖解分析-舉例說明:

• 第一輪循環中，以A(下標爲：0)作爲中間頂點，距離表和前驅關係更新爲：

• 分析如下：
  • 1. 以A頂點作爲中間頂點是，B->A->C的距離由N->9，同理C到B；C->A->G的距離由N->12，同理G到C
  • 2. 更換中間頂點，循環執行操作，直到所有頂點都作爲中間頂點更新後，計算結束。

距離表的數據來源：

A A A F G G A 
(A到A的最短路徑是0) (A到B的最短路徑是5) (A到C的最短路徑是7) (A到D的最短路徑是12) (A到E的最短路徑是6) (A到F的最短路徑是8) (A到G的最短路徑是2) 

B B A B G G B 
(B到A的最短路徑是5) (B到B的最短路徑是0) (B到C的最短路徑是12) (B到D的最短路徑是9) (B到E的最短路徑是7) (B到F的最短路徑是9) (B到G的最短路徑是3) 

C A C F C E A 
(C到A的最短路徑是7) (C到B的最短路徑是12) (C到C的最短路徑是0) (C到D的最短路徑是17) (C到E的最短路徑是8) (C到F的最短路徑是13) (C到G的最短路徑是9) 

G D E D F D F 
(D到A的最短路徑是12) (D到B的最短路徑是9) (D到C的最短路徑是17) (D到D的最短路徑是0) (D到E的最短路徑是9) (D到F的最短路徑是4) (D到G的最短路徑是10) 

G G E F E E E 
(E到A的最短路徑是6) (E到B的最短路徑是7) (E到C的最短路徑是8) (E到D的最短路徑是9) (E到E的最短路徑是0) (E到F的最短路徑是5) (E到G的最短路徑是4) 

G G E F F F F 
(F到A的最短路徑是8) (F到B的最短路徑是9) (F到C的最短路徑是13) (F到D的最短路徑是4) (F到E的最短路徑是5) (F到F的最短路徑是0) (F到G的最短路徑是6) 

G G A F G G G 
(G到A的最短路徑是2) (G到B的最短路徑是3) (G到C的最短路徑是9) (G到D的最短路徑是10) (G到E的最短路徑是4) (G到F的最短路徑是6) (G到G的最短路徑是0) 

具體代碼實現：

import java.util.Arrays;

public class FloydAlgorithm {

	public static void main(String[] args) {
		char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
		// 創建鄰接矩陣
		int[][] matrix = new int[vertex.length][vertex.length];
		final int N = 65535;
		matrix[0] = new int[] { 0, 5, 7, N, N, N, 2 };
		matrix[1] = new int[] { 5, 0, N, 9, N, N, 3 };
		matrix[2] = new int[] { 7, N, 0, N, 8, N, N };
		matrix[3] = new int[] { N, 9, N, 0, N, 4, N };
		matrix[4] = new int[] { N, N, 8, N, 0, 5, 4 };
		matrix[5] = new int[] { N, N, N, 4, 5, 0, 6 };
		matrix[6] = new int[] { 2, 3, N, N, 4, 6, 0 };

		// 創建 Graph 對象
		Graph graph = new Graph(vertex, matrix, vertex.length);
		// 調用弗洛伊德算法
		graph.floyd();
		graph.show();
	}
}

// 創建圖
class Graph {
	@SuppressWarnings("unused")
	private char[] vertex; // 存放頂點的數組
	private int[][] dis; // 保存,從各個頂點出發到其它頂點的距離,最後的結果,也是保留在該數組
	private int[][] pre;// 保存到達目標頂點的前驅頂點

	/**
	 * @param vertex 頂點數組
	 * @param matrix 鄰接矩陣
	 * @param length 大小
	 */
	public Graph(char[] vertex, int[][] matrix, int length) {
		super();
		this.vertex = vertex;
		this.dis = matrix;
		this.pre = new int[length][length];
		// 對pre數組初始化,注意存放的是前驅頂點的下標
		for (int i = 0; i < length; i++) {
			Arrays.fill(pre[i], i);
		}
	}

	// 顯示pre數組和dis數組
	public void show() {
		char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
		for (int k = 0; k < dis.length; k++) {
			// 先將pre數組輸出的一行
			for (int i = 0; i < dis.length; i++) {
				System.out.print(vertex[pre[k][i]] + " ");
			}
			System.out.println();
			// 輸出dis數組的一行數據
			for (int i = 0; i < dis.length; i++) {
				System.out.print("(" + vertex[k] + "到" + vertex[i] + "的最短路徑是" + dis[k][i] + ") ");
			}
			System.out.println();
			System.out.println();
		}
	}

	// 弗洛伊德算法
	public void floyd() {
		int len = 0; // 變量保存距離
		// 對中間頂點遍歷, k 就是中間頂點的下標 [A, B, C, D, E, F, G]
		for (int k = 0; k < dis.length; k++) { //
			// 從i頂點開始出發 [A, B, C, D, E, F, G]
			for (int i = 0; i < dis.length; i++) {
				// 到達j頂點 [A, B, C, D, E, F, G]
				for (int j = 0; j < dis.length; j++) {
					len = dis[i][k] + dis[k][j];// => 求出從i 頂點出發,經過 k中間頂點,到達 j
												// 頂點距離
					if (len < dis[i][j]) {// 如果len小於 dis[i][j]
						dis[i][j] = len;// 更新距離
						pre[i][j] = pre[k][j];// 更新前驅頂點
					}
				}
			}
		}
	}
}

回溯算法

算法簡介：

• 1)馬踏棋盤算法也被稱爲騎士周遊問題
• 2)將馬隨機放在國際象棋的8×8棋盤Board[0～7][0～7]的某個方格中，馬按走棋規則(馬走日字)進行移動。要求每個方格只進入一次，走遍棋盤上全部64個方格
• 3)遊戲演示: http://www.4399.com/flash/146267_2.htm

• 1)馬踏棋盤問題(騎士周遊問題)實際上是圖的深度優先搜索(DFS)的應用。
• 2)如果使用回溯（就是深度優先搜索）來解決，假如馬兒踏了53個點，如圖：走到了第53個，座標（1,0），發現已經走到盡頭，沒辦法，那就只能回退了，查看其他的路徑，就在棋盤上不停的回溯…… ，思路分析+代碼實現
• 3)分析第一種方式的問題，並使用貪心算法（greedyalgorithm）進行優化。解決馬踏棋盤問題.
• 4)使用前面的遊戲來驗證算法是否正確。

騎士周遊問題的解決步驟和思路:

1.  創建棋盤 chessBoard , 是一個二維數組
2.  將當前位置設置爲已經訪問，然後根據當前位置，計算馬兒還能走哪些位置，並放入到一個集合中(ArrayList), 最多有8個位置， 每走一步，就使用step+1
3. 遍歷ArrayList中存放的所有位置，看看哪個可以走通 , 如果走通，就繼續，走不通，就回溯.
4.  判斷馬兒是否完成了任務，使用   step 和應該走的步數比較 ， 如果沒有達到數量，則表示沒有完成任務，將整個棋盤置0


注意：馬兒不同的走法（策略），會得到不同的結果，效率也會有影響(優化)

//創建一個Point
Point p1 = new Point();
if((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y -1) >= 0) {
ps.add(new Point(p1));
}

使用貪心算法對原來的算法優化
1。 我們獲取當前位置，可以走的下一個位置的集合
//獲取當前位置可以走的下一個位置的集合 
ArrayList<Point> ps = next(new Point(column, row));
2. 我們需要對 ps 中所有的Point 的下一步的所有集合的數目，進行非遞減排序,就ok ,  
9， 7， 6， 5， 3， 2 ， 1 //遞減排序
1, 2, 3, 4,5,6, 10, //遞增排序

1, 2, 2, 2, 3,3, 4, 5, 6 // 非遞減
9， 7， 6，6, 6, 5，5,  3， 2 ， 1     //非遞增

代碼實現如下：

import java.awt.Point;
import java.util.ArrayList;
import java.util.Comparator;

public class HorseChessboard {
	private static int X; // 棋盤的列數
	private static int Y; // 棋盤的行數
	//創建一個數組,標記棋盤的各個位置是否被訪問過
	private static boolean visited[];
	//使用一個屬性,標記是否棋盤的所有位置都被訪問
	private static boolean finished; // 如果爲true,表示成功
	
	public static void main(String[] args) {
		System.out.println("騎士周遊算法:");
		X = 8;
		Y = 8;
		int row = 1; //馬兒初始位置的行,從1開始編號
		int column = 1; //馬兒初始位置的列,從1開始編號
		//創建棋盤
		int[][] chessboard = new int[X][Y];
		visited = new boolean[X * Y];//初始值爲false
		//測試耗時
		long start = System.currentTimeMillis();
		traversalChessboard(chessboard, row - 1, column - 1, 1);
		long end = System.currentTimeMillis();
		System.out.println("共耗時: " + (end - start) + " 毫秒");
		
		//輸出棋盤
		for(int[] rows : chessboard) {
			for(int step: rows) {
				System.out.print(step + "\t");
			}
			System.out.println();
		}
	}
	
	/**
	  * @Description 騎士周遊問題的算法
	  * @author subei
	  * @date 2020年6月27日上午10:58:06
	  * @param chessboard 棋盤
	  * @param row 馬兒當前的位置的行 從0開始 
	  * @param column 馬兒當前的位置的列  從0開始
	  * @param step 是第幾步,初始位置就是第1步 
	 */
	public static void traversalChessboard(int[][] chessboard, int row, int column, int step) {
		chessboard[row][column] = step;
		//row = 4 X = 8 column = 4 = 4 * 8 + 4 = 36
		visited[row * X + column] = true; //標記該位置已經訪問
		//獲取當前位置可以走的下一個位置的集合 
		ArrayList<Point> ps = next(new Point(column, row));
		//對ps進行排序,排序的規則就是對ps的所有的Point對象的下一步的位置的數目,進行非遞減排序
		sort(ps);
		//遍歷 ps
		while(!ps.isEmpty()) {
			Point p = ps.remove(0);//取出下一個可以走的位置
			//判斷該點是否已經訪問過
			if(!visited[p.y * X + p.x]) {//說明還沒有訪問過
				traversalChessboard(chessboard, p.y, p.x, step + 1);
			}
		}
		//判斷馬兒是否完成了任務，使用   step 和應該走的步數比較 
		//如果沒有達到數量，則表示沒有完成任務，將整個棋盤置0
		//說明: step < X * Y  成立的情況有兩種
		//1. 棋盤到目前位置,仍然沒有走完
		//2. 棋盤處於一個回溯過程
		if(step < X * Y && !finished ) {
			chessboard[row][column] = 0;
			visited[row * X + column] = false;
		} else {
			finished = true;
		}
	}
	
	//根據當前位置(Point對象),計算馬兒還能走哪些位置(Point),並放入到一個集合中(ArrayList),最多有8個位置
	public static ArrayList<Point> next(Point curPoint) {
		//創建一個ArrayList
		ArrayList<Point> ps = new ArrayList<Point>();
		//創建一個Point
		Point p1 = new Point();
		//表示馬兒可以走5這個位置
		if((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y -1) >= 0) {
			ps.add(new Point(p1));
		}
		//判斷馬兒可以走6這個位置
		if((p1.x = curPoint.x - 1) >=0 && (p1.y=curPoint.y-2)>=0) {
			ps.add(new Point(p1));
		}
		//判斷馬兒可以走7這個位置
		if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y - 2) >= 0) {
			ps.add(new Point(p1));
		}
		//判斷馬兒可以走0這個位置
		if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y - 1) >= 0) {
			ps.add(new Point(p1));
		}
		//判斷馬兒可以走1這個位置
		if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y + 1) < Y) {
			ps.add(new Point(p1));
		}
		//判斷馬兒可以走2這個位置
		if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y + 2) < Y) {
			ps.add(new Point(p1));
		}
		//判斷馬兒可以走3這個位置
		if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y + 2) < Y) {
			ps.add(new Point(p1));
		}
		//判斷馬兒可以走4這個位置
		if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y + 1) < Y) {
			ps.add(new Point(p1));
		}
		return ps;
	}

	//根據當前這個一步的所有的下一步的選擇位置,進行非遞減排序,減少回溯的次數
	public static void sort(ArrayList<Point> ps) {
		ps.sort(new Comparator<Point>() {

			@Override
			public int compare(Point o1, Point o2) {
				//獲取到o1的下一步的所有位置個數
				int count1 = next(o1).size();
				//獲取到o2的下一步的所有位置個數
				int count2 = next(o2).size();
				if(count1 < count2) {
					return -1;
				} else if (count1 == count2) {
					return 0;
				} else {
					return 1;
				}
			}
		});
	}
}

全劇終！！！