## 1, What is Prim algorithm

The process of finding the minimum spanning tree by prim algorithm adopts the idea of greedy algorithm. For a connected network with N vertices, PRIM algorithm finds an edge with the smallest weight from the connected network every time. This operation is repeated N-1 times. The spanning tree composed of N-1 edges with the smallest weight is the minimum spanning tree.

## 2, Prim implementation ideas

- All vertices in the connected network are divided into two categories (assuming class A (nodes have been accessed) and class B (nodes have not been accessed). first In the initial state, all vertices are in class B;
- Select any vertex and move it from class B to class A; (mark this node as accessed)
- Starting from all vertices of class B, find an edge connecting a vertex in class A with the smallest weight, and move the vertex in class a connected by this edge to class B (double loop, find the smallest edge between access node and non access node)
- Repeat step 3 Step until all vertices in class B move to class A, and N-1 edges can be found. (cycle realization constitutes n-1 times)

If starting from vertex A, the weights from vertex B, C, D to vertex A are 2, 4 and 2 respectively. Therefore, for vertex A, the weights of vertex B and vertex d to A are the smallest. Suppose that the vertex B found first:

Continue to analyze vertices C and D. the weight from vertex C to B is 3 and the weight from vertex A is 4; the weight from vertex d to a is 2 and the weight from vertex B is infinite (if there is no direct path between them, set the weight to infinity). Therefore, the weight from vertex d to a is the smallest:

Finally, only vertex C is left, the weight to A is 4, and the weight to B is as large as that to D, which is 3. Therefore, the connected graph has two minimum spanning trees:

## 3, Prim application example and code implementation

Problem Description: there are 7 villages (A, B, C, D, E, F, G) in Shengli township. Now roads need to be built to connect the 7 villages

* The distance of each village is represented by A sideline (right), for example, A – B is 5km away.

* Ask: how to build roads to ensure that all villages can be connected and the total mileage of roads built is the shortest?

### Realization idea

For example, starting from point A, the steps of PLIM algorithm are as follows:

1. Start processing from the < a > vertex, A-C [7] A-G[2] A-B[5], select the smallest < A, G >, and mark the two points as selected

2. Start with < A, G > and process the vertices a and G and their adjacent vertices that have not been accessed. A-C[7] A-B[5] G-B[3] G-E[4] G-F[6] Select the smallest < A, G, b > and mark as selected

3. < A,G,B > start, process the vertices A,G,B and their adjacent vertices that have not been accessed A-C[7] G-E[4] G- F[6] B-D[9] Select the smallest < A,G,B, E > and mark it as selected. And so on. Finally, you will get:

4. {a, G, B, e} - > F / / the 4th large cycle, Corresponding edge < e, f > weight: 5

5. {a, G, B, e, f} - > D / / the 5th large cycle, corresponding edge < F, d > weight: 4

6. {a, G, B, e, F, D} - > C / / the 6th large cycle, corresponding edge < A, C > weight: 7 = = = > < A, G, B, e, F, D, C >

### code implementation

package c13prim; import java.util.Arrays; public class Prim { //Use a large number to indicate that there is no connection between the two points public static final int N = 100; public static void main(String[] args) { char[] vertexs = new char[]{'A', 'B', 'C', 'D', 'E', 'F', 'G'}; //An array is used to represent the adjacency matrix, and N represents unconnected int[][] weight = new int[][]{ {N, 5, 7, N, N, N, 2}, {5, N, N, 9, N, N, 3}, {7, N, N, N, 8, N, N}, {N, 9, N, N, N, 4, N}, {N, N, 8, N, N, 5, 4}, {N, N, N, 4, 5, N, 6}, {2, 3, N, N, 4, 6, N}}; Graph graph = new Graph(vertexs, weight); System.out.println("Storage information of graph"); graph.showGraph(); System.out.println("Information about the selected connecting edge"); graph.prim(0); } static class Graph{ private char[] vertex; //Represents vertex information private int[][] edges; //Store the adjacency matrix to represent the weight between edges public Graph(char[] vertex,int[][] edges) { this.vertex =vertex; this.edges = edges; } public void showGraph(){ for (int[] edge : edges) { System.out.println(Arrays.toString(edge)); } } //Build Prim algorithm and realize the code according to the idea public void prim( int VertexIndex) { //Mark whether the vertex has been selected. If it is selected, it is 1 and if it is not selected, it is 0 int[] selected = new int[vertex.length]; //Marks the current vertex as selected selected[VertexIndex] = 1; //Subscript of accessed vertex int visitYesIndex = -1; //The subscript of the vertex has not been accessed int visitNoIndex = -1; //Initialize the minimum weight to an unreachable number int minWright = N; int length=vertex.length; //Why start from 1? Because after the prim algorithm, k vertices and k-1 edges can only be generated for (int k = 1; k < length; k++) { //You need to traverse the selected vertices every time. For example, only point A has been selected in the first traverse, A and G in the second, A, G, B in the third, and the fourth for (int i = 0; i < length; i++) { //Each time, you need to traverse the vertices that have not been selected. For example, when i corresponds to A, j corresponds to C, G and B (excluding unreachable vertices) for (int j = 0; j < length; j++) { //If i is selected, j is unselected, and i and j are reachable (with edges) if (selected[i] == 1 && selected[j] == 0 && edges[i][j] < minWright) { //Replace minWeight to find the smallest edge of the weights of the vertices that have been accessed and the vertices that have not been accessed minWright = edges[i][j]; // Replace selected and unselected vertices that match the criteria for each comparison visitYesIndex = i; visitNoIndex = j; } } } //After a loop, the smallest edge is obtained. At this time, the unreachable edge should be set as accessed System.out.println("Select edge <" + vertex[visitYesIndex] + "," +vertex[visitNoIndex] + "> Weight :" + minWright); selected[visitNoIndex] = 1; //minWright resets the maximum value minWright = N; } } } }

### Result display