2016国庆集训day3-minimum.cpp

Description

给出一幅由 n 个点 m 条边构成的无向带权图。

其中有些点是黑点，另外点是白点。

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

注意：最后选出的边保证每个白点到黑点的距离任然是最短距离。

Input Format

第一行两个整数 n,m

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

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

Output Format

如果无解，输出 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

Hint

选 2、4、6 三条边

• 对于 30% 的数据，1 ≤ n ≤ 10，1 ≤ m ≤ 20。

• 对于 100% 的数据，1 ≤ n ≤ 10 5 ，1 ≤ m ≤ 2 × 10 5 ，1 ≤ z ≤ 10 9 。

这题看完题，就知道是图论，结合数据的特点：边不超过点的2倍——稀疏图。所以应该考虑到SPFA算法。

每个白点都连到最近的黑点，所以，黑点与黑点间的边没有用。

抽象来看，就是所以的白点到一个整体（黑点的集合）的最短距离之和。

考试完学会了“缩点”——不是很明白缩点的应用，但知道它简化问题，有待研究。

我把所有的黑点直接替代成一个点“0”，这样问题转化成了：

所有白点的0点的dist和；

SPFA求完所有最短路后，我们在从“0”出发往回dfs，找到最短路径上的边，即在SPFA中“d[v]>d[u]+v[u,v]”的v[u,v];

一条边可能被多次经过，我们dfs可能会重复把它们选出来，因此，再来一次

最小生成树Kruskal找边。

如果我们求的边权和ans==0，那么说明一条边也找不到，那么“impossible”。

有一组数据：

Input

5 4

1 0 0 0 1

1 2 3

2 3 2

3 4 1

4 5 4

Output

8

情况为点有两条以上的最短路径通向“0”，题目要求“与白点最近的黑点”，所以这个数据挂了，我把非直接连向0的边再增加权值，保证可以走“最近的路”，求值是再判断减去；

以下codes：

#include <algorithm>
#include <cstdio>
#include <cmath>
#include <vector>
#include <stack>
#include <queue>
#include <cstring>
#define maxn 100005
using namespace std;
struct edge{
int to,next,f;
long long v;
}e[400005],E[400005];
int last[maxn],fa[maxn],color[maxn];
bool vis[maxn];
int tot,tot1,n,m,cnt;
bool flag;
long long ans,d[maxn];
int cur;
bool cmp (const edge x,const edge y)
{
return x.v<y.v;
}
int  get(int x)
{
if (fa[x]==x)  return x;
long long y=get(fa[x]);
fa[x]=y;
return y;
}

void Kruskal()
{
sort(E+1,E+1+tot1,cmp);

for (int i=1;i<=tot1;i++)
{
cur=0;
int fx=get(E[i].f);
int fy=get(E[i].to);
if (fx!=fy)
{
fa[fy]=fx;
if (E[i].f!=0&&E[i].to!=0)cur=-2;
ans+=E[i].v+cur;

}

}
}
void  find(int u)
{
for (int i=last[u];i;i=e[i].next)
{
int v=e[i].to;
int k=e[i].v;
if (d[v]==d[u]+k)
{
find(v);
tot1++;
E[tot1].f=u;
E[tot1].to=v;
E[tot1].v=k;

}
}
return ;
}
void spfa()
{
queue<int>q;
memset(vis,0,sizeof(vis));
for (int i=0;i<=n;i++)
d[i]=9999999999999;
d[0]=0;
q.push(0);
vis[0]=1;
while (!q.empty())
{
int u=q.front();
q.pop();
vis[u]=0;
for (int i=last[u];i;i=e[i].next)
{
int v=e[i].to;
int k=e[i].v;
if (d[v]>d[u]+k)
{
d[v]=d[u]+k;
if (vis[v]==0)
{
vis[v]=1;
q.push(v);
}
}
}
}
}
void add(int x,int y,int z)
{
fa[y]=y;
tot++;
e[tot].v=z;
e[tot].to=y;
e[tot].next=last[x];
last[x]=tot;
}
int main()
{
tot=0;
tot1=0;
scanf("%d%d",&n,&m);
flag=true;
for (int i=1;i<=n;i++)
scanf("%d",&color[i]);
for (int i=1;i<=m;i++)
{
int x,y,z;
cur=0;
scanf("%d%d%d",&x,&y,&z);
if (color[x]==0 || color[y]==0)
{
if (color[x]==1)x=0;
if (color[y]==1)y=0;
if (x!=0&&y!=0)cur=2;
add(x,y,z+cur);
add(y,x,z+cur);
}
}
spfa();
find(0);
Kruskal();
if (ans==0)   printf("impossible");
else printf("%lld",ans);
return 0;
}

增加权值的方法正确性有待研究！