51Nod-1562-玻璃切割

ACM模版

描述

题解

这是一道 CF 的题，很明显我们需要求得是横向纵向每个状态下的最大值，然后相乘即为结果，这个题运气好的话有两种解法儿，运气不好的话，我就知道一种。

因为51时限比较严格，不仅卡了 IO，还卡了运气，第一种办法用 set 集合（代码 One）搞搞，但是不幸的是，总是有一组超时，评论区有一个大神说他多提交几次迷之闪过，我想，大概他用的就是这个方法，而我却没有那么好的人品，提交了七八次，时而一组超时、时而两组超时（在 CF 上应该是可以 AC 的），真是不幸啊，所以只好寻求第二种方法，终于在网上找到了一种解法儿，并查集（代码 Two）。

如果选择并查集搞搞事情，那么我们需要先将所有的切割线加入并查集中（实际上，是把切割线剔除，把其他加入并查集），这时，刚好是最后一个结果的状态，然后我们可以开始逆序逐条删除切割线（实际上，是把剔除的切割线逆序重新加入并查集），对应每一个状态存一下结果，然后正序输出即可了！

这里两种代码均提供一下，作为一个参考。

代码

One:

//  TLE 一组 or 两组 存在很大运气成分
//#include <iostream>
//#include <stdio.h>
//#include <set>
//
//using namespace std;
//
//inline void scan_d(int &ret)
//{
//    char c;
//    ret = 0;
//    while ((c = getchar()) < '0' || c > '9');
//    while (c >= '0' && c <= '9')
//    {
//        ret = ret * 10 + (c - '0'), c = getchar();
//    }
//}
//
//set<int> W, H;
//set<int>::iterator it;
//multiset<int> WL, HL;
//multiset<int>::iterator it_;
//
//int main(int argc, const char * argv[])
//{
////        freopen("/Users/zyj/Desktop/input.txt", "r", stdin);
//    
//    int w, h, n;
//    cin >> w >> h >> n;
//    W.insert(0);
//    W.insert(w);
//    
//    H.insert(0);
//    H.insert(h);
//    
//    WL.insert(w);
//    HL.insert(h);
//    
//    char S[3];
//    int tag;
//    
//    while (n--)
//    {
//        scanf("%s", S);
//        scan_d(tag);
//        if (S[0] == 'V')
//        {
//            W.insert(tag);
//            
//            it = W.find(tag);
//            int right = (* ++it);
//            it--;
//            int left = (* --it);
//            it_ = WL.find(right - left);
//            WL.erase(it_);
//            WL.insert(right - tag);
//            WL.insert(tag - left);
//        }
//        else
//        {
//            H.insert(tag);
//            
//            it = H.find(tag);
//            int right = (* ++it);
//            it--;
//            int left = (* --it);
//            it_ = HL.find(right - left);
//            HL.erase(it_);
//            HL.insert(right - tag);
//            HL.insert(tag - left);
//        }
//        
//        it_ = WL.end();
//        long long resW = (* --it_);
//        it_ = HL.end();
//        long long resH = (* --it_);
//        
//        printf("%lld\n", resW * resH);
//    }
//    
//    return 0;
//}

Two:

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int MAXN = 2e5 + 10;

int maxW, maxH;
int preW[MAXN], preH[MAXN];
int rankW[MAXN], rankH[MAXN];
int visW[MAXN], visH[MAXN];

int w, h, n;

char opt[3];
int op[MAXN];
int num[MAXN];
long long ans[MAXN];

inline void scan_d(int &ret)
{
    char c;
    ret = 0;
    while ((c = getchar()) < '0' || c > '9');
    while (c >= '0' && c <= '9')
    {
        ret = ret * 10 + (c - '0'), c = getchar();
    }
}

int findW(int x)
{
    if (preW[x] != x)
    {
        preW[x] = findW(preW[x]);
    }
    return preW[x];
}

void joinW(int x, int y)
{
    x = findW(x);
    y = findW(y);

    if (x == y)
    {
        return ;
    }

    preW[y] = x;
    rankW[x] += rankW[y];
    maxW = max(rankW[x], maxW);
}

int findH(int x)
{
    if (preH[x] != x)
    {
        preH[x] = findH(preH[x]);
    }
    return preH[x];
}

void joinH(int x, int y)
{
    x = findH(x);
    y = findH(y);

    if (x == y)
    {
        return ;
    }

    preH[y] = x;
    rankH[x] += rankH[y];

    maxH = max(rankH[x], maxH);
}

void init()
{
    for (int i = 0; i <= w; i++)
    {
        preW[i] = i;
        rankW[i] = 1;
    }
    for (int i = 0; i <= h; i++)
    {
        preH[i] = i;
        rankH[i] = 1;
    }
    memset(visW, 0, sizeof(visW));
    memset(visH, 0, sizeof(visH));
    memset(op, 0, sizeof(op));
}

int main()
{
    cin >> w >> h >> n;

    init();

    rankW[0] = rankH[0] = 0;

    for (int i = 0; i < n; i++)
    {
        scanf("%s", opt);
        scan_d(num[i]);

        if (opt[0] == 'H')
        {
            op[i] = 1;
            visH[num[i]] = 1;
        }
        else
        {
            visW[num[i]] = 1;
        }
    }

    maxH = 1;
    maxW = 1;

    for (int i = 1; i < w; i++)
    {
        if (!visW[i])
        {
            joinW(i, i + 1);
        }
    }

    for (int i = 1; i < h; i++)
    {
        if (!visH[i])
        {
            joinH(i, i + 1);
        }
    }

    for (int i = n - 1; i >= 0; i--)
    {
        ans[i] = (long long)(maxH) * (maxW);

        if (op[i])
        {
            joinH(num[i], num[i] + 1);
        }
        else
        {
            joinW(num[i], num[i] + 1);
        }
    }


    for (int i = 0; i < n; i++)
    {  
        printf("%lld\n", ans[i]);
    }  

    return 0;  
}