Codeforces 200A Cinema 并查集 + 思维 (看题解)

Cinema

感觉这个题好神啊。。。

首先如果 n 比 m 大， 我们先旋转90度。

我们要加入一个(x, y)的时候， 我们枚举答案所在的行离 x 的距离 g ， 然后对于x + g 行来说

我们找到(x + g, y)左边的第一个和右边的第一个未被占的位置，更新答案， 如果 g > 答案 退出。

左边和右边第一个未被占的可以用并查集维护， 把连续占了的并成一个联通块， 维护最小值和最大值。

对于 2000 * 2000的图来说， 对于每一次， 最多sqrt( n )就能找到答案， 因为最坏情况下所有点都在一个点， 

最后的图是sqrt(n) * sqrt(n)的矩形。

#include<bits/stdc++.h>
#define LL long long
#define LD long double
#define ull unsigned long long
#define fi first
#define se second
#define mk make_pair
#define PLL pair<LL, LL>
#define PLI pair<LL, int>
#define PII pair<int, int>
#define SZ(x) ((int)x.size())
#define ALL(x) (x).begin(), (x).end()
#define fio ios::sync_with_stdio(false); cin.tie(0);

using namespace std;

const int N = 2000 + 7;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-8;
const double PI = acos(-1);

template<class T, class S> inline void add(T& a, S b) {a += b; if(a >= mod) a -= mod;}
template<class T, class S> inline void sub(T& a, S b) {a -= b; if(a < 0) a += mod;}
template<class T, class S> inline bool chkmax(T& a, S b) {return a < b ? a = b, true : false;}
template<class T, class S> inline bool chkmin(T& a, S b) {return a > b ? a = b, true : false;}


struct DSU {
    int fa[N], L[N], R[N];
    bool used[N];
    void init() {
        for(int i = 0; i < N; i++) {
            fa[i] = i;
            L[i] = i;
            R[i] = i;
        }
    }
    int getRoot(int x) {
        return fa[x] == x ? x : fa[x] = getRoot(fa[x]);
    }
    void Merge(int u, int v) {
        int x = getRoot(u);
        int y = getRoot(v);
        chkmin(L[x], L[y]);
        chkmax(R[x], R[y]);
        fa[y] = x;
    }
} dsu[N];

int n, m, k;

int main() {
    scanf("%d%d%d", &n, &m, &k);
    if(n <= m) {
        for(int i = 1; i <= n; i++) dsu[i].init();
        while(k--) {
            pair<int, PII> ans = mk(inf, mk(inf, inf));
            int x, y; scanf("%d%d", &x, &y);
            for(int g = 0; g <= ans.fi; g++) {
                if(x + g <= n) {
                    if(!dsu[x + g].used[y]) {
                        chkmin(ans, mk(g, mk(x + g, y)));
                    } else {
                        int Rt = dsu[x + g].getRoot(y);
                        pair<int, PII> retL = mk(inf, mk(inf, inf));
                        pair<int, PII> retR = mk(inf, mk(inf, inf));
                        if(dsu[x + g].L[Rt] - 1 > 0) retL = mk(g + y - dsu[x + g].L[Rt] + 1, mk(x + g, dsu[x + g].L[Rt] - 1));
                        if(dsu[x + g].R[Rt] + 1 <= m) retR = mk(g + dsu[x + g].R[Rt] + 1 - y, mk(x + g, dsu[x + g].R[Rt] + 1));
                        chkmin(ans, retL);
                        chkmin(ans, retR);
                    }
                }
                if(x - g >= 1) {
                    if(!dsu[x - g].used[y]) {
                        chkmin(ans, mk(g, mk(x - g, y)));
                    } else {
                        int Rt = dsu[x - g].getRoot(y);
                        pair<int, PII> retL = mk(inf, mk(inf, inf));
                        pair<int, PII> retR = mk(inf, mk(inf, inf));
                        if(dsu[x - g].L[Rt] - 1 > 0) retL = mk(g + y - dsu[x - g].L[Rt] + 1, mk(x - g, dsu[x - g].L[Rt] - 1));
                        if(dsu[x - g].R[Rt] + 1 <= m) retR = mk(g + dsu[x - g].R[Rt] + 1 - y, mk(x - g, dsu[x - g].R[Rt] + 1));
                        chkmin(ans, retL);
                        chkmin(ans, retR);
                    }
                }
            }
            if(dsu[ans.se.fi].used[ans.se.se - 1]) dsu[ans.se.fi].Merge(ans.se.se, ans.se.se - 1);
            if(dsu[ans.se.fi].used[ans.se.se + 1]) dsu[ans.se.fi].Merge(ans.se.se, ans.se.se + 1);
            dsu[ans.se.fi].used[ans.se.se] = true;
            printf("%d %d
", ans.se.fi, ans.se.se);
        }
    } else {
        for(int i = 1; i <= m; i++) dsu[i].init();
        while(k--) {
            pair<int, PII> ans = mk(inf, mk(inf, inf));
            int x, y; scanf("%d%d", &x, &y);
            for(int g = 0; g <= ans.fi; g++) {
                if(y + g <= m) {
                    if(!dsu[y + g].used[x]) {
                        chkmin(ans, mk(g, mk(x, y + g)));
                    } else {
                        int Rt = dsu[y + g].getRoot(x);
                        pair<int, PII> retL = mk(inf, mk(inf, inf));
                        pair<int, PII> retR = mk(inf, mk(inf, inf));
                        if(dsu[y + g].L[Rt] - 1 > 0) retL = mk(g + x - dsu[y + g].L[Rt] + 1, mk(dsu[y + g].L[Rt] - 1, y + g));
                        if(dsu[y + g].R[Rt] + 1 <= n) retR = mk(g + dsu[y + g].R[Rt] + 1 - x, mk(dsu[y + g].R[Rt] + 1, y + g));
                        chkmin(ans, retL);
                        chkmin(ans, retR);
                    }
                }
                if(y - g >= 1) {
                    if(!dsu[y - g].used[x]) {
                        chkmin(ans, mk(g, mk(x, y - g)));
                    } else {
                        int Rt = dsu[y - g].getRoot(x);
                        pair<int, PII> retL = mk(inf, mk(inf, inf));
                        pair<int, PII> retR = mk(inf, mk(inf, inf));
                        if(dsu[y - g].L[Rt] - 1 > 0) retL = mk(g + x - dsu[y - g].L[Rt] + 1, mk(dsu[y - g].L[Rt] - 1, y - g));
                        if(dsu[y - g].R[Rt] + 1 <= n) retR = mk(g + dsu[y - g].R[Rt] + 1 - x, mk(dsu[y - g].R[Rt] + 1, y - g));
                        chkmin(ans, retL);
                        chkmin(ans, retR);
                    }
                }
            }
            if(dsu[ans.se.se].used[ans.se.fi - 1]) dsu[ans.se.se].Merge(ans.se.fi, ans.se.fi - 1);
            if(dsu[ans.se.se].used[ans.se.fi + 1]) dsu[ans.se.se].Merge(ans.se.fi, ans.se.fi + 1);
            dsu[ans.se.se].used[ans.se.fi] = true;
            printf("%d %d
", ans.se.fi, ans.se.se);
        }
    }
    return 0;
}

/*
*/