NOIP2017 7.17模拟 Minimum (最短路+最小生成树)

题目描述：

给出一幅由 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

【数据范围】

对 30% 的输入数据 ：1≤n≤10，1≤m≤20；

对 100% 的输入数据 ：1≤n≤100000，1≤m≤200000，1≤z≤1000000000 。

题意：将所有白点和黑点通过在最短路上的路径连接，求最小代价，无解的情况是存在白点与黑点无法连通。通过分析我们可以发现，有解的情况可以分为两个问题考虑：

1、求最短路；

2.并找到在最短路上的边；

3、通过这些边跑一边最小生成树，统计边权之和。

对于第一个问题，因为是要求任意一个白点到任意一个黑点的距离，我们可以想到建一个超级点，由它向每一个黑点连一条边权为0的有向边，然后由这个超级点跑一次最短路（迪杰斯特拉或spfa),就行了；

对于第二个问题，由最短路的更新方法

if(dis[a]+val[i]<dis[to[i]])
dis[to[i]]=dis[a]+val[i];

我们可以想到，遍历每条边，满足dis[edge[i].start]==dis[edge[i].end+edge[i[.val那么这条边一定是最短路上的边，由此我们可以找到所有最短路上的边

对于第三个问题，裸的最小生成树，在此就不赘述了；

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<ctime>
#include<cstring>
#include<string>
#include<iomanip>
#include<iostream>
#include<cctype>
#include<queue>
using namespace std;
int n,m,tot,sup,cnt,len,fa[100005],next[500010],first[100005],to[500010];
long long dis[100005];
long long val[500010];
bool black[100005],ok=true;
//---------------------
priority_queue< pair<int,int> > que;
pair<int,int> temp;
//---------------------
struct node
{
int st,end;
long long val;
}a[400010];

bool cmp(const node&a,const node&b)
{
return a.val<b.val;
}
//---------------------
inline long long Readint()
{
long long i=0,f=1;
char ch;
for(ch=getchar();(ch<'0'||ch>'9')&&ch!='-';ch=getchar());
if(ch=='-') f=-1;
for(;ch>='0'&&ch<='9';ch=getchar()) i=(i<<1)+(i<<3)+ch-'0';
return i*f;
}
//---------------------
inline void add(int x,int y,long long z)
{
next[++tot]=first[x];
first[x]=tot;
to[tot]=y;
val[tot]=z;
}
//---------------------
inline void djstra(int root)
{
dis[root]=0;
temp.first=0;
temp.second=root;
que.push(temp);
while(!que.empty()){
temp=que.top();
que.pop();
int a=temp.second;
for(int i=first[a];i;i=next[i]){
if(dis[a]+val[i]<dis[to[i]]){
dis[to[i]]=dis[a]+val[i];
pair<int,int> s;
s.first=-dis[to[i]];
s.second=to[i];
que.push(s);
}
}
}
}
//---------------------
inline int find(int x)
{
if(x==fa[x]) return x;
fa[x]=find(fa[x]);
return fa[x];
}
//---------------------
int main()
{
freopen("minimum.in","r",stdin);

n=Readint(),m=Readint();
memset(first,0,sizeof(first));
for(int i=0;i<=n;i++) fa[i]=i;
for(int i=0;i<=n;i++) dis[i]=1e16+7;
for(int i=1;i<=n;i++){
black[i]=Readint();
if(black[i]) add(sup,i,0);
}
for(int i=1;i<=m;i++){
int x,y;
long long z;
x=Readint(),y=Readint(),z=Readint();
add(x,y,z),add(y,x,z);
}
djstra(sup);

for(int i=1;i<=n;i++) if(dis[i]==1e16+7) ok=false;
if(!ok){
cout<<"impossible"<<endl;
return 0;
}
for(int i=1;i<=n;i++){
for(int p=first[i];p;p=next[p]){
if(dis[to[p]]==val[p]+dis[i]){
a[++len].st=i,a[len].end=to[p],a[len].val=val[p];
}
}
}
long long ans=0;
sort(a+1,a+1+len,cmp);
for(int i=1;i<=len;i++){
int fx=find(a[i].st),fy=find(a[i].end);
if(fx!=fy){
fa[fx]=fy;
ans+=a[i].val;
cnt++;
}
if(cnt==n-1) break;
}
cout<<ans<<endl;
return 0;
}