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;

}