A degree-constrained minimum spanning tree is a minimum spanning tree (MST) where the maximum vertex degree is limited to a certain constant k. The problem is NP-hard. Below is a Java program that adapts Kruskal's MST algorithms, and implement them, to find degree-constrained MST. Prove the correctness of this algorithm.

Program:

import java.util.*; import java.lang.*; import java.io.*;

public class Graph { // A class to represent a graph edge class Edge implements Comparable { int src, dest, weight;

// Comparator function used for sorting edges based on // their weight public int compareTo(Edge compareEdge) { return this.weight-compareEdge.weight; } };

// A class to represent a subset for union-find class subset { int parent, rank; };

int V, E; // V-> no. of vertices & E->no.of edges Edge edge[]; // collection of all edges

// Creates a graph with V vertices and E edges Graph(int v, int e) { V = v; E = e; edge = new Edge[E]; for (int i=0; i

// A utility function to find set of an element i // (uses path compression technique) int find(subset subsets[], int i) { // find root and make root as parent of i (path compression) if (subsets[i].parent != i) subsets[i].parent = find(subsets, subsets[i].parent);

return subsets[i].parent; }

// A function that does union of two sets of x and y // (uses union by rank) void Union(subset subsets[], int x, int y) { int xroot = find(subsets, x); int yroot = find(subsets, y);

// Attach smaller rank tree under root of high rank tree // (Union by Rank) if (subsets[xroot].rank < subsets[yroot].rank) subsets[xroot].parent = yroot; else if (subsets[xroot].rank > subsets[yroot].rank) subsets[yroot].parent = xroot;

// If ranks are same, then make one as root and increment // its rank by one else { subsets[yroot].parent = xroot; subsets[xroot].rank++; } }

// The main function to construct MST using Kruskal's algorithm void KruskalMST() { Edge result[] = new Edge[V]; // Tnis will store the resultant MST int e = 0; // An index variable, used for result[] int i = 0; // An index variable, used for sorted edges for (i=0; i

// Step 1: Sort all the edges in non-decreasing order of their // weight. If we are not allowed to change the given graph, we // can create a copy of array of edges Arrays.sort(edge);

// Allocate memory for creating V ssubsets subset subsets[] = new subset[V]; for(i=0; i

// Create V subsets with single elements for (int v = 0; v < V; ++v) { subsets[v].parent = v; subsets[v].rank = 0; }

i = 0; // Index used to pick next edge

// Number of edges to be taken is equal to V-1 while (e < V - 1) { // Step 2: Pick the smallest edge. And increment the index // for next iteration Edge next_edge = new Edge(); next_edge = edge[i++];

int x = find(subsets, next_edge.src); int y = find(subsets, next_edge.dest);

// If including this edge does't cause cycle, include it // in result and increment the index of result for next edge if (x != y) { result[e++] = next_edge; Union(subsets, x, y); } // Else discard the next_edge }

// print the contents of result[] to display the built MST System.out.println("Following are the edges in the constructed MST"); for (i = 0; i < e; ++i) System.out.println(result[i].src+" -- "+result[i].dest+" == "+ result[i].weight); }

// Driver Program public static void main (String[] args) {

/* Let us create following weighted graph 10 0--------1 | \ | 6| 5\ |15 | \ | 2--------3 4 */ int V = 4; // Number of vertices in graph int E = 5; // Number of edges in graph Graph graph = new Graph(V, E);

// add edge 0-1 graph.edge[0].src = 0; graph.edge[0].dest = 1; graph.edge[0].weight = 10;

// add edge 0-2 graph.edge[1].src = 0; graph.edge[1].dest = 2; graph.edge[1].weight = 6;

// add edge 0-3 graph.edge[2].src = 0; graph.edge[2].dest = 3; graph.edge[2].weight = 5;

// add edge 1-3 graph.edge[3].src = 1; graph.edge[3].dest = 3; graph.edge[3].weight = 15;

// add edge 2-3 graph.edge[4].src = 2; graph.edge[4].dest = 3; graph.edge[4].weight = 4;

graph.KruskalMST(); } }

output:

Following are the edges in the constructed MST 2 -- 3 == 4 0 -- 3 == 5 0 -- 1 == 10