寒假2019培训：最小代价*图论*@最小生成树@

题目描述

给出一幅由n个点m条边构成的无向带权图。 其中有些点是黑点，其他点是白点。

现在每个白点都要与他距离最近的黑点通过最短路连接（如果有很多个黑点，可以选取其中任意一个），我们想要使得花费的代价最小。

请问这个最小代价是多少？

注意：最后选出的边保证每个白点到离它最近的黑点的距离仍然等于原图中的最短距离。

输入格式

第一行两个整数n，m；

第二行n 个整数，0表示白点，1 表示黑点；

接下来m 行，每行三个整数x，y，z，表示一条连接x和y 点，权值为z 的边。

输出格式

如果无解，输出impossible；

否则，输出最小代价。

样例数据

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
output

5

【样例解释】

选 2、4、6三条边
数据规模与约定
对30%的输入数据： 1≤n≤10， 1≤m≤20；
对100%的输入数据：1≤n≤100000，1≤m≤200000，1≤z≤1000000000

时间限制：1s
空间限制：256MB

添加超级源点S，S 与每个黑点间连上权值为0的边，先处理从S 出发到每个点的最短距离，取出一张最短路径图，然后再来一次最小生成树算法

#include<bits/stdc++.h>
using namespace std;
FILE *fin,*fout;
const int N=100000+200,M=500000+20;
int n,m,color[N],Last[M],t,T,vis[N],f[N],total;
long long dis[N],ans;
priority_queue < pair<long long,int>,vector< pair<long long,int> >,greater< pair<long long,int> > > Heap;
struct EDGE{int reach,next,start,flag;long long val;}e[M];
inline void insert(int x,int y,long long v)
{
	e[++t].reach=y;e[t].val=v;e[t].next=Last[x];Last[x]=t;e[t].start=x;
}
inline int find(int x){return f[x]==x?x:f[x]=find(f[x]);}
inline bool cmp(EDGE p1,EDGE p2){return p1.val<p2.val;}
inline void input(void)
{
	fscanf(fin,"%d%d",&n,&m);
	for(int i=1;i<=n;i++)
		fscanf(fin,"%d",&color[i]);
	for(int i=1;i<=m;i++)
	{
		int x,y;long long v;
		fscanf(fin,"%d%d%lld",&x,&y,&v);
		insert(x,y,v);
		insert(y,x,v);	
	}
} 
inline void super_node(void)
{
	for(int i=1;i<=n;i++)
	{
		if(color[i])
			insert(i,0,0LL),
			insert(0,i,0LL);
	}
}
inline void dijkstra(void)
{
	memset(dis,127,sizeof dis);
	memset(vis,0,sizeof vis);
	Heap.push(make_pair(0LL,0));
	dis[0]=0LL;
	while(!Heap.empty())
	{
		int temp=Heap.top().second;
		Heap.pop();
		if(vis[temp])continue;
		vis[temp]=true;
		for(int i=Last[temp];i;i=e[i].next)
		{
			int reach=e[i].reach;
			if(dis[reach]>dis[temp]+e[i].val)
			{
				dis[reach]=dis[temp]+e[i].val;
				Heap.push(make_pair(dis[reach],reach));
			}
		}
	}
}
inline void build(void)
{
	for(int i=0;i<=n;i++)
	{
		for(int j=Last[i];j;j=e[j].next)
		{
			int x=i,y=e[j].reach;
			if(dis[y]==dis[x]+e[j].val)
				e[j].flag=true;
		}
	}
}
inline void kruscal(void)
{
	for(int i=0;i<=n;i++)
		f[i]=i;
	sort(e+1,e+t+1,cmp);
	int cnt=0;
	for(int i=1;i<=t;i++)
	{
		if(!e[i].flag)continue;
		int x=find(e[i].start),y=find(e[i].reach);
		if(x==y)continue;
		f[x]=y;
		cnt++;
		ans+=e[i].val;
		if(cnt==n)break;
	}
}
int main(void)
{
	fin=fopen("minimum.in","r");
	fout=fopen("minimum.out","w");
	input();
	super_node();
	dijkstra();
	build();
	kruscal();
	if(ans)fprintf(fout,"%lld\n",ans);
	else fprintf(fout,"impossible\n");
	return 0;
}

*或者看看这个*~~

#include<bits/stdc++.h>
using namespace std;
const int N=200005;
long long n,m,k,len,tot,cnt;
long long f[N*2],last[N*2],vis[N*2],fa[N*2],dis[N*2];
long long ans=0;
struct ss
{
    int to,next,v,fg,x;
}e[N*4];
void insert(int x,int y,int z)
{
    e[++len].next=last[x],
	e[len].to=y,
	e[len].v=z,
	e[len].x=x,
    last[x]=len;
}
void SPFA(int x)
{ 
    queue<int>q;
	memset(dis,0x3f3f3f3f,sizeof(dis));
    dis[x]=0,vis[x]=1,q.push(x);
    while(!q.empty())
    {
        int _x=q.front(),i=last[_x];
        for(q.pop(),vis[_x]=0;i;i=e[i].next)
        {
            int v=e[i].to;
            if(dis[v]>dis[_x]+e[i].v)
            {
                dis[v]=dis[_x]+e[i].v;
                if(!vis[v])vis[v]=1,q.push(v);
            }
        }
    }
}
void dfs()
{
	int i=0,j;
    for(;++i<=n;)
    {
        if(f[i])continue;
        for(j=last[i];j;j=e[j].next)
        {
            int v=e[j].to;
            if(v==0)continue;
            if(dis[v]+e[j].v==dis[i])e[j].fg=1;
        }
    }
}
bool myc(ss xx,ss yy)
{
   return xx.v<yy.v;
}
int find(int x)
{
    return fa[x]==x?fa[x]:fa[x]=find(fa[x]);
}
int main()
{
//	freopen("minimum.in","r",stdin);
//	freopen("minimum.out","w",stdout);
	
	int i=0,j;
    for(scanf("%lld%lld",&n,&m);++i<=n;)scanf("%lld",&f[i]);
    for(i=0;++i<=m;) 
    {
        int x,y,z;
        scanf("%lld%lld%lld",&x,&y,&z);
        insert(x,y,z),
		insert(y,x,z);
    }
    for(i=0;++i<=n;)
    {
        if(f[i])
		    insert(0,i,0),
		    insert(i,0,0);
        fa[i]=i;
    }
    
    for(SPFA(0),dfs(),sort(e+1,e+1+len,myc),ans=0,tot=0,i=0;++i<=len;)
    {
        if(!e[i].fg)continue;
        int x=e[i].x,y=e[i].to;
        int _x=find(x),_y=find(y);
        if(_x!=_y)
        {
            fa[_x]=_y,++tot;
            ans+=e[i].v;
            if(tot==n-1)break;
        }
    }
    if(!ans)printf("impossible");
    else printf("%lld",ans);
    return 0;
 }

---

谢谢观赏~~