HDU 3957 Street Fighter （最小支配集 DLX 重复覆盖+精确覆盖 ）

DLX经典题型，被虐惨了……

建一个2*N行3*N列的矩阵，行代表选择，列代表约束。前2*N列代表每个人的哪种状态，后N列保证每个人至多选一次。

显然对手可以被战胜多次（重复覆盖），每个角色至多选择一次（精确覆盖）。

注意事项：

1.行数=∑每个人的模式数，之前我直接把行数当2*N了……但实际上也会有人只有一种模式的，也就是说实际行数小于等于2*N

2.建图的时候注意：这个人不光能覆盖他所战胜的某角色的某模式，还覆盖了他自己的所有模式（因为他不用战胜自己）。之前没注意这个问题，样例全成无解了orz……

3.处理精确覆盖和重复覆盖的先后顺序。如果优先处理精确覆盖，会把重复覆盖的一些行也删掉，这样前面可以重复覆盖的很多列也被当成了精确覆盖，显然不对了。所以应当先处理重复覆盖。恢复的时候遵循先删除的后恢复，后删除的先恢复。

4.只要满足重复覆盖的条件即为一个可行解。

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>

using namespace std;

const int MAXN = 50;
const int INF = 1 << 30;

int N;
int U[ (2*MAXN)*(3*MAXN) ], D[ (2*MAXN)*(3*MAXN) ];
int L[ (2*MAXN)*(3*MAXN) ], R[ (2*MAXN)*(3*MAXN) ];
int C[ (2*MAXN)*(3*MAXN) ];
int cnt[ 3*MAXN ];
bool mx[ 2*MAXN ][ 3*MAXN ];
bool vis[ 3*MAXN ];
bool vs[MAXN][2][MAXN][2];   //i的x模式能打败j的y模式
int modelN[MAXN];            //i有几个模式
int sum[MAXN];
int head;
int maxr, maxc;

void Remove( int c )    //重复覆盖删除列
{
for ( int i = D[c]; i != c; i = D[i] )
{
R[ L[i] ] = R[i];
L[ R[i] ] = L[i];
}
return;
}

void Resume( int c )    //重复覆盖恢复列
{
for ( int i = D[c]; i != c; i = D[i] )
{
R[ L[i] ] = i;
L[ R[i] ] = i;
}
return;
}

void ExRemove( int c )    //精确覆盖删除列+行
{
int i, j;
L[ R[c] ] = L[c];
R[ L[c] ] = R[c];
for ( i = D[c]; i != c; i = D[i] )
{
for ( j = R[i]; j != i; j = R[j] )
{
U[ D[j] ] = U[j];
D[ U[j] ] = D[j];
--cnt[ C[j] ];
}
}
return;
}

void ExResume( int c )      //精确覆盖恢复列+行
{
int i, j;
R[ L[c] ] = c;
L[ R[c] ] = c;
for ( i = D[c]; i != c; i = D[i] )
{
for ( j = R[i]; j != i; j = R[j] )
{
U[ D[j] ] = j;
D[ U[j] ] = j;
++cnt[ C[j] ];
}
}
return;
}

bool build()
{
head = 0;
for ( int i = 0; i < maxc; ++i )
{
R[i] = i + 1;
L[i + 1] = i;
}
R[maxc] = 0;
L[0] = maxc;

//列链表
for ( int j = 1; j <= maxc; ++j )
{
int pre = j;
cnt[j] = 0;
for ( int i = 1; i <= maxr; ++i )
{
if ( mx[i][j] )
{
++cnt[j];
int cur = i * maxc + j;
U[cur] = pre;
D[pre] = cur;
C[cur] = j;
pre = cur;
}
}
U[j] = pre;
D[pre] = j;
//if ( !cnt[j] ) return false;
}

//行链表
for ( int i = 1; i <= maxr; ++i )
{
int pre = -1, first = -1;
for ( int j = 1; j <= maxc; ++j )
{
if ( mx[i][j] )
{
int cur = i * maxc + j;
if ( pre == -1 ) first = cur;
else
{
L[cur] = pre;
R[pre] = cur;
}
pre = cur;
}
}
if ( first != -1 )
{
R[pre] = first;
L[first] = pre;
}
}

return true;
}

/****************以上DLX模板****************/

//估价函数：至少还要选几个人
int h()
{
memset( vis, false, sizeof(vis) );
int res = 0;
for ( int c = R[head]; c <= maxr && c != head; c = R[c] )
{
if ( !vis[c] )
{
++res;
vis[c] = true;
for ( int i = D[c]; i != c; i = D[i] )
for ( int j = R[i]; j != i; j = R[j] )
vis[ C[j] ] = true;
}
}
return res;
}

bool DFS( int dep, int limit )
{
//A-star剪枝
if ( dep + h() > limit ) return false;

//只要前面满足重复覆盖的条件，即为可行解
if ( R[head] > maxr || R[head] == head ) return true;

int c, minv = INF;
for ( int i = R[head]; i <= maxr && i != head; i = R[i] )
{
if ( cnt[i] < minv )
{
minv = cnt[i];
c = i;
}
}

for ( int i = D[c]; i != c; i = D[i] )
{
Remove(i);
//注意处理重复覆盖和精确覆盖的顺序
for ( int j = R[i]; j != i; j = R[j] )
if ( C[j] <= maxr ) Remove(j);

for ( int j = R[i]; j != i; j = R[j] )
if ( C[j] > maxr ) ExRemove( C[j] );

if ( DFS( dep + 1, limit ) )
{
//注意恢复精确覆盖和重复覆盖的顺序，这样恢复之后可以不必重新建图
for ( int j = R[i]; j != i; j = R[j] )
if ( C[j] > maxr ) ExResume( C[j] );

for ( int j = R[i]; j != i; j = R[j] )
if ( C[j] <= maxr ) Resume(j);

Resume(i);  //之前忘了恢复i，死活TLE
return true;
}

for ( int j = R[i]; j != i; j = R[j] )
if ( C[j] > maxr ) ExResume( C[j] );
for ( int j = R[i]; j != i; j = R[j] )
if ( C[j] <= maxr ) Resume(j);
Resume(i);
}

return false;
}

int solved()
{
int l = 0, r = N;
int ans;

while ( l <= r )
{
int mid = ( l + r ) >> 1;
if ( DFS( 0, mid ) )
{
r = mid - 1;
ans = mid;
}
else l = mid + 1;
}

return ans;
}

void show()
{
for ( int i = 0; i <= maxr; ++i )
{
for ( int j = 0; j <= maxc; ++j )
printf( "%d", mx[i][j] );
puts("");
}
}

void init()
{
memset( mx, false, sizeof(mx) );

for( int i = 0; i < N; ++i )
{
for ( int x = 0; x < modelN[i]; ++x )
{
mx[ sum[i] + x ][ maxr + i + 1 ] = true;
mx[ sum[i] + x ][ sum[i] ] = true;
if ( modelN[i] > 1 )
{
mx[ sum[i] + x ][ sum[i] + 1 ] = true;
}
for ( int j = 0; j < N; ++j )
{
for ( int y = 0; y < modelN[j]; ++y )
{
if ( vs[i][x][j][y] )
{
mx[ sum[i] + x ][ sum[j] + y ] = true;
}
}
}
}
}

//show();
return;
}

int main()
{
//freopen( "in.txt", "r", stdin );
//freopen( "out.txt", "w", stdout );
int T, cas = 0;
scanf( "%d", &T );
while ( T-- )
{
memset( vs, false, sizeof(vs) );
scanf( "%d", &N );
maxr = 0;

for ( int i = 0; i < N; ++i )
{
scanf( "%d", &modelN[i] );
sum[i] = maxr + 1;
for ( int j = 0; j < modelN[i]; ++j )
{
++maxr;
int K;
scanf( "%d", &K );
for ( int k = 0; k < K; ++k )
{
int id, mode;
scanf( "%d%d", &id, &mode );
vs[i][j][id][mode] = true;
}
}
}

maxc = maxr + N;
init();
build();
printf("Case %d: %d\n", ++cas, solved() );
}
return 0;
}