比赛的时候队友说这道题很像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;
}