HDU ACM 1879 继续畅通工程

继续畅通工程

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 10206    Accepted Submission(s): 4451

Problem Description

省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。现得到城镇道路统计表，表中列出了任意两城镇间修建道路的费用，以及该道路是否已经修通的状态。现请你编写程序，计算出全省畅通需要的最低成本。

 

Input

测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( 1< N < 100 )；随后的 N(N-1)/2 行对应村庄间道路的成本及修建状态，每行给4个正整数，分别是两个村庄的编号（从1编号到N），此两村庄间道路的成本，以及修建状态：1表示已建，0表示未建。

当N为0时输入结束。

 

Output

每个测试用例的输出占一行，输出全省畅通需要的最低成本。

 

Sample Input

3

1 2 1 0

1 3 2 0

2 3 4 0

3

1 2 1 0

1 3 2 0

2 3 4 1

3

1 2 1 0

1 3 2 1

2 3 4 1

0

 

Sample Output

3

1

0

 

Author

ZJU

 

Source

浙大计算机研究生复试上机考试-2008年

 

 #include <cstdio>
 #include <queue>
 #include <cstring>

 using namespace std;

 const int NV = ;
 const int NE = ;
 const int INF = <<;
 int ne, nv, term, tot;
 bool vis[NV];
 int dist[NV];
 struct Edge{
     int v, cost, next;
     Edge(){}
     Edge(int a, int c){v = a, cost = c;}
     Edge(int a, int c, int d){v = a, cost = c, next = d;}
     bool operator < (const Edge& x) const
     {
         return cost > x.cost;
     }
 }edge[NE];
 int eh[NV];

 int prim(int s = )
 {
     for(int i = ; i <= nv; ++i) dist[i] = i == s ?  : INF;
     priority_queue<Edge> que;
     que.push(Edge(s, ));
     while(!que.empty())
     {
         Edge tmp = que.top();
         int u = tmp.v;
         int cost = tmp.cost;
         que.pop();
         if(vis[u]) continue;
         vis[u] = true;
         term += dist[u];

         for(int i = eh[u]; i != -; i = edge[i].next)
         {
             int v = edge[i].v;
             if(!vis[v] && dist[v] > edge[i].cost)
             {
                 dist[v] = edge[i].cost;
                 que.push(Edge(v, dist[v]));
             }
         }
     }
     return term;
 }

 void addedge(int u, int v, int cost)
 {
     Edge e = Edge(v, cost, eh[u]);
     edge[tot] = e;
     eh[u] = tot++;
     return;
 }

 int main()
 {
     #ifndef ONLINE_JUDGE
     freopen("input.txt", "r", stdin);
     #endif
     while(scanf("%d", &nv) != EOF && nv)
     {
         memset(eh, -, sizeof(eh));
         memset(vis, false, sizeof(vis));
         term = tot = ;
         int u, v, cost, state;
         for(int i = ; i < nv * (nv - ) / ; ++i)
         {
             scanf("%d%d%d%d", &u, &v, &cost, &state);
             if(state) cost = ;
             addedge(u, v, cost);
             addedge(v, u, cost);
         }
         prim();
         printf("%d\n", term);
     }
     return ;
 }

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define SIZE 102
 #define MAXN 10000

 using namespace std;

 const int INF = <<;
 int nv, ne;
 struct Edge{
     int u, v, cost;
 }edge[MAXN];

 int father[SIZE];

 bool cmp(const struct Edge &a, const struct Edge &b)
 {
     return a.cost < b.cost;
 }

 int find_father(int f)
 {
     return father[f] = f == father[f] ? f : find_father(father[f]);
 }

 int main()
 {
     #ifndef ONLINE_JUDGE
     freopen("input.txt", "r", stdin);
     #endif
     while(scanf("%d", &nv) != EOF && nv)
     {
         int state;
         for(int i=; i<=nv; ++i) father[i] = i;
         ne = nv*(nv-)/;
         for(int i=; i<ne; ++i)
         {
             scanf("%d%d%d%d", &edge[i].u, &edge[i].v, &edge[i].cost, &state);
             if(state)
             {
                 int u = find_father(edge[i].u);
                 int v = find_father(edge[i].v);
                 father[u] = v;
             }
         }
         int term = ;
         sort(edge, edge+ne, cmp);
         for(int i=; i<ne; ++i)
         {

             int u = find_father(edge[i].u);
             int v = find_father(edge[i].v);
             if(u != v)
             {
                 term += edge[i].cost;
                 father[u] = v;
             }
         }
         printf("%d\n", term);
     }
     return ;
 }