学习笔记之 prim算法和kruskal算法

~. 最近数据结构课讲到了prim算法，然而一直使用kruskal算法的我还不知prim的思想，实在是寝食难安，于此灯火通明之时写此随笔，以祭奠我睡过去的数

据结构课。

一，最小生成树之prim

　　prim的思路就是先任取一点（记为st）加入集合（数组s[]) ，然后在顶点集(数组v[]) 中 未被取的点集中（v - s) 选取一点记为en， 要求是：边 a[st][en]

是 a[i][j] (i 属于 s， j 属于 v-s） 中最小的，然后不断重复此过程（从v-s中选点加入s),直到 v-s 中只剩一个点。

　　关键点在于找a[i][j]中最小的。ok，来一个数组暂存（记为mi[])，比如说最开始 s[] 中只有一个点 1， 那么 mi[] 保存的就是 a[1][1],a[1][2]...a[1][n] ;

(等下再说a[][]赋值的细节)，然后选取了一个点，假如是2吧！那就把2这个点标记一下（就是表明已经加入了，即：vis[2] = true;），然后更新 mi[]数组，

说明一下，mi[]保存的是 集合 s 中的点 i 到 v-s中的点 j 的最小距离 （指 mi [ j ] = min(a[i][j]) 其中 i 取遍 s )。这么多废话之后就可以上代码了~_~。

hdu 1102 

 #include <stdio.h>
 #include <stdlib.h>
 #include <iostream>
 #include <algorithm>
 #include <cstring>
 #include <math.h>
 using namespace std;
 const int maxn =  ;
 const int inf =  ;
 int a[maxn][maxn] , mi[maxn] ;
 int N, M ;
 bool vis[maxn] ;

 int prim()
 {
     int ans =  , p , temp_min ;
     vis[] = true ;
     for (int i = ; i < N; i ++) {
         temp_min = inf ;
         for (int j = ; j <= N; j ++) {
             if (!vis[j] && temp_min > mi[j]) {
                 p = j ;
                 temp_min = mi[j] ;
             }
         }
         ans += temp_min ;
         vis[p] = true ;
         for (int k = ; k <= N; k ++) {
             if (!vis[k] && a[p][k] < mi[k]) mi[k] = a[p][k] ;
         }
     }
     return ans;
 }

 void sol()
 {
     for (int i = ; i <= N; i ++) {
         for (int j = ; j <= N; j ++) {
             scanf("%d",&a[i][j]) ;
             if (i == ) mi[j] = a[i][j] ;
         }
     }
     memset(vis,false,sizeof(vis)) ;
     cin >> M ;
     int x, y ;
     for (int i = ; i <= M; i ++) {
         scanf("%d%d",&x,&y) ;
         a[x][y] = a[y][x] =  ;
         if (x == ) mi[y] =  ;
         if (y == ) mi[x] =  ;
     }
     mi[] =  ;
     cout << prim() << endl ;
 }

 int main()
 {
     while (cin >> N) {
         sol() ;
     }
     return ;
 }

二，最小生成树之kruskal

　　kruskal的思路呢就是先把边给排个序，然后选啊选啊，当然是先选小的啦！至于为什么？呵呵哒！此处显露了并查集的~~~~超级~武器。

存储是有一个边集结构体，st (起点）， en （终点） ，di（距离）。排序依据就是 di；如果选择的边的起点重点已经连在一起了，那在他们之间连一条边就是多余的 。

hdu 1102

 #include <iostream>
 #include <cstring>
 #include <algorithm>
 #include <cmath>
 #include <stdio.h>
 using namespace std;
 const int maxn =  ;
 const int inf =  ;

 int s[maxn] ;
 int ans ;
 int f[maxn][maxn] ;
 struct Node
 {
     int st ;
     int en ;
     int di ;
 };

 Node A[] ;
 bool cmp(const Node &T_1,const Node &T_2)
 {
     return T_1.di < T_2.di ;
 }

 int fi(int x)
 {
     int r = x, p = x, q ;
     while (r != s[r]) {
         r = s[r] ;
     }
     while (p != s[p]) {
         q = s[p] ;
         s[p] = r ;
         p = q ;
     }
     return r ;
 }

 void join(int x,int y)
 {
     int fx = fi(x), fy = fi(y) ;
     if (fx != fy) {
         s[fx] = fy ;
     }
 }

 int main()
 {
     int N, M, a, b, d , x;
     while (cin >> N) {
         for (int i = ; i <= N; i++) {
             s[i] = i ;
         }

         for (int i = ; i <= N; i++) {
             for (int j = ; j <= N; j++) {
                 scanf("%d",&x) ;
                 f[i][j] = x ;
             }
         }

         int k =  ;
         for (int i = ; i < N; i++) {
             for (int j = i+; j <= N; j++) {
                 A[k].st = i;
                 A[k].en = j ;
                 A[k].di = f[i][j] ;
                 k ++ ;
             }
         }
         int n = N*(N-)/ ;
         scanf("%d",&M) ;
         for (int i = ; i <= M; i++) {
             scanf("%d %d",&a,&b) ;
             join(a,b) ;
         }
         sort(A,A+n,cmp) ;
         ans = ;
         for (int i = ; i < n; i++) {
             if (fi(A[i].st) != fi(A[i].en)) {
                 ans += A[i].di ;
                 join(A[i].st,A[i].en) ;
             }
         }
         cout << ans << endl;
     }
     return  ;
 }

三，至于上面两种方法的证明以及其他方法以后再写，小弟今晚要早睡了。