floyd骚操作——传递闭包

传递闭包的含义指通过传递性推导出尽量多的元素之间的关系，而传递闭包一般都是采用floyd算法。

下面用两道题来实现传递闭包：

Problem 1（POJ3660）：

题目链接：http://poj.org/problem?id=3660

题目：

题意：n头牛参加比赛，给你m对关系（譬如给你a和b，那么给的就是a必赢b，当然，b能赢c，那么a也能赢c），问能确定多少头牛的排名。

思路：首先我们用flod算法将所有的关系进行传递，只要u能胜v，那么我们就将d[u][v]设为1，最后如果两者之间有d[u][v]=1或d[v][u]且二者不能同时出现时ans++。

代码实现如下：

 #include <set>
 #include <map>
 #include <queue>
 #include <stack>
 #include <cmath>
 #include <bitset>
 #include <cstdio>
 #include <string>
 #include <vector>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std;

 typedef long long ll;
 typedef pair<ll, ll> pll;
 typedef pair<int, ll> pil;;
 typedef pair<int, int> pii;
 typedef unsigned long long ull;

 #define lson i<<1
 #define rson i<<1|1
 #define bug printf("*********\n");
 #define FIN freopen("D://code//in.txt", "r", stdin);
 #define debug(x) cout<<"["<<x<<"]" <<endl;
 #define IO ios::sync_with_stdio(false),cin.tie(0);

 const double eps = 1e-;
 const int mod = ;
 const int maxn =  + ;
 const double pi = acos(-);
 const int inf = 0x3f3f3f3f;
 const ll INF = 0x3f3f3f3f3f3f3f;

 int n, m, u, v;
 int relationship[][];

 int main() {
     //FIN;
     scanf("%d%d", &n, &m);
     memset(relationship, , sizeof(relationship));
     for(int i = ; i <= m; i++) {
         scanf("%d%d", &u, &v);
         relationship[u][v] = ;
     }
     for(int k = ; k <= n; k++) {
         for(int i = ; i <= n; i++) {
             for(int j = ; j <= n; j++) {
                 if(relationship[i][k] && relationship[k][j]) {
                     relationship[i][j] = ;
                 }
             }
         }
     }
     int ans = , j;
     for(int i = ; i <= n; i++) {
         for(j = ; j <= n; j++) {
             if(i == j) continue;
             if(relationship[i][j] ==  && relationship[j][i] == ) {
                 break;
             }
         }
         if(j > n) ans++;
     }
     printf("%d\n", ans);
     return ;
 }

Problem 2（POJ1094）

题目链接：http://poj.org/problem?id=1094

题目：

题意：给你n个大写字母，m对大小关系，根据他给的关系推测是否有大小矛盾的情况。如果有矛盾的就输出是在第几组关系时矛盾；如果不矛盾，判断只需要前t对组关系就能推测出他们从小到大的排序；如果没有以上两种情况就输入无法确定。

思路：对于每输入一对关系就跑一次floyd判断一遍，如果能推测出他们的关系，那么就跑一边拓扑排序求出他们从小打到的排序情况；如果有矛盾的关系就直接输出是在第几组关系时矛盾；如果没有以上情况就输出无法确定。

代码实现如下：

 #include <set>
 #include <map>
 #include <queue>
 #include <stack>
 #include <cmath>
 #include <bitset>
 #include <cstdio>
 #include <string>
 #include <vector>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std;

 typedef long long ll;
 typedef pair<ll, ll> pll;
 typedef pair<int, ll> pil;;
 typedef pair<int, int> pii;
 typedef unsigned long long ull;

 #define lson i<<1
 #define rson i<<1|1
 #define bug printf("*********\n");
 #define FIN freopen("D://code//in.txt", "r", stdin);
 #define debug(x) cout<<"["<<x<<"]" <<endl;
 #define IO ios::sync_with_stdio(false),cin.tie(0);

 const double eps = 1e-;
 const int mod = ;
 const int maxn =  + ;
 const double pi = acos(-);
 const int inf = 0x3f3f3f3f;
 const ll INF = 0x3f3f3f3f3f3f3f;

 int n, m, t, flag;
 char s[][];
 int d[][], in[], num[];
 vector<int> G[];

 bool floyd() {
     for(int k = ; k <= n; k++) {
         for(int i = ; i <= n; i++) {
             for(int j = ; j <= n; j++) {
                 if(d[i][k] && d[k][j]) {
                     d[i][j] = ;
                 }
             }
         }
     }
     for(int i = ; i <= n; i++) {
         for(int j = ; j <= n; j++) {
             if(i == j) continue;
             if((d[i][j] && d[j][i]) || (d[i][j] ==  && d[j][i] == )) {
                 return false;
             }
         }
     }
     return true;
 }

 void topsort(int m) {
     t = ;
     for(int i = ; i <= n; i++) {
         G[i].clear();
     }
     memset(in, , sizeof(in));
     for(int i = ; i <= m; i++) {
         int x = s[i][] - 'A' + , y = s[i][] - 'A' + ;
         G[x].push_back(y);
         in[y]++;
     }
     queue<int> q;
     for(int i = ; i <= n; i++) {
         if(in[i] == ) {
             q.push(i);
         }
     }
     while(!q.empty()) {
         int x = q.front(); q.pop();
         num[t++] = x;
         for(int i = ; i < G[x].size(); i++) {
             int v = G[x][i];
             in[v]--;
             if(in[v] == ) {
                 q.push(v);
             }
         }
     }
 }

 int main() {
     //FIN;
     while(~scanf("%d%d", &n, &m)) {
         if(n ==  && m == ) break;
         memset(d, , sizeof(d));
         for(int i = ; i <= m; i++) {
             scanf("%s", s[i]);
         }
         flag = ;
         for(int i = ; i <= m; i++) {
             int x = s[i][] - 'A' + , y = s[i][] - 'A' + ;
             d[x][y] = ;
             if(floyd()) {
                 printf("Sorted sequence determined after %d relations: ", i);
                 topsort(i);
                 for(int i = ; i < t; i++) {
                     printf("%c", num[i] -  + 'A');
                 }
                 printf(".\n");
                 flag = ;
             } else {
                 for(int j = ; j <= n; j++) {
                     for(int k = ; k <= n; k++) {
                         if(j == k) continue;
                         if((d[j][k] && d[k][j])) {
                             printf("Inconsistency found after %d relations.\n", i);
                             flag = ;
                             break;
                         }
                     }
                     if(flag) break;
                 }
             }
             if(flag) break;
         }
         if(!flag) printf("Sorted sequence cannot be determined.\n");
     }
     return ;
 }