ZOJ 3544 / HDU 4056 Draw a Mess（ 并查集好题 ）

方法参见：http://blog.acmol.com/?p=751

从最后一个线段开始倒着处理（因为之后的线段不会被它之前的线段覆盖），把这条线段所覆盖的所有线段编号合并到一个集合里，并以最左边线段编号为父结点。然后，以后的线段每次都是从右端向左端进行以下处理：

1、判断该线段在并查集中的根结点是否被覆盖过（用一个数组标记），如果没有被覆盖，则将该线段所在集合与海报左端点所在集合进行合并（以左端点所在集合为根）。

2、然后开始处理刚处理过的线段父结点左边的那一个线段，处理方法与第1步时一样。

3、直到要处理的线段在左端点的左边时停止循环。

处理时，如果有一个线段未被覆盖，就证明该点的染色没有被之后的染色覆盖掉。

我头一次知道还有这种搞法，涨姿势了。

PS.之前我觉得Diamond和Circle是弄出来应该是一样的形状，就把它俩当一样处理了，事实证明这是不对的……

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

using namespace std;

const int MAXN = 52222;

struct node
{
    char op[20];
    int xc, yc;
    int l, w, c;
};

int N, M, Q;
node D[MAXN];
int p[MAXN];
bool vis[MAXN];

int find( int x )
{
    return p[x] == x ? x : p[x] = find(p[x]);
}

int main()
{
    while ( scanf( "%d%d%d", &N, &M, &Q ) == 3 )
    {
        for ( int i = 0; i < Q; ++i )
        {
            scanf( "%s%d%d", D[i].op, &D[i].xc, &D[i].yc );
            if ( D[i].op[0] == 'R' )
                scanf("%d%d%d", &D[i].l, &D[i].w, &D[i].c );
            else
                scanf( "%d%d", &D[i].w, &D[i].c );
        }

        int ans[10] = { 0 };
        for ( int i = 0; i < N; ++i )
        {
            for ( int j = 0; j < M; ++j )
            {
                vis[j] = false;
                p[j] = j;
            }
            for ( int j = Q - 1; j >= 0; --j )
            {
                int l, r;
                int color = D[j].c;
                if ( D[j].op[0] == 'R' )
                {
                    if ( i < D[j].xc || i >= D[j].xc + D[j].l ) continue;
                    l = D[j].yc;
                    r = D[j].yc + D[j].w - 1;
                }
                else if ( D[j].op[0] == 'D' )
                {
                    if ( i < D[j].xc - D[j].w || i > D[j].xc + D[j].w ) continue;
                    l = D[j].yc - ( D[j].w - abs( i - D[j].xc ) );
                    r = D[j].yc + ( D[j].w - abs( i - D[j].xc ) );
                }
                else if ( D[j].op[0] == 'C' )
                {
                    if ( ( i - D[j].xc )*( i - D[j].xc ) > D[j].w*D[j].w ) continue;
                    int ww = (int)( sqrt( ( double)(D[j].w*D[j].w - ( i - D[j].xc )*( i - D[j].xc ) ) ) + 1e-8 );
                    l = D[j].yc - ww;
                    r = D[j].yc + ww;
                }
                else
                {
                    if ( i < D[j].xc || i > D[j].xc + (D[j].w+1)/2 - 1 ) continue;
                    int ww = D[j].w - 2*( i - D[j].xc );
                    l = D[j].yc - ww / 2;
                    r = D[j].yc + ww / 2;
                }

                l = max( 0, l );
                r = min( M - 1, r );

                int xx = find(l);
                int yy;
                for ( int k = r; k >= l; k = yy - 1 )
                {
                    yy = find(k);
                    if ( !vis[yy] ) ++ans[color];
                    vis[yy] = true;
                    if ( xx != yy ) p[yy] = xx;
                }
            }
        }

        for ( int i = 1; i <= 9; ++i )
        {
            if ( i != 1 ) putchar(' ');
            printf( "%d", ans[i] );
        }
        puts("");
    }
    return 0;
}

之前线段树也能做，只不过效率和代码长度都比较惊悚。

ZOJ上因为内存给的比较宽松，以前线段树可以AC，但是现在好像把数据加强了，线段树一定TLE……

HDU一定MLE……

附：线段树代码，TLE

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

#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
#define lc rt << 1
#define rc rt << 1 | 1

const int MAXN = 52222;

int N, M, Q;
short tree[201][ MAXN << 2 ];
char op[20];
int ans[10];

inline int max( int a, int b )
{
    return a > b ? a : b;
}

inline int min( int a, int b )
{
    return a < b ? a : b;
}

inline int abs( int a )
{
    return a >= 0 ? a : -a;
}

inline void update( short *color, int L, int R, short val, int l, int r, int rt )
{
    if ( L <= l && r <= R )
    {
        color[rt] = val;
        return;
    }
    //if ( l >= r ) return;

    if ( color[rt] )
    {
        color[lc] = color[rc] = color[rt];
        color[rt] = 0;
    }

    int m = ( l + r ) >> 1;
    if ( L <= m ) update( color, L, R, val, lson );
    if ( R > m )  update( color, L, R, val, rson );

    //if ( color[lc] == color[rc] ) color[rt] = color[lc];
    return;
}

inline void query( short *color, int l, int r, int rt )
{
    if ( color[rt] != 0 )
    {
        //printf("[%d %d]: %d
", l, r, color[rt] );
        ans[ color[rt] ] += r - l + 1;
        return;
    }
    if ( l >= r ) return;
    int m = ( l + r ) >> 1;
    query( color, lson );
    query( color, rson );
    return;
}

int main()
{
    while ( scanf( "%d%d%d", &N, &M, &Q ) == 3 )
    {
        for ( int i = 0; i < N; ++i )
            memset( tree[i], 0, sizeof(short)*(( N << 2 ) + 4) );

        while ( Q-- )
        {
            scanf( "%s", op );
            if ( op[0] == 'D' || op[0] == 'C' )
            {
                int xc, yc, r, c;
                scanf("%d%d%d%d", &xc, &yc, &r, &c);
                int stX = max( 0, xc - r );
                int edX = min( N - 1, xc + r );
                //printf( "stX=%d edX=%d
", stX, edX );
                if ( r == 0 )
                {
                    update( tree[xc], yc, yc, c, 0, M - 1, 1 );
                    continue;
                }

                for ( int i = stX; i <= edX; ++i )
                {
                    int stY = max( 0, yc - ( r - abs( i - xc ) ) );
                    int edY = min( M - 1, yc + ( r - abs(i - xc) ) );
                    //printf("**%d %d
", stY, edY );
                    update( tree[i], stY, edY, c, 0, M - 1, 1 );
                }
            }
            else if ( op[0] == 'T' )
            {
                int xc, yc, w, c;
                scanf( "%d%d%d%d", &xc, &yc, &w, &c );
                int stx = xc, sty = yc;
                int limitX = min( N - 1, xc + (w+1)/2 - 1 );
                //printf( "T: %d %d
", xc, limitX );
                for ( int i = stx; i <= limitX && w >= 0; ++i )
                {
                    update( tree[i], max( sty - w/2, 0 ), min( sty + w/2, M - 1 ), c, 0, M - 1, 1 );
                    w -= 2;
                    if ( w < 0 ) break;
                }
            }
            else if ( op[0] == 'R' )
            {
                int xc, yc, l, w, c;
                scanf( "%d%d%d%d%d", &xc, &yc, &l, &w, &c );
                if ( l == 0 || w == 0 ) continue;
                int limitX = min( xc + l - 1, N - 1 );
                int limitY = min( yc + w - 1, M - 1 );
                //printf("R: %d %d %d %d
", xc, limitX, yc, limitY );
                for ( int i = xc; i <= limitX; ++i )
                    update( tree[i], yc, limitY, c, 0, M - 1, 1 );
            }
        }

        memset( ans, 0, sizeof(ans) );
        for ( int j = 0; j < N; ++j )
            query( tree[j], 0, M - 1, 1 );

        bool first = false;
        for ( int i = 1; i <= 9; ++i )
        {
            if ( first ) putchar(' ');
            printf( "%d", ans[i] );
            first = true;
        }
        puts("");
    }
    return 0;
}