ECNUOJ 2575 Separate Connections

Separate Connections

Time Limit:5000MS Memory Limit:65536KB
Total Submit:421 Accepted:41

Description 

Partychen are analyzing a communications network with at most 18 nodes. Character in a matrix i,j (i,j both 0-based,as matrix[i][j]) denotes whether nodes i and j can communicate ('Y' for yes, 'N' for no). Assuming a node cannot communicate with two nodes at once, return the maximum number of nodes that can communicate simultaneously. If node i is communicating with node j then node j is communicating with node i.

Input 

The first line of input gives the number of cases, N(1 ≤ N ≤ 100). N test cases follow.
In each test case,the first line is the number of nodes M(1 ≤ M ≤ 18),then there are a grid by M*M describled the matrix.

Output 

For each test case , output the maximum number of nodes that can communicate simultaneously

Sample Input 

2
5
NYYYY
YNNNN
YNNNN
YNNNN
YNNNN
5
NYYYY
YNNNN
YNNNY
YNNNY
YNYYN

Sample Output 

2
4
Hint
The first test case: 
All communications must occur with node 0. Since node 0 can only communicate with 1 node at a time, the output value is 2.
The second test case: 
In this setup, we can let node 0 communicate with node 1, and node 3 communicate with node 4.

Source

解题：逼格很高啊！带花树模板题，可惜本人不会敲，只好找了份模板

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <queue>
 using namespace std;
 const int N = ;
 int belong[N];
 int findb(int x) {
     return belong[x] == x ? x : belong[x] = findb(belong[x]);
 }
 void unit(int a, int b) {
     a = findb(a);
     b = findb(b);
     if (a != b) belong[a] = b;
 }

 int n, match[N];
 vector<int> e[N];
 int Q[N], rear;
 int nxt[N], mark[N], vis[N];
 int LCA(int x, int y) {
     static int t = ;
     t++;
     while (true) {
         if (x != -) {
             x = findb(x);
             if (vis[x] == t) return x;
             vis[x] = t;
             if (match[x] != -) x = nxt[match[x]];
             else x = -;
         }
         swap(x, y);
     }
 }

 void group(int a, int p) {
     while (a != p) {
         int b = match[a], c = nxt[b];
         if (findb(c) != p) nxt[c] = b;
         if (mark[b] == ) mark[Q[rear++] = b] = ;
         if (mark[c] == ) mark[Q[rear++] = c] = ;

         unit(a, b);
         unit(b, c);
         a = c;
     }
 }

 // 增广
 void aug(int s) {
     for (int i = ; i < n; i++) // 每个阶段都要重新标记
         nxt[i] = -, belong[i] = i, mark[i] = , vis[i] = -;
     mark[s] = ;
     Q[] = s;
     rear = ;
     for (int front = ; match[s] == - && front < rear; front++) {
         int x = Q[front]; // 队列Q中的点都是S型的
         for (int i = ; i < (int)e[x].size(); i++) {
             int y = e[x][i];
             if (match[x] == y) continue; // x与y已匹配，忽略
             if (findb(x) == findb(y)) continue; // x与y同在一朵花，忽略
             if (mark[y] == ) continue; // y是T型点，忽略
             if (mark[y] == ) { // y是S型点，奇环缩点
                 int r = LCA(x, y); // r为从i和j到s的路径上的第一个公共节点
                 if (findb(x) != r) nxt[x] = y; // r和x不在同一个花朵，nxt标记花朵内路径
                 if (findb(y) != r) nxt[y] = x; // r和y不在同一个花朵，nxt标记花朵内路径

                 // 将整个r -- x - y --- r的奇环缩成点，r作为这个环的标记节点，相当于论文中的超级节点
                 group(x, r); // 缩路径r --- x为点
                 group(y, r); // 缩路径r --- y为点
             } else if (match[y] == -) { // y自由，可以增广，R12规则处理
                 nxt[y] = x;
                 for (int u = y; u != -; ) { // 交叉链取反
                     int v = nxt[u];
                     int mv = match[v];
                     match[v] = u, match[u] = v;
                     u = mv;
                 }
                 break; // 搜索成功，退出循环将进入下一阶段
             } else { // 当前搜索的交叉链+y+match[y]形成新的交叉链，将match[y]加入队列作为待搜节点
                 nxt[y] = x;
                 mark[Q[rear++] = match[y]] = ; // match[y]也是S型的
                 mark[y] = ; // y标记成T型
             }
         }
     }
 }

 bool g[N][N];
 char mp[N][N];
 int main() {
     int kase;
     scanf("%d",&kase);
     while(kase--) {
         scanf("%d", &n);
         for (int i = ; i < n; i++)
             for (int j = ; j < n; j++) g[i][j] = false;
         for(int i = ; i < n; ++i) e[i].clear();
         for(int i = ; i < n; ++i){
             scanf("%s",mp[i]);
             for(int j = ; j < n; ++j){
                 if(mp[i][j] == 'Y'){
                     e[i].push_back(j);
                     e[j].push_back(i);
                     g[i][j] = g[j][i] = true;
                 }
             }
         }
         for (int i = ; i < n; i++) match[i] = -;
         for (int i = ; i < n; i++) if (match[i] == -) aug(i);
         int tot = ;
         for (int i = ; i < n; i++) if (match[i] != -) tot++;
         printf("%d\n", tot);
     }
     return ;
 }