[spfa][最小生成树] Jzoj P4261 最小代价

Description

给出一幅由n个点m条边构成的无向带权图。
其中有些点是黑点，其他点是白点。
现在每个白点都要与他距离最近的黑点通过最短路连接（如果有很多个黑点，可以选取其中任意一个），我们想要使得花费的代价最小。请问这个最小代价是多少？
注意：最后选出的边保证每个白点到离它最近的黑点的距离仍然等于原图中的最短距离。

 

Input

第一行两个整数n，m；
第二行n 个整数，0表示白点，1 表示黑点；
接下来m 行，每行三个整数x，y，z，表示一条连接x和y 点，权值为z 的边。

Output

如果无解，输出impossible；
否则，输出最小代价。

 

Sample Input

5 7
0 1 0 1 0
1 2 11
1 3 1
1 5 17
2 3 1
3 5 18
4 5 3
2 4 5

Sample Output

5
【样例解释】
选 2、4、6三条边

 

Data Constraint

对30%的输入数据： 1≤n≤10， 1≤m≤20；
对100%的输入数据：1≤n≤100000，1≤m≤200000，1≤z≤1000000000

题解

• 一开始时，一直在想如果找到与哪个黑点相连
• 可以考虑一下从建一个S源点，然后把黑点向S点连一条权值为0的边
• 然后我们就可以求出从S点到所有点的最短距离
• 问题就转换为了求白点到S的距离
• 从S出发往回dfs，找到最短路径上的边
• 一条边可能被多次经过，我们dfs可能会重复把边选出来，但题目要求一条边只加一次代价
• 所以可以用Kruskal，把边连起来，避免重复边
• 如果我们求的边权和ans==0，那么说明一条边也找不到，那么“impossible”

代码

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;
const int inf=0x3f3f3f;
struct edge {long long to,from,v; }e[300010*2],k[300010*2];
long long dis[100010],ans,fa[100010],n,m,head[100010],cnt,tot;
bool f[100010];
queue<int>Q;
void insert(int x,int y,int z) { e[++cnt].to=y; e[cnt].from=head[x]; e[cnt].v=z; head[x]=cnt; }
void spfa()
{
    memset(dis,inf,sizeof(dis));
    memset(f,false,sizeof(f));
    Q.push(0); dis[0]=0;
    while (!Q.empty())
    {
        int u=Q.front(); Q.pop();
        f[u]=false;
        for (int i=head[u];i;i=e[i].from)
            if (dis[u]+e[i].v<dis[e[i].to])
            {
                dis[e[i].to]=dis[u]+e[i].v;
                if (!f[e[i].to])
                {
                    Q.push(e[i].to);
                    f[e[i].to]=true;
                }
            }
    }
}
void dg(int x)
{
    for (long long i=head[x];i;i=e[i].from)
        if (dis[x]+e[i].v==dis[e[i].to])
        {
            dg(e[i].to);
            k[++tot].from=x,k[tot].to=e[i].to,k[tot].v=e[i].v;
        }
}
long long getfather(int x)
{
    if (fa[x]==x) return x;
    return fa[x]=getfather(fa[x]);
}
void kruskal()
{
    for (long long i=1;i<=tot;i++)
    {
        long long x=getfather(k[i].from),y=getfather(k[i].to);
        if (x!=y)
        {
            ans+=k[i].v;
            fa[y]=x;
        }
    }
}
bool cmp(edge x,edge y) { return x.from<y.from; }
int main()
{
    scanf("%lld%lld",&n,&m);
    for (int i=1;i<=n;i++)
    {
        int x;
        scanf("%d",&x);
        if (x==1) insert(0,i,0);
    }
    for (int i=1;i<=m;i++)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        insert(x,y,z); insert(y,x,z);
    }
    spfa();
    dg(0);
    sort(k+1,k+tot+1,cmp);
    for (int i=1;i<=n;i++) fa[i]=i;
    kruskal();
    if (ans==0) printf("impossible"); else printf("%lld",ans);
}