HDU 4265

比赛的时候队友说这道题很像Dancing Link，但方案数太多，不能处理好方案间冲突的问题，我简单想了下网络流，方案数容易解决，但具体的方案始终很难处理，于是就放弃了。赛后得知居然真的可以用网络流解决，于是开始纠结。

          

        言归正传，先确定方案总数，二分一个mid值（方案数），如下构图：s向n个人分别连接一条容量为mid的边，n个坐位（题目中是button）分别向t连接一条容量也为mid的边，根据'Y' or 'N'，每个人向对应的坐位连接一条容量为1的边。显然如果s -> t的最大流为n*mid，则至少存在mid种合法方案（为什么合法？请仔细想想容量为mid的那些边的具体含义）

        既然上述二分出来的mid就是合法方案数，那么合法方案必定就在残留网络里，遍历残留网络中的每条边后就能得知每个人能坐的那些位置，因为残留网络保证了“每个人能分别坐到mid个不同位置，每个位置能被mid个不同的人坐”，所以从中随意构造合法的方案，必定能构造出mid组合法方案（如果觉得前面几次的随意构造可能会导致后来无法再构造合法方案，可以尝试重新理解双引号里的话的含义，这是难点所在）。

         至于每次随意构造合法方案，回溯会TLE。考虑第一段中构造的网络，如果mid = 1，每次求最大流后的残留网络就是一种方案，不过要注意：1）这次构造的网络要将第二段中“残留网络流量没发生变化的边删掉”，因为这些是错误的选择，之前所做的一切都是为了找出这些“错误的边”，在这里终于删除掉了。。。2）每次求完最大流，要将流量发生变化的边删掉。

       这题有个地方坑了我很久。。。输出方案时有两种形式：第i个人坐第ans[i]位置、第i个位置给第ans[i]个人坐。事实证明是第二种理解方式（虽然output有简单说明，可我一直没看清楚，最后还是试出来的）。这解题报告的描述感觉很别扭，本来网络流的描述就不容易，再加上这题要反反复复构图、求最大流，而且目的和含义都略有不同，见谅，下面是代码：

/****************************************************************
    Problem: HDU 4265
    User: Jeflie
    Language: C++
    Result: Accepted
    Time: 234 ms
    Memory: 528 k
****************************************************************/
 
#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;
const int INF = 1e9;
const int N = 200;
 
struct Data
{
    int x, y, f, next;
} edge[100*N];
int inx;
int node[N], level[N];
 
void addedge(int u, int v, int f)
{
    //cout<<u<<" "<<v<<" "<<f<<endl;
    edge[inx].x = u, edge[inx].y = v, edge[inx].f = f;
    edge[inx].next = node[u], node[u] = inx++;
    edge[inx].x = v, edge[inx].y = u, edge[inx].f = 0;
    edge[inx].next = node[v], node[v] = inx++;
}
 
bool BFS(int s, int e)
{
    memset(level, -1, sizeof(level));
    queue<int> que;
    que.push(s); level[s] = 0;
    while ( !que.empty() )
    {
        int u = que.front(); que.pop();
        for (int ip = node[u]; ip != -1; ip = edge[ip].next)
        {
            Data &v = edge[ip];
            if (v.f > 0 && level[v.y] == -1)
            {
                level[v.y] = level[u] + 1;
                que.push(v.y);
                if (e == v.y) return 1;
            }
        }
    }
    return 0;
}
 
int DFS(int e, int u, int flow)
{
    if (e == u) return flow;
    int sum = 0;
    for (int ip = node[u]; ip != -1 && sum < flow; ip = edge[ip].next)
    {
        Data &v = edge[ip];
        if (level[v.y] == level[u]+1 && v.f > 0)
        {
            int tmp = DFS(e, v.y, min(v.f, flow - sum));
            edge[ip].f -= tmp;
            edge[ip^1].f += tmp;
            sum += tmp;
        }
    }
    if (!sum) level[u] = -1;
    return sum;
}
 
int Dinic(int s, int e)
{
    int flow = 0;
    while (BFS(s, e))
        flow += DFS(e, s, INF);
    return flow;
}
 
 
char sit[100][100];
 
void Graph(int n, int s, int t, int mid)
{
    inx = 0;
    memset(node, -1, sizeof(node));
    for (int i = 1; i <= n; i++)
    {
        addedge(s, i, mid);
        addedge(n+i, t, mid);
    }
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            if (sit[i-1][j-1] == 'Y')
                addedge(i, n+j, 1);
}
 
void Delete(int n, int s, int t, int ch)
{
    for (int i = 1; i <= n; i++)
        for (int ip = node[i]; ip != -1; ip = edge[ip].next)
            if (edge[ip].f == ch && edge[ip].y != s)
                sit[i-1][edge[ip].y-n-1] = 'N';
}
 
int main()
{
    int n;
    while (cin>>n)
    {
        if (n == 0) break;
        for (int i = 0; i < n; i++)
            cin>>sit[i];
 
        int low = 0, high = 100;
        int s = 0, t = 2*n + 1;
        while (low <= high)
        {
            int mid = (low + high) >> 1;
            Graph(n, s, t, mid);
            if (Dinic(s, t) == n * mid)
                low = mid + 1;
            else
                high = mid - 1;
        }
 
        Graph(n, s, t, high);
        Dinic(s, t);
        Delete(n, s, t, 1);       // 删除没流过的边
 
        cout<<high<<endl;
        while (high--)
        {
            Graph(n, s, t, 1);    // 每次从残留网络提取一种方案
            Dinic(s, t);
            int ans[100];
            for (int i = 1; i <= n; i++)
                for (int ip = node[i]; ip != -1; ip = edge[ip].next)
                    if (edge[ip].f == 0 && edge[ip].y != s)
                        ans[edge[ip].y-n] = i;
 
            for (int i = 1; i < n; i++)
                cout<<ans[i]<<" "; cout<<ans[n]<<endl;
 
            Delete(n, s, t, 0);   // 删除流过的边
        }
    }
    return 0;
}