Tip: after the article is written, the directory can be generated automatically. Please refer to the help document on the right for how to generate it

# Greedy Algorithm

## Greedy algorithm - Definition:

#### Use the segmentation theorem to find one edge of the minimum spanning tree and repeat until all edges of the minimum spanning tree are found

- Greedy algorithm is the basic algorithm for calculating the minimum spanning tree of a graph. Its basic principle is the segmentation theorem,
- Use the segmentation theorem to find one edge of the minimum spanning tree and repeat until all edges of the minimum spanning tree are found.
- If a graph has V vertices, it needs to find V-1 edges to represent the minimum spanning tree of the graph.

## Greedy algorithm - principle:

## Algorithm of minimum spanning tree

- There are many algorithms for calculating the minimum spanning tree of a graph, but these algorithms can be regarded as a special case of greedy algorithms,
- The difference between these algorithms is the way to save the segmentation and determine the cross cutting edge with the smallest weight.

# Prim algorithm

- We learn the first method to calculate the minimum spanning tree, called Prim algorithm, which adds an edge to a spanning tree at each step. At first, the tree has only one vertex, and then V-1 edges will be added to it. Each time, the next edge with the lowest weight connecting the vertex in the tree and the vertex not in the tree will be added to the tree.

## Segmentation rules:

- The vertices in the minimum spanning tree are regarded as a set, and the vertices not in the minimum spanning tree are regarded as another set.

## Algorithm API design

## Implementation principle of Prim algorithm

Prim algorithm always divides the vertices in the graph into two sets, the minimum spanning tree vertex and the non minimum spanning tree vertex. By constantly repeating some operations, you can gradually add the vertices in the non minimum spanning tree to the minimum spanning tree until all the vertices are added to the minimum spanning tree

- When designing the API, we use the minimum index priority queue to store the effective crosscutting edges of vertices in the tree and non vertices in the tree. How is it represented? We can let the index value of the minimum index priority queue represent the vertices of the graph, and let the value in the minimum index priority queue represent the edge weight from another vertex to the current vertex.

### 1. Initialization status

- In the initialization state, 0 is the only vertex in the minimum spanning tree by default, and other vertices are not in the minimum spanning tree. At this time, the crosscutting edge is the four edges 0-2,0-4,0-6,0-7 in the adjacency table of vertex 0. We only need to store the weight values of these edges at the indexes 2, 4, 6 and 7 of the index priority queue.

### 2. Find the edge with the smallest weight and add it to the tree

Now you just need to find the edge with the least weight from the four crosscutting edges, and then add the corresponding vertices. Therefore, the weight of the crosscutting edge 0-7 is the smallest, so the edge 0-7 is added. At this time, 0 and 7 belong to the vertices of the minimum spanning tree, and the others do not. Now the edges in the adjacent table of vertex 7 also become crosscutting edges,

Two operations are required:

- The 0-7 edge is no longer a crosscutting edge and needs to be invalidated: it can be completed by calling the delMin() method of the minimum index priority queue;
- 2 and 4 vertices each have two connections pointing to the minimum spanning tree, and only one needs to be reserved:

The weight of 4-7 is less than that of 0-4, so keep 4-7 and call change(4,0.37) of the index priority queue,

The weight of 0-2 is less than that of 2-7, so keep 0-2 and no additional operation is required.

### 3. Repeat the above action,

- By repeating the above actions, we can add all vertices to the minimum spanning tree.

## Auxiliary class

#### 1.Edge - edge

package graph.tu; public class Edge implements Comparable<Edge> { private final int v;//Vertex one private final int w;//Vertex two private final double weight;//The weight of the current edge //Construct an edge object from vertices v and w and weight values public Edge(int v, int w, double weight) { this.v = v; this.w = w; this.weight = weight; } //Gets the weight value of the edge public double weight(){ return weight; } //Gets a point on the edge public int either(){ return v; } //Gets another vertex on the edge except vertex vertex public int other(int vertex){ if (vertex==v){ return w; }else{ return v; } } @Override public int compareTo(Edge that) { //Use a traversal record to compare the results int cmp; if (this.weight()>that.weight()){ //If the weight value of the current edge is large, let cmp=1; cmp = 1; }else if (this.weight()<that.weight()){ //If the weight value of the current edge is small, let cmp=-1; cmp=-1; }else{ //If the weight value of the current edge is as large as that edge, let cmp=0 cmp = 0; } return cmp; } }

#### 2.EdgeWeightedGraph - weighted undirected graph

package graph.tu; import java.util.Queue; import java.util.concurrent.ConcurrentLinkedQueue; public class EdgeWeightedGraph { //Total number of vertices private final int V; //Total number of edges private int E; //Adjacency table private Queue<Edge>[] adj; //Create a null weighted undirected graph with V vertices public EdgeWeightedGraph(int v) { //Number of initialization vertices this.V = v; //Number of initialization edges this.E = 0; //Initialize adjacency table this.adj = new ConcurrentLinkedQueue[v]; for (int i = 0; i < adj.length; i++) { adj[i] = new ConcurrentLinkedQueue<Edge>(); } } //Gets the number of vertices in the graph public int V() { return V; } //Gets the number of edges in the graph public int E() { return E; } //Add an edge to the weighted undirected graph e public void addEdge(Edge e) { //You need to make edge e appear in the adjacency table of two vertices of edge e at the same time int v = e.either(); int w = e.other(v); adj[v].offer(e); adj[w].offer(e); //Number of sides + 1 E++; } //Gets all edges associated with the vertex v public Queue<Edge> adj(int v) { return adj[v]; } //Gets all edges of a weighted undirected graph public Queue<Edge> edges() { //Create a queue object to store all the edges Queue<Edge> allEdges = new ConcurrentLinkedQueue<>(); //Traverse each vertex in the graph and find the adjacency table of the vertex, which stores each edge associated with the vertex //Because this is an undirected graph, the same edge appears in the adjacency table of its associated two vertices at the same time. It is necessary to record an edge only once; for(int v =0;v<V;v++){ //Traverse the adjacency table of v vertices and find each edge associated with v for (Edge e : adj(v)) { if (e.other(v)<v){ allEdges.offer(e); } } } return allEdges; } }

#### 3.IndexMinPriorityQueue - minimum priority queue

package graph.tu; public class IndexMinPriorityQueue<T extends Comparable<T>> { //Elements in the storage heap private T[] items; //Save the index of each element in the items array. The pq array needs to be heap ordered private int[] pq; //Save the reverse order of qp, the value of pq as the index and the index of pq as the value private int[] qp; //Record the number of elements in the heap private int N; public IndexMinPriorityQueue(int capacity) { this.items = (T[]) new Comparable[capacity+1]; this.pq = new int[capacity+1]; this.qp= new int[capacity+1]; this.N = 0; //By default, no data is stored in the queue, so that all elements in qp are - 1; for (int i = 0; i < qp.length; i++) { qp[i]=-1; } } //Gets the number of elements in the queue public int size() { return N; } //Determine whether the queue is empty public boolean isEmpty() { return N==0; } //Judge whether the element at index i in the heap is smaller than the element at index j private boolean less(int i, int j) { return items[pq[i]].compareTo(items[pq[j]])<0; } //Swap the values at the i and j indexes in the heap private void exch(int i, int j) { //Exchange data in pq int tmp = pq[i]; pq[i] = pq[j]; pq[j] = tmp; //Update data in qp qp[pq[i]]=i; qp[pq[j]] =j; } //Judge whether the element corresponding to k exists public boolean contains(int k) { return qp[k] !=-1; } //Index associated with the smallest element public int minIndex() { return pq[1]; } //Insert an element into the queue and associate the index i public void insert(int i, T t) { //Judge whether i has been associated. If it has been associated, it will not be inserted if (contains(i)){ return; } //Number of elements + 1 N++; //Store the data in the i location corresponding to the items items[i] = t; //Store i in pq pq[N] = i; //i in pq is recorded by qp qp[i]=N; //Adjust the heap by floating it up swim(N); } //Deletes the smallest element in the queue and returns the index associated with that element public int delMin() { //Gets the index associated with the smallest element int minIndex = pq[1]; //Swap elements at index 1 and maximum index in pq exch(1,N); //Delete the corresponding content in qp qp[pq[N]] = -1; //Delete content at pq maximum index pq[N]=-1; //Delete the corresponding content in items items[minIndex] = null; //Number of elements - 1 N--; //Subsidence adjustment sink(1); return minIndex; } //Delete index i associated elements public void delete(int i) { //Find the index of i in pq int k = qp[i]; //Swap the value at index k and the value at index N in pq exch(k,N); //Delete content in qp qp[pq[N]] = -1; //Delete content in pq pq[N]=-1; //Delete content in items items[k]=null; //Number of elements - 1 N--; //Heap adjustment sink(k); swim(k); } //Change the element associated with index i to t public void changeItem(int i, T t) { //Modify the element at i position in the items array to t items[i] = t; //Find where i appears in pq int k = qp[i]; //Heap adjustment sink(k); swim(k); } //Using the floating-up algorithm, the element at index k can be in a correct position in the heap private void swim(int k) { while(k>1){ if (less(k,k/2)){ exch(k,k/2); } k = k/2; } } //Using the sinking algorithm, the element at index k can be in a correct position in the heap private void sink(int k) { while(2*k<=N){ //Find the smaller value in the child node int min; if (2*k+1<=N){ if (less(2*k,2*k+1)){ min = 2*k; }else{ min = 2*k+1; } }else{ min = 2*k; } //Compare the current node with the smaller value if (less(k,min)){ break; } exch(k,min); k = min; } } }

## Prim algorithm - PrimMST

package graph.tu; import java.util.Queue; import java.util.concurrent.ConcurrentLinkedQueue; public class PrimMST { //The index represents the vertex, and the value represents the shortest edge between the current vertex and the minimum spanning tree private Edge[] edgeTo; //The index represents the vertex, and the value represents the weight of the shortest edge between the current vertex and the minimum spanning tree private double[] distTo; //The index represents the vertex. If the current vertex is already in the tree, the value is true; otherwise, it is false private boolean[] marked; //Stores valid crosscutting edges between vertices in the tree and non vertices in the tree private IndexMinPriorityQueue<Double> pq; //According to a weighted undirected graph, the minimum spanning tree calculation object is created public PrimMST(EdgeWeightedGraph G) { //Initialize edgeTo this.edgeTo = new Edge[G.V()]; //Initialize distTo this.distTo = new double[G.V()]; for (int i = 0; i < distTo.length; i++) { distTo[i] = Double.POSITIVE_INFINITY; } //Initialize marked this.marked = new boolean[G.V()]; //Initialize pq pq = new IndexMinPriorityQueue<Double>(G.V()); //By default, vertex 0 is allowed to enter the tree, but there is only one vertex 0 in the tree. Therefore, vertex 0 is not connected to other vertices by default, so let the value at the corresponding position of distTo store 0.0 distTo[0] = 0.0; pq.insert(0,0.0); //Traverse the index minimum priority queue, get the vertex corresponding to the minimum and N cutting edges, and add the vertex to the minimum spanning tree while (!pq.isEmpty()){ visit(G,pq.delMin()); } } //Add vertex v to the minimum spanning tree and update the data private void visit(EdgeWeightedGraph G, int v) { //Add vertex v to the minimum spanning tree marked[v] = true; //Update data for (Edge e : G.adj(v)) { //Get another vertex of edge e (current vertex is v) int w = e.other(v); //Judge whether another vertex is already in the tree. If it is in the tree, no processing will be done. If it is no longer in the tree, the data will be updated if (marked[w]){ continue; } //Judge whether the weight of edge e is less than the weight from w vertex to the smallest edge already existing in the tree; if (e.weight()<distTo[w]){ //Update data edgeTo[w] = e; distTo[w] = e.weight(); if (pq.contains(w)){ pq.changeItem(w,e.weight()); }else{ pq.insert(w,e.weight()); } } } } //Gets all edges of the minimum spanning tree public Queue<Edge> edges() { //Create queue object Queue<Edge> allEdges = new ConcurrentLinkedQueue<>(); //Traverse the edgeTo array to get each edge. If it is not null, it will be added to the queue for (int i = 0; i < edgeTo.length; i++) { if (edgeTo[i]!=null){ allEdges.offer(edgeTo[i]); } } return allEdges; } }

## Test class

package graph.tu; import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.Queue; public class PrimMSTTest { public static void main(String[] args) throws Exception{ //Prepare a weighted undirected graph BufferedReader br = new BufferedReader(new InputStreamReader(PrimMSTTest.class.getClassLoader().getResourceAsStream("main/resources/min_create_tree_test.txt"))); int total = Integer.parseInt(br.readLine()); graph.tu.EdgeWeightedGraph G = new graph.tu.EdgeWeightedGraph(total); int edgeNumbers = Integer.parseInt(br.readLine()); for (int e = 1;e<=edgeNumbers;e++){ String line = br.readLine();//4 5 0.35 String[] strs = line.split(" "); int v = Integer.parseInt(strs[0]); int w = Integer.parseInt(strs[1]); double weight = Double.parseDouble(strs[2]); //Building weighted undirected edges Edge edge = new Edge(v, w, weight); G.addEdge(edge); } //Create a PrimMST object and calculate the minimum spanning tree in the weighted undirected graph graph.tu.PrimMST primMST = new graph.tu.PrimMST(G); //Gets all edges in the minimum spanning tree Queue<Edge> edges = primMST.edges(); //Traverse and print all edges for (Edge e : edges) { int v = e.either(); int w = e.other(v); double weight = e.weight(); System.out.println(v+"-"+w+" :: "+weight); } } }

# kruskal Algorithm

## Main ideas:

#### The edges are processed according to their weights (from small to large), and the edges are added to the minimum spanning tree

- kruskal algorithm is another algorithm to calculate the minimum spanning tree of a weighted undirected graph. Its main idea is to deal with them according to the weight of edges (from small to large). The edges are added to the minimum spanning tree. The added edges will not form a ring with the edges that have been added to the minimum spanning tree until the tree contains V-1 edges.

## Differences between kruskal algorithm and prim algorithm:

- Prim algorithm constructs the minimum spanning tree one by one, and adds an edge to a tree at each step.
- kruskal algorithm constructs the minimum spanning tree side by side, but its segmentation rules are different. Every time it looks for the edge, it will connect two trees in a forest. If a weighted undirected graph is composed of V vertices, and each vertex forms an independent tree under initialization, then the V vertices correspond to V trees to form a forest. kruskal algorithm will merge the two trees into one tree every time until there is only one tree left in the whole forest.

## API design

## Implementation principle of kruskal algorithm

- When designing the API, a MinPriorityQueue pq is used to store all edges in the graph. Each time pq.delMin() is used to take out the edge with the smallest weight and obtain the two vertices V and W associated with the edge. uf.connect(v,w) is used to judge whether V and W are connected. If connected, it is proved that the two vertices are in the same tree, so this edge can no longer be added to the minimum spanning tree, Because adding an edge to any two vertices of a tree will form a ring, and the minimum spanning tree cannot have a ring. If it is not connected, the tree where vertex v is located and the tree where vertex W is located will be merged into a tree through uf.connect(v,w), and the edge will be added to the mst queue. In this way, if all edges are processed, Finally, all the edges of the minimum spanning tree are stored in mst.

## Auxiliary class

#### 1.Edge - edge

#### 2.EdgeWeightedGraph - weighted undirected graph

#### 3.UF_Tree_Weighted -- union search set

package graph.tu; public class UF_Tree_Weighted { //Record the node element and the identification of the group in which the element is located private int[] eleAndGroup; //Record and check the number of data groups in the set private int count; //It is used to store the number of nodes saved in the tree corresponding to each root node private int[] sz; //Initialize and query set public UF_Tree_Weighted(int N){ //The number of initialization packets. By default, there are N packets this.count = N; //Initialize eleAndGroup array this.eleAndGroup = new int[N]; //Initialize the element in eleAndGroup and the identifier of its group, make the index of eleAndGroup array as the element of each node of the query set, and make the value at each index (the identifier of the group in which the element is located) the index for (int i = 0; i < eleAndGroup.length; i++) { eleAndGroup[i] = i; } this.sz = new int[N]; //By default, the value at each index in sz is 1 for (int i = 0; i < sz.length; i++) { sz[i] = 1; } } //How many groups are there in the current query set public int count(){ return count; } //Judge and check whether element p and element q in the set are in the same group public boolean connected(int p,int q){ return find(p) == find(q); } //Identifier of the group in which the element p is located public int find(int p){ while(true){ if (p == eleAndGroup[p]){ return p; } p = eleAndGroup[p]; } } //Merge the group of p element and the group of q element public void union(int p,int q){ //Find the root node of the tree corresponding to the group of p and q elements int pRoot = find(p); int qRoot = find(q); //If p and q are already in the same group, there is no need to merge if (pRoot==qRoot){ return; } //To determine whether the tree size corresponding to proot or qroot is large, you need to merge the smaller trees into the larger trees if (sz[pRoot]<sz[qRoot]){ eleAndGroup[pRoot] = qRoot; sz[qRoot]+=sz[pRoot]; }else{ eleAndGroup[qRoot] = pRoot; sz[pRoot]+= sz[qRoot]; } //Number of groups - 1 this.count--; } }

## kruskal algorithm - KruskalMST

- PriorityQueueâ€”java.util

package graph.tu; import java.util.PriorityQueue; import java.util.Queue; import java.util.concurrent.ConcurrentLinkedDeque; public class KruskalMST { //Save all edges of the minimum spanning tree private Queue<Edge> mst; //The index represents the vertex. Use uf.connect(v,w) to judge whether vertex v and vertex W are in the same tree. Use uf.union(v,w) to merge the tree where vertex v and vertex W are located private UF_Tree_Weighted uf; //All edges in the graph are stored, and the edges are sorted by weight using the minimum priority queue private Queue<Edge> pq; //According to a weighted undirected graph, the minimum spanning tree calculation object is created public KruskalMST(EdgeWeightedGraph G) { //Initialize mst this.mst = new ConcurrentLinkedDeque<>(); //Initialize uf this.uf = new UF_Tree_Weighted(G.V()); //Initialize pq this.pq = new PriorityQueue<>(G.E()+1); //Store all the edges in the graph in pq for (Edge e : G.edges()) { pq.offer(e); } //Traverse the pq queue, get the edge with the minimum weight, and process it while(!pq.isEmpty() && mst.size()<G.V()-1){ //Find the edge with the least weight Edge e = pq.poll(); //Find the two vertices of the edge int v = e.either(); int w = e.other(v); //Judge whether the two vertices are already in the same tree. If they are in the same tree, the edge will not be processed. If they are not in the same tree, the two trees to which the two vertices belong will be merged into one tree if (uf.connected(v,w)){ continue; } uf.union(v,w); //Get edge e into mst queue mst.offer(e); } } //Gets all edges of the minimum spanning tree public Queue<Edge> edges() { return mst; } }