problem

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

analysis

• SPFA+MST

• 建立一个点$S$（我选的是$n+1$），向所有黑点连一条权值为$0$的边

• 从$S$点跑一个最短路，这样可以保证白点到离最近的黑点距离最短

• 然后把从$S$开始所有在最短路上的边都拿出来，再做一个最小生成树就可以了

code

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
#define MAXN 500005
#define ll long long
#define fo(i,a,b) for (ll i=a;i<=b;i++)

using namespace std;

ll last[MAXN*2],next[MAXN*2],tov[MAXN*2],len[MAXN*2];
ll dis[MAXN],fa[MAXN];
bool bz[MAXN];
ll n,m,tot,total,ans;
queue<ll>que;

struct edge
{
    ll x,y,z;
}a[MAXN];

ll read()
{
    ll x=0,f=1;
    char ch=getchar();
    while (ch<'0' || '9'<ch)
    {
        if (ch=='-')f=-1;
        ch=getchar();   
    }
    while ('0'<=ch && ch<='9')
    {
        x=x*10+ch-'0';
        ch=getchar();
    }
    return x*f;
}

void insert(ll x,ll y,ll z)
{
    next[++tot]=last[x];
    last[x]=tot;
    tov[tot]=y;
    len[tot]=z;
}

void spfa()
{
    while (!que.empty())que.pop();
    memset(dis,63,sizeof(dis));
    memset(bz,1,sizeof(bz));
    que.push(n+1),dis[n+1]=bz[n+1]=0;
    while (!que.empty())
    {
        int now=que.front();
        que.pop();
        for (ll i=last[now];i;i=next[i])
        {
            if (dis[now]+len[i]<dis[tov[i]])
            {
                dis[tov[i]]=dis[now]+len[i];
                if (bz[tov[i]])
                {
                    que.push(tov[i]);
                    bz[tov[i]]=0;
                }
            }
        }
        bz[now]=1;
    }
}

void dfs(int x)
{
    for (ll i=last[x];i;i=next[i])
    {
        if (dis[x]+len[i]==dis[tov[i]])
        {
            dfs(tov[i]);
            a[++tot]={x,tov[i],len[i]};
        }
    }
}

bool cmp(edge a,edge b)
{
    return a.z<b.z;
}

ll getfa(ll x)
{
    return fa[x]==0?x:fa[x]=getfa(fa[x]);
}

void kruskal()
{
    sort(a+1,a+tot+1,cmp);
    fo(i,1,tot)
    {
        int xx=a[i].x,yy=a[i].y;
        if (getfa(xx)!=getfa(yy))
        {
            fa[xx]=yy;
            ans+=a[i].z;
        }
    }
}

int main()
{
    n=read(),m=read();
    fo(i,1,n)if (read())insert(n+1,i,0);
    fo(i,1,m)
    {
        ll x=read(),y=read(),z=read();
        insert(x,y,z),insert(y,x,z);
    }
    tot=0;
    spfa();
    dfs(n+1);
    kruskal();
    if (!ans)printf("impossible\n");
    else printf("%lld\n",ans);
    return 0;
}