johnson方法求所有节点对最短路径

发布一个k8s部署视频：https://edu.youkuaiyun.com/course/detail/26967

课程内容：各种k8s部署方式。包括minikube部署，kubeadm部署，kubeasz部署，rancher部署，k3s部署。包括开发测试环境部署k8s，和生产环境部署k8s。

腾讯课堂连接地址https://ke.qq.com/course/478827?taid=4373109931462251&tuin=ba64518

第二个视频发布  https://edu.youkuaiyun.com/course/detail/27109

腾讯课堂连接地址https://ke.qq.com/course/484107?tuin=ba64518

介绍主要的k8s资源的使用配置和命令。包括configmap，pod，service，replicaset，namespace，deployment，daemonset，ingress，pv，pvc，sc，role，rolebinding，clusterrole，clusterrolebinding，secret，serviceaccount，statefulset，job，cronjob，podDisruptionbudget，podSecurityPolicy,networkPolicy,resourceQuota，limitrange，endpoint，event，conponentstatus，node，apiservice，controllerRevision等。

第三个视频发布：https://edu.youkuaiyun.com/course/detail/27574

详细介绍helm命令，学习helm chart语法，编写helm chart。深入分析各项目源码，学习编写helm插件
————————————————------------------------------------------------------------------------------------------------------------------

 

package com.data.struct;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Random;
import java.util.Set;

public class Johnson {
	private Node[][] graphic;
	private Node[][] origonal;
	private Node [][]result;
	private Node s;
	private Set<Node> nextNodes = new HashSet<Node>();
	private Set<Node> addList = new HashSet<Node>();
	private Set<Node> removeList = new HashSet<Node>();

	public Johnson(int v, int e) {
		origonal = new Node[v][v];
		result=new Node[v][v];
		for (int i = 0; i < e; i++) {
			int v1 = new Random().nextInt(v);
			int v2 = new Random().nextInt(v);
			Node node = new Node();
			node.w = new Random().nextInt(v) + 1;
			node.d = Integer.MAX_VALUE - 1000;
			node.start = v1;
			node.end = v2;
			origonal[v1][v2] = node;
		}
		for (int i = 0; i < v; i++) {
			if (origonal[i][i] == null) {
				Node node = new Node();
				node.d = Integer.MAX_VALUE - 1000;
				node.w = 0;
				node.start = i;
				node.end = i;
				origonal[i][i] = node;
			} else {
				origonal[i][i].w = 0;
			}
		}
		graphic = new Node[v + 1][v + 1];
		for (int i = 0; i < origonal.length; i++) {
			for (int j = 0; j < origonal.length; j++) {
				graphic[i][j] = origonal[i][j];
			}
		}
		for (int i = 0; i < v + 1; i++) {
			Node node = new Node();
			node.start = origonal.length;
			node.d = Integer.MAX_VALUE - 1000;
			node.end = i;
			graphic[origonal.length][i] = node;
		}

		s = graphic[0][0];
		s.d = 0;

	}

	public Node[][] johnson() {
		if (!bellmanFord()) {
			System.out.println("matrix contain negtive cycle");
			return null;
		} else {
			printTmp();
			for (int i = 0; i < graphic.length; i++) {
				graphic[i][i].h = graphic[graphic.length - 1][i].d;
			}
			for (int i = 0; i < graphic.length; i++) {
				for (int j = 0; j < graphic.length; j++) {
					if (graphic[i][j] != null) {
						graphic[i][j].w = graphic[i][j].w + graphic[i][i].h
								- graphic[j][j].h;
					}
				}
			}
			for(int i=0;i<origonal.length;i++){
				dijkstra(origonal[i][i]);
				printResult();
				for (int j = 0; j < graphic.length; j++) {
					if (graphic[i][j] != null) {
						graphic[i][j].d = graphic[i][j].d - graphic[i][i].h
								+ graphic[j][j].h;
					}
				}
			}
		}
		return result;
	}

	public Node extractMin() {
		Iterator<Node> it = nextNodes.iterator();
		Node node = null;
		while (it.hasNext()) {
			if (node == null) {
				node = it.next();
			} else {
				Node n = it.next();
				if (n.d < node.d) {
					node = n;
				}
			}
		}
		return node;
	}

	public void dijkstra(Node s) {
		for(int i=0;i<origonal.length;i++){
			for(int j=0;j<origonal.length;j++){
				if(origonal[i][j]!=null){
					origonal[i][j].d=Integer.MAX_VALUE - 1000;
				}
			}
		}
		s.d=0;
		nextNodes.clear();
		for (int i = 0; i < origonal.length; i++) {
			nextNodes.add(origonal[i][i]);
		}
		for (int k = 0; k < origonal.length; k++) {
			if (k != s.start && origonal[s.start][k] != null) {
				relex(s, origonal[k][k]);
			}
		}
		nextNodes.remove(s);
		while (nextNodes.size() > 0) {
			Node node = extractMin();
			for (int k = 0; k < origonal.length; k++) {
				if (k != node.start && origonal[node.start][k] != null) {
					relex(node, origonal[k][k]);
				}
			}
			nextNodes.remove(node);
		}
		for(int i=0;i<origonal.length;i++){
			Node node=new Node();
			node.start=s.start;
			node.end=i;
			node.d=origonal[i][i].d;
			result[s.start][i]=node;
		}
	}

	public void relex(Node u, Node v) {
		if (graphic[v.end][v.end].d > u.d + graphic[u.start][v.start].w) {
			graphic[v.end][v.end].d = u.d + graphic[u.start][v.start].w;
			graphic[v.end][v.end].parent = u;
			addList.add(graphic[v.end][v.end]);
			System.out.println(graphic[v.end][v.end].start + "=>" + u.start
					+ "||" + graphic[v.end][v.end].d);
		}
	}

	public boolean bellmanFord() {
		s = graphic[graphic.length - 1][graphic.length - 1];
		s.d = 0;
		addList.clear();
		nextNodes.clear();
		removeList.clear();
		nextNodes.add(s);
		for (int k = 0; k < graphic.length; k++) {
			if (k != s.start && graphic[s.start][k] != null) {
				relex(s, graphic[k][k]);
			}
		}
		nextNodes.addAll(addList);
		nextNodes.remove(s);
		while (nextNodes.size() > 0) {
			addList.clear();
			removeList.clear();
			Iterator<Node> it = nextNodes.iterator();
			while (it.hasNext()) {
				Node node = it.next();
				for (int k = 0; k < graphic.length; k++) {
					if (k != node.start && graphic[node.start][k] != null) {
						relex(node, graphic[k][k]);
					}
				}
				removeList.add(node);
			}
			nextNodes.removeAll(removeList);
			nextNodes.addAll(addList);

		}

		for (int j = 0; j < graphic.length; j++) {
			for (int k = 0; k < graphic.length; k++) {
				if (j != k) {
					if (graphic[j][k] != null
							&& graphic[k][k].d > graphic[j][j].d
									+ graphic[j][k].w) {
						return false;
					}
				}
			}
		}
		return true;

	}
	public void printResult() {
		System.out.println("result:");
		for (int i = 0; i < result.length; i++) {
			for (int j = 0; j < result.length; j++) {
				if (result[i][j] != null) {
					System.out.print(result[i][j].d + " ");
				} else {
					System.out.print(" " + " ");
				}
			}
			System.out.println();
		}
	}
	public void printTmp() {
		System.out.println("tmp:");
		for (int i = 0; i < graphic.length; i++) {
			for (int j = 0; j < graphic.length; j++) {
				if (graphic[i][j] != null) {
					System.out.print(graphic[i][j].d + " ");
				} else {
					System.out.print(" " + " ");
				}
			}
			System.out.println();
		}
	}

	public void print() {
		System.out.println("origranal:");
		for (int i = 0; i < graphic.length; i++) {
			for (int j = 0; j < graphic.length; j++) {
				if (graphic[i][j] != null) {
					System.out.print(graphic[i][j].w + " ");
				} else {
					System.out.print(" " + " ");
				}
			}
			System.out.println();
		}

		Node[][] l = johnson();
		System.out.println("result:");
		for (int i = 0; i < l.length; i++) {
			for (int j = 0; j < l.length; j++) {
				if (l[i][j] != null) {
					System.out.print(l[i][j].d + " ");
				} else {
					System.out.print(" " + " ");
				}
			}
			System.out.println();
		}

	}

	private class Node {
		private int d;
		private int w;
		private int start;
		private int end;
		private Node parent;
		private int h;
	}

	public static void main(String[] args) {
		Johnson j = new Johnson(5, 20);
		j.print();

	}

}