[BZOJ 3332]旧试题

Description

圣诞节将至。一年一度的难题又摆在wyx面前——如何给妹纸送礼物。
wyx的后宫有n人，这n人之间有着复杂的关系网，相互认识的人有m对。wyx想要量化后宫之间的亲密度，于是准备给每对认识关系估一个亲密度。亲密度是个正整数，值越大说明越亲密。当然有可能有些后宫之间不直接认识，为此wyx定义了一个值f(i,j)，代表从第i个后宫开始不断经过认识的人到j，经过的亲密度最小的一对关系的最大值。不过也有可能有些后宫的朋友圈互相独立，怎么也没法通过认识的人互相到达，那么f(i,j)就为-1。
举个例子，wyx的后宫有4人，编号为1~4。后宫1和2之间的亲密度为3，后宫2和3之间的亲密度为4，后宫1和3之间的亲密度为2，后宫4由于不明原因被孤立了。那么f(1,2)=f(1,3)=3，f(2,3)=4，f(1,4)=f(2,4)=f(3,4)=-1。
wyx认为了解后宫之间的亲密程度对于他选择礼物有着很重大的意义，于是他找了几个路人，测出了所有后宫之间的f(i,j)值。不过wyx怀疑路人在坑爹，他想知道，是否能找到一组后宫之间的亲密度方案满足路人测出的f(i,j)值？由于他还要去把妹，这个问题就交给你了。

Input

第一行一个正整数T，代表数据组数。

接下来T组数据，每组数据第一行两个正整数n、m，代表点数和边数。

接下来m行，每行两个正整数代表一条边。
接下来n行每行n个整数，代表所有的f(i,j)值。

Output

对于每组数据，输出 "Yes" 或者 "No"。（详细参看样例输出）

Sample Input

3
4 5
1 2
1 3
1 4
2 3
2 4
0 5 5 5
5 0 5 5
5 5 0 4
5 5 4 0
4 4
1 2
1 3
2 3
2 4
0 4 4 4
4 0 4 5
4 4 0 4
4 5 4 0
4 2
1 2
2 3
0 3 3 -1
3 0 4 -1
3 4 0 -1
-1 -1 -1 0

Sample Output

Case #1: No
Case #2: Yes
Case #3: Yes

HINT

数据范围

T ≤ 30

n ≤ 1000

m ≤ 300000

f(i,j)=-1 或者 1 ≤ f(i,j) ≤ 32767
注意输入量奇大无比！

题解

其实就是给个存路径上最小值最大的$floyd$矩阵，问你是否合法。

因为数据量大，显然不能够直接$floyd$。既然它是最大化最小值。我们想到最大化瓶颈路。实际上我跑一次$Kruskal$求最大生成树，在以每个点为根，遍历一遍树，看是否合法即可。

 //It is made by Awson on 2017.10.18
 #include <set>
 #include <map>
 #include <cmath>
 #include <ctime>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <cstdio>
 #include <string>
 #include <cstring>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>
 #define LL long long
 #define link LINK
 #define set SET
 #define Max(a, b) ((a) > (b) ? (a) : (b))
 #define Min(a, b) ((a) < (b) ? (a) : (b))
 using namespace std;
 void read(int &x) {
     bool flag = ;
     x = ;
     char ch = getchar();
     while ((ch < '' || ch > '') && ch != '-') ch = getchar();
     if (ch == '-') flag = , ch = getchar();
     while (ch >= '' && ch <= '') x = (x<<)+(x<<)+ch-, ch = getchar();
     x *= -*flag;
 }
 const int N = ;
 const int M = ;

 int n, m;
 struct ss {
     int from, to, cost;
     bool operator < (const ss &b) const{
         return cost > b.cost;
     }
 }link[M+];
 int mp[N+][N+];
 struct tt {
     int to, cost, next;
 }edge[(N<<)+];
 int path[N+], top;
 int set[N+];
 int dist[N+];

 int find(int r) {
     return set[r] ? set[r] = find(set[r]) : r;
 }
 void add(int u, int v, int c) {
     edge[++top].to = v;
     edge[top].cost = c;
     edge[top].next = path[u];
     path[u] = top;
 }
 void Kruskal() {
     sort(link+, link++m); int cnt = ;
     for (int i = ; i <= m; i++) {
         int p = find(link[i].from), q = find(link[i].to);
         if (p != q) {
             set[p] = q; cnt++;
             add(link[i].from, link[i].to, link[i].cost);
             add(link[i].to, link[i].from, link[i].cost);
             if (cnt == n-) break;
         }
     }
 }
 void dfs(int u, int fa, int mind) {
     dist[u] = mind;
     for (int i = path[u]; i; i = edge[i].next) if (edge[i].to != fa) dfs(edge[i].to, u, Min(mind, edge[i].cost));
 }
 void work() {
     read(n), read(m); memset(path, , sizeof(path)); top = ; memset(set, , sizeof(set));
     for (int i = ; i <= m; i++) read(link[i].from), read(link[i].to);
     for (int i = ; i <= n; i++) for (int j = ; j <= n; j++) read(mp[i][j]);
     for (int i = ; i <= m; i++) link[i].cost = mp[link[i].from][link[i].to];
     Kruskal();
     for (int i = ; i <= n; i++) {
         memset(dist, -, sizeof(dist));
         dfs(i, , 2e9); dist[i] = ;
         for (int j = ; j <= n; j++) if (dist[j] != mp[i][j]) {
             printf("No\n"); return;
         }
     }
     printf("Yes\n");
 }
 int main() {
     int t;
     read(t);
     for (int i = ; i <= t; i++) {
         printf("Case #%d: ", i);
         work();
     }
     return ;
 }