Minimum Spanning Tree

 

1. Greedy Algorithms

  Aside from Dynamic Programming, Greedy Algorithm is another kind of optimization maneuver, in which every time we make a locally optimal choice and finally get the global optimum. According to CLRS, a problem exhibits Optimal Substructure if an optimal solution to the problem contains optimal solutions to the sub-problems. A good case in point may be Huffman Coding, which generates optimal prefix code in light of the frequencies of different symbols. Here is my solution to an SJTU ACM Online Judge problem concerning such coding strategy:

 1 import java.util.*;
 2 
 3 class Huffman {
 4     private class Node {
 5         public int freq, sum;
 6         
 7         public Node(int freq,int sum) {
 8             this.freq = freq;
 9             this.sum = sum;
10         }
11     }
12     private int size, len;
13     private Node[] arr;
14     
15     public Huffman() {
16         size = 50000;
17         arr = new Node[size];
18     }
19     public void doubleSpace() {
20         Node[] tmp = arr;
21         arr = new Node[size<<1];
22         for (int i=0;i<size;i++) {
23             arr[i] = tmp[i];
24         }
25         size <<= 1;
26     }
27     public void getLeaf(int f) {
28         if (len==size) {
29             doubleSpace();
30         }
31         arr[len++] = new Node(f,0);
32     }
33     public int freqSum() {
34         // Return the weighted sum of prefix code length
35         PriorityQueue<Node> q = new PriorityQueue<Node>(len,
36                 new Comparator<Node>() {
37                     public int compare(Node a,Node b) {
38                         if (a.freq<b.freq) {
39                             return -1;
40                         } else if (a.freq>b.freq) {
41                             return 1;
42                         } else {
43                             return 0;
44                         }
45                     }
46                 }
47         );
48         for (int i=0;i<len;i++) {
49             q.add(arr[i]);
50         }
51         while (q.size()>1) {
52             Node a = q.poll(), b = q.poll();
53             q.add(new Node(a.freq+b.freq,a.freq+b.freq+a.sum+b.sum));
54         }
55         return q.peek().sum;
56     }
57 }
58 
59 public class Main {
60     public static void main(String[] args) {
61         Huffman tree = new Huffman();
62         Scanner in = new Scanner(System.in);
63         int n=in.nextInt(),tmp;
64         for (int i=0;i<n;i++) {
65             tmp = in.nextInt();
66             tree.getLeaf(tmp);
67         }
68         System.out.println(tree.freqSum());
69         in.close();
70     }
71 }

 

2. Prim's Algorithm

  To find a Minimal Spanning Tree of a given weighted graph, Prim's Algorithm is a greedy strategy in which we always choose an optimal vertex and connect it to the spanning tree. The following code is my solution to the USACO training problem "agrinet":

 1 import java.io.*;
 2 import java.util.*;
 3 
 4 public class agrinet {
 5     public static final int INF = 100001;
 6     public static Scanner input;
 7     public static PrintWriter output;
 8     public static int num;
 9     public static int [][] cost;
10     
11     public static int genMST() {
12         // Prim's Algorithm based on Adjacency Matrix:
13         int val=0, pos=0;
14         boolean vis[] = new boolean [num];
15         int dist[] = new int [num];
16         vis[0] = true;
17         for (int i=1;i<num;i++) {
18             dist[i] = INF;
19         }
20         for (int i=1;i<num;i++) {
21             for (int j=0;j<num;j++) {
22                 // update all the remaining vertices
23                 if (!vis[j] && dist[j]>cost[pos][j])
24                     dist[j] = cost[pos][j];
25             }
26             dist[pos] = INF;
27             for (int j=0;j<num;j++) {
28                 // search for an optimal vertex
29                 if (!vis[j] && dist[j]<dist[pos]) {
30                     pos = j;
31                 }
32             }
33             vis[pos] = true;
34             val += dist[pos];
35         }
36         return val;
37     }
38     public static void main(String[] args) throws IOException {
39         input = new Scanner(new FileReader("agrinet.in"));
40         num = input.nextInt();
41         cost = new int[num][num];
42         for (int i=0;i<num;i++) {
43             for (int j=0;j<num;j++) {
44                 cost[i][j] = input.nextInt();
45             }
46         }
47         input.close();
48         output = new PrintWriter(new FileWriter("agrinet.out"));
49         output.println(genMST());
50         output.close();
51     }
52 }


3. Kruskal's Algorithm

  Kruskal's Algorithm is another greedy method to build a Minimal Spanning Tree, in which every time we add an optimal safe edge to an edge set. Here I provide my solution an SJTU ACM Online Judge  problem as an example:

  1 import java.util.*;
  2 
  3 class DisjointSet {
  4     private int[] root;    // root of each item
  5     private int size;         // number of items
  6     
  7     public DisjointSet(int size) {
  8         if (size<=0) {
  9             throw new RuntimeException("Illegal Initial Size");
 10         } else {
 11             this.size = size;
 12             root = new int[size];
 13             for (int i=0;i<size;i++) {
 14                 root[i] = -1;
 15             }
 16         }
 17     }
 18     public void union(int i,int j) {
 19         // Merge the set of i and the set of j
 20         if (i<0||i>=size||j<0||j>=size) {
 21             throw new RuntimeException("IndexOutOfBounds on union");
 22         } else {
 23             i = find(i);
 24             j = find(j);
 25             if (i!=j) {    
 26                 // BEWARE that i and j may be identical
 27                 if (root[i]<root[j]) {
 28                     root[i] += root[j];
 29                     root[j] = i;
 30                 } else {
 31                     root[j] += root[i];
 32                     root[i] = j;
 33                 }
 34             }
 35         }
 36     }
 37     public int find(int idx)  {
 38         // Determine and return root[idx]
 39         if (idx<0||idx>=size) {
 40             throw new RuntimeException("IndexOutOfBounds on find");
 41         } else {
 42             int prev = root[idx];
 43             if (prev<0) {
 44                 return idx;
 45             } else {
 46                 root[idx] = find(prev);
 47                 return root[idx];
 48             }
 49         }
 50     }
 51 }
 52 
 53 class AdjList {
 54     private class Vert {
 55         public Edge next;
 56     }
 57     private class Edge {
 58         public int end, weight;
 59         public Edge next;
 60         
 61         public Edge(int end,int weight,Edge next) {
 62             this.end = end;
 63             this.weight = weight;
 64             this.next = next;
 65         }
 66     }
 67     private class HeapItem {
 68         public int start, end, weight;
 69         
 70         public HeapItem(int start,int end,int weight) {
 71             this.start = start;
 72             this.end = end;
 73             this.weight = weight;
 74         }
 75     }
 76     
 77     public static final int INF = 100001;
 78     private int num;
 79     private Vert [] vert;
 80     
 81     public AdjList(int num) {
 82         this.num = num;
 83         vert = new Vert[num];
 84         for (int i=0;i<num;i++) {
 85             vert[i] = new Vert();
 86         }
 87     }
 88     public void insert(int i,int j,int w) {
 89         if (i<j) {
 90             vert[i].next = new Edge(j,w,vert[i].next);
 91         } else {
 92             vert[j].next = new Edge(i,w,vert[j].next);
 93         }
 94     }
 95     public int genMST() {
 96         // Kruskal's Algorithm based on Adjacency List:
 97         DisjointSet set = new DisjointSet(num);
 98         PriorityQueue<HeapItem> q = new PriorityQueue<HeapItem>(INF,
 99                 new Comparator<HeapItem>() {
100                     public int compare(HeapItem a,HeapItem b) {
101                         if (a.weight<b.weight) {
102                             return -1;
103                         } else if (a.weight>b.weight) {
104                             return 1;
105                         } else {
106                             return 0;
107                         }
108                     }
109                 }
110         );
111         for (int i=0;i<num;i++) {
112             Edge itr = vert[i].next;
113             while (itr!=null) {
114                 q.add(new HeapItem(i,itr.end,itr.weight));
115                 itr = itr.next;
116             }
117         }
118         int cnt=0, val=0;
119         while (cnt<num-1) {
120             HeapItem e = q.poll();
121             if (set.find(e.start)!=set.find(e.end)) {
122                 set.union(e.start,e.end);
123                 val += e.weight;
124                 cnt++;
125             }
126         }
127         return val;
128     }
129 }
130 
131 public class Main {
132     public static void main(String[] args) {
133         Scanner in = new Scanner(System.in);
134         int v = in.nextInt();
135         int e = in.nextInt();
136         AdjList g = new AdjList(v);
137         for (int i=0;i<e;i++) {
138             int j = in.nextInt()-1;
139             int k = in.nextInt()-1;
140             int w = in.nextInt();
141             g.insert(j,k,w);
142         }
143         in.close();
144         System.out.println(g.genMST());
145     }
146 }


 

References:

    1. Cormen, T. H. et al. Introduction to Algorithms [M] .  北京:机械工业出版社, 2006-09

 

posted on 2015-04-04 00:07  DevinZ  阅读(163)  评论(0编辑  收藏  举报

导航