Algorithms 第四版 习题 4.1.16- 4.1.18

原书部分内容见：http://algs4.cs.princeton.edu/home/

4.1.16 计算点的离心率，图的直径，半径，中心

4.1.18 计算图的围长

定义：

点的离心率：图中任意一点v，v的离心率是图中其他点到v的所有最短路径中最大值。

图的直径：图中所有点的离心率的最大值。

图的半径：图中所有点的离心率的最小值。

图的中心：图中离心率长度等于半径的点。

图的围长：如果图中有环，围长则为所有环的长度的最小值。

一般解法：

1. 分别以图中每个点为根进行 广度优先搜索BFS，每次BFS计算并用数组 e[] 保存好每个点的离心率。之后迭代数组即可得知直径，半径，中心。

2. 对于围长，分别以图中每个点为根进行BFS，每次BFS计算并用数组 g [] 保存包含该点的最小环的长度。之后迭代数组即可得知图的围长。

以上两种操作可以在同一迭代中进行。

另外，为方便计算，标记 点 是否访问过时 改用具体的数字- 点到根的距离，即点到根的最短路径 - 代替使用布尔值标记。即定义 int [] marked = new marked [G.V]

为了计算包含某个点的最小环，对于每个层次的BFS，需要知道该层次中各点，例如u，的前驱是哪个点：如果有边连接v 到 u，如果u不是v的前驱，则说明出现了环，

该环的长度为 marked[v] + marked[u] +1。

因为要对每个点进行BFS，所以时间复杂度为 O(V *(V+E))，V为点数，E为边数。

代码如下：

package com.cupid.algorithm.graph.algorithms4th;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class GraphProperties {
	
	// Rather than using boolean values to indicate whether a vertex was visited,
	// use a Integer array to mark each visited vertex.
	// If marked[v] = -1 , vertex v has not been visited.
	// If v is root of a BFS, marked[v] = 0;
	// Other positive values represent for the shortest path length from source(root) to a particular vertex.
	private int[] marked;
	// Integer array e is used to store eccentricity  of every vertex.
	private int[] e;
	// Integer array g is used to store minimum length of circle(s) involving the root vertex.
	private int[] g;
	// For calculating minimum length of circle(s), Integer array p is used to store predecessor of every vertex. 
	private int[] p;
	private Graph myGraph;
	private int center; 
	
	public GraphProperties(Graph G){
		e = new int[G.V()];
		g = new int[G.V()];
		p = new int[G.V()];
		marked = new int[G.V()];
		this.myGraph = G;
		
		// Calculate the eccentricity and girth for the tree rooted at each vertex
		// to decide diameter, radius, center, and girth of a given graph.
		// It takes O(V*(V+E))
		for(int i=0;i<myGraph.V();i++){
			breathFirstSearch(i,e,g);
		}
	}
	
	public int eccentricity(int v){
		return e[v];
	}
	
	public int girth(){
		int min = Integer.MAX_VALUE;
		for(int i=0;i<g.length;i++){
			if(g[i] < min){
				min = g[i];
			}
		}
		return min;
	}
	
	// The diameter of a graph is the maximum eccentricity
	// of any vertex.
	public int diameter(){
		int max = Integer.MIN_VALUE;
		for(int i=0;i<e.length;i++){
			if(e[i] > max){
				max = e[i];
			}
		}
		return max;
	}
	
	// The radius of a graph is the smallest eccentricity of any vertex. A center is
	// a vertex whose eccentricity is the radius.
	public int radius(){
		int min = Integer.MAX_VALUE;
		for(int i=0;i<e.length;i++){
			if(e[i] < min){
				min = e[i];
				center = i;
			}
		}
		return min;
	}
	
	// Calculate the eccentricity and girth for a given vertex.
	// Definition from Algorithms 4th edition:
	
	// The eccentricity of a vertex v is the the length of the shortest path from that vertex
	// to the farthest vertex from v 
	
	// The girth of a graph is the length of its shortest cycle. If a graph is acyclic, then its
	// girth is infinite.
	private void breathFirstSearch(int v,int[] e,int[] g){
		
		// Initialize int[] marked before a BFS is going to commence.
		for(int i=0;i<myGraph.V();i++){
			marked[i] = -1;
		}
		// A standard BFS begins.
		Queue<Integer> q = new LinkedList<Integer>();
		int eccen = 0;
		int girth = Integer.MAX_VALUE;
		marked[v] = 0;
		q.add(v);
		while(!q.isEmpty()){
			int u = q.poll();
			for(Integer w: myGraph.adj(u)){
				if(marked[w] <0){
					// Each level of BFS should increase shortest path length by 1
					marked[w] = marked[u] +1;
					// Assign a shortest path length to an eccentricity.
					eccen = marked[w];
					// w's parent u was found.
					p[w] = u;
					q.add(w);
				}else{
					// If the marked vertex w is not u's parent,
					// there is a cycle here.
					if(w != p[u]){
						// Decide that whether this cycle's length is greater than
						// the smallest one that has been discovered.
						// If no, this cycle is the smallest one.
						if(girth > marked[w] + marked[u] + 1){
							girth = marked[w] + marked[u] + 1;
						}
					}
				}
			}
		}
		// Store eccentricity and girth for root vertex in every BFS.
		e[v] = eccen;
		g[v] = girth;
	}
	
	
	public int getCenter() {
		return center;
	}

	public static void main(String[] args) {
		File file = new File("d:\\tinyG6.txt");
		try {
			Scanner in = new Scanner(file);
			Graph G = new Graph(in);
			System.out.println(G);
			GraphProperties gps = new GraphProperties(G);
			System.out.println("The diameter is: " + gps.diameter());
			System.out.println("The radius is: " +gps.radius());
			System.out.println("The center is vertex No." + gps.getCenter());
			if(gps.girth() == Integer.MAX_VALUE){
				System.out.println("The girth is infinite since the graph is acyclic.");
			}else{
				System.out.println("The girth is: " + gps.girth());
			}
		}catch(FileNotFoundException e){
			e.printStackTrace();
		}
	}

}

测试数据，以邻接链表表示：

0: 1 
1: 3 2 0 
2: 4 3 1 
3: 5 4 2 1 
4: 2 3 
5: 7 6 3 
6: 8 5 
7: 8 5 
8: 7 6 

PS：关于具体的图的实现（如每个点的邻接链表）可以参考上面的原书网址。