SDOJ 3742 黑白图

【描述】

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

【输入】

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

【输出】

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

【输入样例】

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

【输出样例】

5

【样例说明】

选 2、4、6 三条边；

【数据范围】

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

------------------------------------------------------------------------------------------------

这道题有两个关键点，一是距离最近的黑点，一是价值最小。

对于距离最近，我们可以建立一个超级汇点，汇点用零边连接每个黑点，然后从汇点开始跑最短路。

因为汇点和黑点之间权值为0，所以汇点与白点之间跑出来的最短路是白点和黑点之间的最短路。

对于第二点，价值最小，我们已经得到了最短路径图、确定了距离白点最近的黑点，所以可以跑一个最小生成树，在确保图连通的情况下得到最小价值。

注：形成的最小生成树上的边不一定是白点到黑点最短距离的边，但可以肯定这个黑点是最优的，而且我们关注的是最小价值。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 #include<queue>
 #define N 200100
 #define INF 0x3f
 using namespace std;
 long long n,m,ans=;
 bool vis[N];
 long long dis[N];
 long long fa[N];
 struct node
 {
     long long u,v,w,nxt;
 }e[N*],d[N*];
 long long first[N],cnt,tot;
 void ade(long long u,long long v,long long w)
 {
     e[++cnt].nxt=first[u]; first[u]=cnt;
     e[cnt].u=u; e[cnt].v=v; e[cnt].w=w;
 }
 queue<long long>q;
 void spfa(long long x)
 {
     memset(dis,0x3f,sizeof(dis));
     memset(vis,true,sizeof(vis));
     q.push(x);
     dis[x]=;
     while(!q.empty())
     {
         long long u=q.front(); q.pop();
         vis[u]=true;
         for(long long i=first[u];i;i=e[i].nxt)
         {
             long long v=e[i].v;
             if(dis[v]>dis[u]+e[i].w)
             {
                 dis[v]=dis[u]+e[i].w;
                 if(vis[v]==true)
                 {
                     q.push(v);
                     vis[v]=false;
                 }
             }
         }
     }
 }
 inline bool cmp(node a,node b)
 {
     return a.w<b.w;
 }
 long long la(long long x)
 {
     if(fa[x]!=x)  fa[x]=la(fa[x]);
     return fa[x];
 }
 void kruskal()
 {
     sort(e+,e+tot+,cmp);
     for(long long i=;i<=n;i++) fa[i]=i;
     long long cnnt=n;
     for(long long i=;i<=tot;i++)
     {
         if(!cnnt) break;
         long long x=la(d[i].u);
         long long y=la(d[i].v);
         if(x==y) continue;
         fa[x]=y;
         ans+=d[i].w;
         --cnnt;
     }
 }
 int main()
 {
     scanf("%lld%lld",&n,&m);
     for(long long i=,x;i<=n;i++)
     {
         scanf("%lld",&x);
         if(x==) ade(n+,i,);//ade(i,n+1,0);//建立汇点
     }
     for(long long i=;i<=m;i++)
     {
         long long x,y,z;
         scanf("%lld%lld%lld",&x,&y,&z);
         ade(x,y,z);ade(y,x,z);
     }
     spfa(n+);
 //    for(long long i=1;i<=n;i++) cout<<dis[i]<<" ";
 //    cout<<endl;
     bool pu=;
     for(long long i=;i<=n;i++)
     {
         if(dis[i]==INF) pu=;
         for(long long j=first[i];j;j=e[j].nxt)//!!!!!!!!建立新最短路图
             if(dis[e[j].v]==dis[i]+e[j].w)
                 d[++tot].u=i,d[tot].v=e[j].v,d[tot].w=e[j].w;
     }
 //    for(long long i=1;i<=tot;i++)
 //        cout<<d[i].u<<" "<<d[i].v<<" "<<d[i].w<<endl;
 //    cout<<endl;
     if(pu==)
     {
         printf("impossible\n");
         return ;
     }
     kruskal();
     if(ans==)
     {
         printf("impossible\n"); return ;
     }
     printf("%lld\n",ans);
     return ;
 }