[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 ;

 }

秒客网