hdoj1879 继续畅通工程（Prime || Kruskal）

题目链接

http://acm.hdu.edu.cn/showproblem.php?pid=1879

思路

这题和hdoj1102很像，图中的有一些路已经修好了，对于这些已经修好的路，我们令还需要修的长度为0即可，然后进行Prime算法或者Kruskal算法。

代码

Prime算法：

 #include <algorithm>
 #include <cstring>
 #include <cstdio>
 using namespace std;

 const int INF = 0x7fffffff;
 const int N =  + ;
 int map[N][N];
 int dist[N];
 int n;

 void prime()
 {
     int min_edge, min_node;
     for (int i = ; i <= n; i++)
         dist[i] = INF;
     int ans = ;
     int now = ;
     for (int i = ; i < n; i++)
     {
         dist[now] = -;
         min_edge = INF;
         for (int j = ; j <= n; j++)
         {
             if (j != now&& dist[j] >= )
             {
                 if (map[now][j] >= )    //注意是map[now][j]>=0,因为有些路已经修好了，初始化时令其长度为0
                     dist[j] = min(dist[j], map[now][j]);
                 if (dist[j] < min_edge)
                 {
                     min_edge = dist[j];    // //min_edge存储与当前结点相连的最短的边
                     min_node = j;
                 }
             }
         }
         ans += min_edge;    // //ans存储最小生成树的长度
         now = min_node;
     }
     printf("%d\n", ans);
 }

 int main()
 {
     //freopen("hdoj1879.txt", "r", stdin);
     while (scanf("%d", &n) ==  && n)
     {
         memset(map, , sizeof(map));
         int a, b, d, s;
         for (int i = ; i < n*(n - ) / ; i++)
         {
             scanf("%d%d%d%d", &a, &b, &d, &s);
             if (s == )
                 map[a][b] = map[b][a] = d;
             else if (s == ) map[a][b] = map[b][a] = ;
         }
         prime();
     }
     return ;
 }

Kruskal算法：

 #include <algorithm>
 #include <cstring>
 #include <cstdio>
 #include <vector>
 using namespace std;

 struct Edge
 {
     int a, b, dist;

     Edge() {}
     Edge(int a, int b, int d) :a(a), b(b), dist(d) {}
     bool operator < (Edge edge)
     {
         return dist < edge.dist;
     }
 };

 const int N =  + ;
 vector<Edge> v;
 int p[N];
 int n;

 int find_root(int x)
 {
     if (p[x] == -)
         return x;
     else return find_root(p[x]);
 }

 void kruskal()
 {
     memset(p, -, sizeof(p));
     sort(v.begin(), v.end());     //将边按边长从短到长排序
     int ans = ;
     for (int i = ; i < v.size(); i++)
     {
         int ra = find_root(v[i].a);
         int rb = find_root(v[i].b);
         if (ra != rb)
         {
             ans += v[i].dist;
             p[ra] = rb;
         }
     }
     printf("%d\n", ans);
 }

 int main()
 {
     //freopen("hdoj1879.txt", "r", stdin);
     while (scanf("%d", &n) ==  && n)
     {
         v.clear();
         int m = n*(n - ) / ;
         int a, b, d, s;
         for (int i = ; i < m; i++)
         {
             scanf("%d%d%d%d", &a, &b, &d, &s);
             if (s == )
                 v.push_back(Edge(a, b, d));
             else if (s == ) v.push_back(Edge(a, b, ));
         }
         kruskal();
     }
     return ;
 }