CCF 最优灌溉

Bertha 。 2021-09-14 03:16 222阅读 0赞

## **一、试题** ##

问题描述  
　　雷雷承包了很多片麦田，为了灌溉这些麦田，雷雷在第一个麦田挖了一口很深的水井，所有的麦田都从这口井来引水灌溉。  
　　为了灌溉，雷雷需要建立一些水渠，以连接水井和麦田，雷雷也可以利用部分麦田作为“中转站”，利用水渠连接不同的麦田，这样只要一片麦田能被灌溉，则与其连接的麦田也能被灌溉。  
　　现在雷雷知道哪些麦田之间可以建设水渠和建设每个水渠所需要的费用（注意不是所有麦田之间都可以建立水渠）。请问灌溉所有麦田最少需要多少费用来修建水渠。  
输入格式  
　　输入的第一行包含两个正整数n, m，分别表示麦田的片数和雷雷可以建立的水渠的数量。麦田使用1, 2, 3, ……依次标号。  
　　接下来m行，每行包含三个整数ai, bi, ci，表示第ai片麦田与第bi片麦田之间可以建立一条水渠，所需要的费用为ci。  
输出格式  
　　输出一行，包含一个整数，表示灌溉所有麦田所需要的最小费用。  
样例输入  
4 4  
1 2 1  
2 3 4  
2 4 2  
3 4 3  
样例输出  
6  
样例说明  
　　建立以下三条水渠：麦田1与麦田2、麦田2与麦田4、麦田4与麦田3。  
评测用例规模与约定  
　　前20%的评测用例满足：n≤5。  
　　前40%的评测用例满足：n≤20。  
　　前60%的评测用例满足：n≤100。  
　　所有评测用例都满足：1≤n≤1000，1≤m≤100,000，1≤ci≤10,000。

## **二、代码** ##

最小生成树问题，[Kruskal和Prime算法][Kruskal_Prime]都可。借用了使用vector的链接表，如果不这样，而是将所有路径最初都置为无穷大，在遍历方面方便多了。

#include<iostream>
    #include<vector>
    #include<utility>
    #include<string.h>
    
    using namespace std;
    
    #define NMAX 10050
    #define INF 0x3f3f3f3f
    
    int mincost[NMAX];
    vector<pair<int,int> > G[NMAX];
    bool visit[NMAX];
    int n,m,total;
    
    // 更新以u为起点的路径代价。
    void update(int u){
        int len = G[u].size();
        for(int i=0; i<len; i++){
            pair<int,int> line = G[u][i];
            if(!visit[line.first] && mincost[line.first]>line.second){
                mincost[line.first] = line.second;
            }
        }
    }
    
    void prime(int u)
    {
    
        visit[u]=1;
        // 所有代价初始化为最大值
        memset(mincost, INF, sizeof(mincost));
    
        // 在1节点处将一些代价更新。
        update(1);
    
        for(int i=1; i<n; i++)
        {
            // 在当前的路径代价中选择最小路径代价
            int pos,cost=INF;
            for(int j=1; j<=n; j++){
                if(!visit[j] && mincost[j]<cost){
                    cost = mincost[j];
                    pos = j;
                }
            }
            total += cost;
            visit[pos] = 1;
            update(pos);
        }
    
    }
    int main()
    {
        cin>>n>>m;
    
        int u,v,c;
        for(int i=0;i<m;i++)
        {
            cin>>u>>v>>c;
            G[u].push_back(make_pair(v,c));
            G[v].push_back(make_pair(u,c));
        }
        prime(1);
        cout<<total;
    
        return 0;
    }

#include<bits/stdc++.h> 
    using namespace std;  
    #define INF 0x3f3f3f3f 
    int lowcost[1010];  
    int e[1010][1010];  
    bool vis[1010];  
    int n,m,sum;  
    void prime()  
    {  
        vis[1]=1;  
        int tmp;  
        int k;  
        for(int i=1;i<=n;i++)  
        lowcost[i]=e[1][i];  
        for(int i=1;i<n;i++)  
        {  
            tmp=INF;  
            for(int j=1;j<=n;j++)  
            if(!vis[j]&&lowcost[j]<tmp)  
            tmp=lowcost[k=j];  
            sum+=tmp;  
            vis[k]=1;  
            for(int j=1;j<=n;j++)  
            if(!vis[j]&&lowcost[j]>e[k][j])  
            lowcost[j]=e[k][j];  
    
        }  
    
    }  
    int main()  
    {  
        int u,v,c;  
        scanf("%d %d",&n,&m);  
        memset(e,INF,sizeof(e));  
        for(int i=0;i<m;i++)  
        {  
         scanf("%d %d %d",&u,&v,&c);  
         e[u][v]=c;  
         e[v][u]=c;  
        }  
        prime();  
        printf("%d\n",sum);  
    }

[Kruskal_Prime]: http://blog.csdn.net/qq_16234613/article/details/52349052