Codeforces 400D. Dima and Bacteria【并查集+最短路】

D. Dima and Bacteria

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Dima took up the biology of bacteria, as a result of his experiments, he invented k types of bacteria. Overall, there are n bacteria at his laboratory right now, and the number of bacteria of type i equals c_i. For convenience, we will assume that all the bacteria are numbered from 1 to n. The bacteria of type c_i are numbered from to .

With the help of special equipment Dima can move energy from some bacteria into some other one. Of course, the use of such equipment is not free. Dima knows m ways to move energy from some bacteria to another one. The way with number i can be described with integers u_i, v_i and x_i mean that this way allows moving energy from bacteria with number u_i to bacteria with number v_i or vice versa for x_i dollars.

Dima's Chef (Inna) calls the type-distribution correct if there is a way (may be non-direct) to move energy from any bacteria of the particular type to any other bacteria of the same type (between any two bacteria of the same type) for zero cost.

As for correct type-distribution the cost of moving the energy depends only on the types of bacteria help Inna to determine is the type-distribution correct? If it is, print the matrix d with size k × k. Cell d[i][j] of this matrix must be equal to the minimal possible cost of energy-moving from bacteria with type i to bacteria with type j.

Input

The first line contains three integers n, m, k (1 ≤ n ≤ 10⁵; 0 ≤ m ≤ 10⁵; 1 ≤ k ≤ 500). The next line contains k integers c₁, c₂, ..., c_k (1 ≤ c_i ≤ n). Each of the next m lines contains three integers u_i, v_i, x_i (1 ≤ u_i, v_i ≤ 10⁵; 0 ≤ x_i ≤ 10⁴). It is guaranteed that .

Output

If Dima's type-distribution is correct, print string «Yes», and then k lines: in the i-th line print integers d[i][1], d[i][2], ..., d[i][k] (d[i][i] = 0). If there is no way to move energy from bacteria i to bacteria j appropriate d[i][j] must equal to -1. If the type-distribution isn't correct print «No».

Examples

Input

4 4 2
1 3
2 3 0
3 4 0
2 4 1
2 1 2

Output

Yes
0 2
2 0

Input

3 1 2
2 1
1 2 0

Output

Yes
0 -1
-1 0

Input

3 2 2
2 1
1 2 0
2 3 1

Output

Yes
0 1
1 0

Input

3 0 2
1 2

Output

No

题目大意：

一共有N个细菌，一共分成K种，每种细菌的个数已知，那么对应假设一共有10个细菌，有两种，每种数量分别为1,9

那么我们此时就视为编号为1的细菌是种类1，编号为2~10的细菌为种类2，以此类推。

现在有M个设备，每个设备有三个描述，u，v，w表示编号为u和编号为v的两个细菌可以互相转化能量，使用的费用为w.

现在问你能否保证他的设定是正确的：就是说每种细菌之间转化能量的花费都必须为0。

如果是正确的，那么求每种细菌之间转化能量的最小花费。

否则输出No.

思路：

1、如果已经判定是正确的了，那么对应我们求每种细菌之间转化能量的最小花费，我们可以选择最短路算法来实现，又因为种类数不多，所以表示点不多，那么我们可以选择Floyd算法直接求两点间最短路。

2、那么考虑如何判定此时的图是否是正确的，对应我们拿出所有花费为0的边，对应两个节点u，v我们进行一次合并，最终能够合并出若干个集合来，如果对应一个种类的所有点都在一个集合当中，就表明此时这种细菌我们任意提取两个出来，其转化的需要的花费一定是0.那么如果所有的种类都满足这样的条件，那么这个图就是一个正确的图。那么对应接下来我们跑一遍Floyd即可，否则输出No...

Ac代码：

#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;
int map[505][505];
int f[500004];
int type[5055];
int color[500004];
int n,m,k;
int find(int a)
{
    int r=a;
    while(f[r]!=r)
    r=f[r];
    int i=a;
    int j;
    while(i!=r)
    {
        j=f[i];
        f[i]=r;
        i=j;
    }
    return r;
}
void merge(int a,int b)
{
    int A,B;
    A=find(a);
    B=find(b);
    if(A!=B)
    f[B]=A;
}
int main()
{
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        memset(map,0x3f3f3f3f,sizeof(map));
        for(int i=1;i<=k;i++)map[i][i]=0;
        for(int i=1;i<=n;i++)f[i]=i;
        int now=1;
        for(int i=1;i<=k;i++)
        {
            scanf("%d",&type[i]);
            for(int j=1;j<=type[i];j++)
            {
                color[now]=i;
                now++;
            }
        }
        for(int i=0;i<m;i++)
        {
            int x,y,w;
            scanf("%d%d%d",&x,&y,&w);
            if(w==0)
            merge(x,y);
            if(color[x]!=color[y])
            {
                map[color[x]][color[y]]=min(w,map[color[x]][color[y]]);
                map[color[y]][color[x]]=min(w,map[color[y]][color[x]]);
            }
        }
        for(int i=1;i<=n;i++)
        {

        }
        int flag=0;
        now=1;
        for(int i=1;i<=k;i++)
        {
            int tmp=now;
            for(int j=1;j<=type[i];j++)
            {
                if(find(now)!=find(tmp))flag=1;
                now++;
            }
        }
        if(flag==1)
        {
            printf("No\n");
        }
        else
        {
            printf("Yes\n");
            for(int i=1;i<=k;i++)
            {
                for(int j=1;j<=k;j++)
                {
                    for(int kk=1;kk<=k;kk++)
                    {
                        map[j][kk]=min(map[j][kk],map[j][i]+map[i][kk]);
                    }
                }
            }
            for(int i=1;i<=k;i++)
            {
                for(int j=1;j<=k;j++)
                {
                    if(map[i][j]==0x3f3f3f3f)printf("-1 ");
                    else printf("%d ",map[i][j]);
                }
                printf("\n");
            }
        }
    }
}