zufe oj 引水工程（巧妙地把在i建水设为e[0][i]）

引水工程

时间限制: 3 Sec 内存限制: 128 MB
提交: 11 解决: 6
[提交][状态][讨论版]

题目描述

南水北调工程是优化水资源配置、促进区域协调发展的基础性工程，是新中国成立以来投资额最大、涉及面最广的战略性工程，事关中华民族长远发展。“南水北调工程”，旨在缓解中国华北和西北地区水资源短缺的国家战略性工程。就是把中国长江流域丰盈的水资源抽调一部分送到华北和西北地区。我国南涝北旱，南水北调工程通过跨流域的水资源合理配置，促进南北方经济、社会与人口、资源、环境的协调发展。

整个工程分东线、中线、西线三条调水线。东线工程位于东部，因地势低需抽水北送至华北地区。中线工程从汉水与其最大支流丹江交汇处的丹江口水库引水，自流供水给黄淮海平原大部分地区，20多座大中城市；西线工程在青藏高原上，由长江上游向黄河上游补水。

现在有N个区域需要建设水资源工程，它们可以自建水库解决缺水问题，也可以从已有水源的地区建立管道引水过来。当然，这些建设都需要大量投资。

你能不能给出一个优化水资源配置方案，在保证每个区域都能用上水的前提下，使得整个引水工程费用最低。

输入

第一行： K 表示有多少组测试数据。

接下来对每组测试数据：

第1行: N 表示有N个区域（ 1<=N<=300 ）

第2 行： W1 W2 …. WN Wi表示第i个区域自建水库需要的费用

再有N行： Pi1 Pi2 …. Pin Pij表示建立第i个区域与第j个区域引水管道的费用

输出

对于每组测试数据，输出占一行，即建立整个引水工程的最小费用。

样例输入

样例输出

10

这道题的思路（我觉得有漏洞）：在全部都自己建水的基础上，选最便宜的点建水，然后借这个点向外松弛。
虽然我AC了，但是发现有一组我自己编的样例过不了，那就是
1
3
11 11 10
0 1 1
1 0 1
10 10 0
答案应该是12，但是我的代码是21，网上很多代码都是21，这其实源于 选最便宜的点建水  这一步有问题，因此我觉得应该每个点都作为起点试一下，但TLM了。
真正的解法应该用克鲁斯卡尔。

下面是AC代码（因为题目不严谨而AC）prim解法

#include <iostream>

#include <string>

#include <cstring>

#include <algorithm>

#define inf 0x3f3f3f3f

using namespace std;

int a[];

int e[][];

bool v[];

int n;

int prim()

{

    memset(v, , sizeof(v));

    int sum = ;

    while ()

    {

        int mbu = inf;

        int k, i;

        k = -;

        for (i = ; i <= n; i++)//先都建水，找出当前建水费用最少的点

        {

            if (v[i]==&&(k==-||a[i] < a[k]))

            {

                k = i;

            }

        }

        if (k == -) break;

        sum = sum + a[k];

        v[k] = ;//模拟删除改点

        for (i = ; i <= n; i++)

        {

            a[i] = min(a[i], e[k][i]);//用该点松弛

        }

    }

    return sum;

}

int main()

{

    int t;

    cin >> t;

    while (t--)

    {

        cin >> n;

        memset(e, inf, sizeof(e));

        int i;

        for (i = ; i <= n; i++)

        {

            cin >> a[i];

        }

        int j;

        for (i = ; i <= n; i++)

        {

            for (j = ; j <= n; j++)

            {

                cin >> e[i][j];

            }

        }

        cout << prim() << endl;

    }

}

下面是克鲁斯卡尔(Kruskal)解法，我的样例也能过

巧妙地把在i建水设为e[0][i]

思路，将自建水库 i 需要的费用转化为边0---->i .

然后用并查集算法求点 0到n的最小生成树即可。

代码：

#include<stdio.h>

#include<string.h>

#include<algorithm>

using namespace std;

struct Edge

{

    int u;

    int v;

    int cost;

}e[];

int map[][],c[],n,p[];

int comp(Edge e1,Edge e2)

{

    return e1.cost<e2.cost;

}

int find(int x)  //找父节点

{

    if(p[x]!=x)

    {

        p[x]=find(p[x]);

    }

    return p[x];

}

bool bin(int x,int y) //将x，y添加至一个集合

{

    int g,h;

    g=find(x);

    h=find(y);

    if(g==h)

        return false;

    p[g]=h;

    return true;

}

bool judge()    //判断是否所有点都在一个集合

{

    int i,count=;

    for(i=;i<=n;i++)

    {

        if(p[i]==i)

            count++;

        if(count>)

            return false;

    }

    return true;

}

int main()

{

    int t,k,i,j,x,res;

    scanf("%d",&t);

    while(t--)

    {

        res=;

        k=;

        scanf("%d",&n);

        for(i=;i<=n;i++)

            p[i]=i;

        for(i=;i<=n;i++)

        {

            scanf("%d",&x);

            e[k].u=;

            e[k].v=i;

            e[k++].cost=x;

        }

        for(i=;i<=n;i++)

            for(j=;j<=n;j++)

            {

                scanf("%d",&x);

                e[k].u=i;

                e[k].v=j;

                e[k++].cost=x;

            }

        sort(e,e+k,comp);

        for(i=;i<k;i++)

        {

            if(bin(e[i].u,e[i].v))

                res+=e[i].cost;

            if(judge())

                break;

        }

        printf("%d\n",res);

    }

    return ;

}

#include<iostream>

#include<cstring>

#include<cstdio>

#include<cmath>

#include<algorithm>

#include<set>

using namespace std;

#define mem(x,y) memset(x,y,sizeof(x))

#define SI(x) scanf_s("%d",&x)

#define SL(x) scanf_s("%lld",&x)

#define  PI(x) printf("%d",x)

#define  PL(x) printf("%lld",x)

#define P_ printf(" ")

const int INF = 0x3f3f3f3f;

const double PI = acos(-1.0);

typedef long long LL;

const int MAXN = ;

struct Node

{

    int u, v, w;

    void init(int x = , int y = , int z = )/*:u(x),v(y),w(z)*/

    {

        u = x; v = y; w = z;

    }

    friend bool operator < (Node a, Node b)

    {

        return a.w<b.w;

    }

}dt[];

int ans;

int pre[MAXN];

int find(int x)

{

    return pre[x] = x == pre[x] ? x : find(pre[x]);

}

void merge(Node a)

{

    int f1 = find(a.u), f2 = find(a.v);

    if (f1 != f2)pre[f1] = f2, ans += a.w;

}

int main()

{

    int K, N;

    SI(K);

    while (K--)

    {

        SI(N);

        int x, k = ;

        for (int i = ; i <= N; i++)

            for (int j = ; j <= N; j++)

            {

                SI(x);

                if (i<j)

                {

                    dt[k++].init(i, j, x);

                }

            }

        sort(dt, dt + k);

        //for(int i=0;i<k;i++)printf("%d %d %d\n",dt[i].u,dt[i].v,dt[i].w);

        for (int i = ; i <= N; i++)pre[i] = i;

        ans = ;

        for (int i = ; i<k; i++)merge(dt[i]);

        printf("%d\n", ans);

    }

    return ;

}

下面是能过这组样例但是超时的代码

#include <iostream>

#include <string>

#include <cstring>

#include <algorithm>

#define inf 0x3f3f3f3f

using namespace std;

int a[];

int e[][];

bool v[];

int u[];

int n;

int prim()

{

    int sum = ;

    while ()

    {

        int mbu = inf;

        int k, i;

        k = -;

        for (i = ; i <= n; i++)//先都建水，找出当前建水费用最少的点

        {

            if (v[i]==&&(k==-||a[i] < a[k]))

            {

                k = i;

            }

        }

        if (k == -) break;

        sum = sum + a[k];

        v[k] = ;//模拟删除改点

        for (i = ; i <= n; i++)

        {

            a[i] = min(a[i], e[k][i]);//用该点松弛

        }

    }

    return sum;

}

int main()

{

    int t;

    cin >> t;

    while (t--)

    {

        cin >> n;

        memset(e, inf, sizeof(e));

        int i;

        for (i = ; i <= n; i++)

        {

            cin >> u[i];

        }

        int j;

        for (i = ; i <= n; i++)

        {

            for (j = ; j <= n; j++)

            {

                cin >> e[i][j];

            }

        }

        int mm = inf;

        int s1;

        memset(v, , sizeof(v));

        for (i = ; i <= n; i++) a[i] = u[i];

        s1 = prim();

        if (s1 < mm) mm = s1;

        for (i = ; i <= n; i++)//我加了这一步

        {

            int j;

            for (j = ; j <= n; j++) a[j] = u[j];

            memset(v, , sizeof(v));

            v[i] = ;//这一点确定不自己建水

            s1 = prim();

            if (s1 < mm) mm = s1;

            v[i] = ;//回退

        }

        cout << mm << endl;

    }

}

//1 3

//10 10 11

//0 1 1

//1 0 1

//10 10 0

//

@太年轻

感谢这位游客，告诉我了不能过我的样例的真相：

其实这题没有说明白，但是观察样例可以
看出每个 i 到 j 的值与 j 到 i 的值是相等的，题目中没有明说这一点，
但是那样写都过了说明测试数据没有不相等的情况。
其实克鲁斯卡尔和Prim都是相通的，能用克鲁斯卡尔就一定能用Prim.
比如这题，我们将错就错，题目没有说管道是单向的，那么拿博主造的
样例来说，在连边的时候较长的边就废弃不用了，用Prim时只需在
连边的时候加一句判断条件即可，这样博主的样例Prim也能过了，
至于克鲁斯卡尔为什么能过，以为sort()排序已经把长的边排到了
后面，实际上长边根本没有用到，和Prim前面的剔除长边道理相通。
话说回来，如果道路是单向的，那么Prim就不能剔除边，但这时用
克鲁斯卡尔也是错的，因为克鲁斯卡尔不会考虑方向，比如存在两条边
a-->b c-->b 若用克鲁斯卡尔加入并查集，则a，c便在一个并查集里，
但实际上a,c是不相通的。