Solution -「POI 2013」LAB-Maze

$\mathscr{Description}$

  Link.

  构造一个边平行与坐标轴, 顶点是整点, 相邻边互相垂直, 且逆时针遍历顶点时转向 (向左或向右) 符合给定字符串的不自交多边形.

  顶点数 $n\le10^5$.

$\mathscr{Solution}$

  设 $L$ 为左转数, $R$ 为右转数, 显然, 有解的必要条件是 $L-R=4$, 不然不可能逆时针转回起点.

  接下来, 注意到相邻的一对 LR 或者 RL 一定体现为一个 "Z" 字形, 并不影响边的走向. 因此, 可以尝试通过不断去除这样的字符对来递归构造多边形.

  研究递归的过程. 递归尽头一定是 LLLL, 此时我们新建一个矩形. 在回溯过程中, 我们要做的工作就是在一条直线中插入一个 "Z", 并合理调整坐标关系. 如图:

  说着很简单, 怎么实现呢?

  对于 LR 对的寻找, 可以用双向连边维护字符串上剩余字符的相邻关系, 然后把所有可能的 LR 和 RL 丢到队列里. 删掉 LR 之后再顺便检查一下新挨在一起的字符是否是 LR 或 RL.

  对于 "合理调整坐标关系", 最好的安排方式自然是把 "Z" 的一竖变得 "很短很短", 短到不可能碰到任何其他边. 当然, 因为坐标需要是整数, 这不太可能. 不过, 我们在构造过程中并不关心一个点的具体坐标, 因而, 可以用两个双向链表维护 $x$ 轴和 $y$ 轴, 每个点的坐标仅仅用指向链表中元素的两个指针描述. 插入坐标通过链表插入 $\mathcal O(1)$ 实现, 由于共用一个坐标的点一定只有两个, 所以也很容易将一个坐标 "分裂" 成两个相近坐标.

  当然, 如果真的要写链表, 就需要精细地去记录当前直线的走向, 否则难以通过迭代器的关系判断左右上下. 一个懒人方法是用 Splay 维护坐标轴, 原理一样, 不过就可以直接用 rank 来描述两个坐标的相对关系啦. 取决于实现方式, 复杂度为 $\mathcal O(n)$ 或者 $\mathcal O(n\log n)$.

$\mathscr{Code}$

/*+Rainybunny+*/

#include <bits/stdc++.h>

#define rep(i, l, r) for (int i = l, rep##i = r; i <= rep##i; ++i)
#define per(i, r, l) for (int i = r, per##i = l; i >= per##i; --i)

const int MAXN = 1e5;
int n, pre[MAXN + 5], suf[MAXN + 5], xid[MAXN + 5], yid[MAXN + 5];
char tur[MAXN + 5];
bool vis[MAXN + 5];
std::queue<int> gap;

struct Splay {
    static const int MAXND = 3e5;
    int node, root, ch[MAXND][2], siz[MAXND], fa[MAXND], lab[MAXND];

    Splay() {
        newnd(), newnd(), root = fa[ch[1][1] = 2] = 1, siz[1] = 2;
    }

    inline int newnd() {
        return siz[++node] = 1, node;
    }

    inline void pushup(const int u) {
        siz[u] = siz[ch[u][0]] + siz[ch[u][1]] + 1;
    }

    inline void rotate(const int u) {
        int v = fa[u], w = fa[v], k = ch[v][1] == u;
        if ((fa[u] = w)) ch[w][ch[w][1] == v] = u;
        if ((ch[v][k] = ch[u][!k])) fa[ch[v][k]] = v;
        pushup(ch[fa[v] = u][!k] = v), pushup(u);
    }

    inline void splay(const int u, const int tar) {
        for (int v, w; (v = fa[u]) != tar; rotate(u)) {
            if ((w = fa[v]) != tar) {
                rotate((v == ch[w][0]) == (u == ch[v][0]) ? v : u);
            }
        }
        if (!tar) root = u;
    }

    inline int rank(const int u) {
        splay(u, 0);
        return siz[ch[u][0]] + 1;
    }

    inline int kth(int k) {
        int u = root;
        while (true) {
            if (k <= siz[ch[u][0]]) u = ch[u][0];
            else if (!(k -= siz[ch[u][0]] + 1)) return u;
            else u = ch[u][1];
        }
    }

    /** insert a node s.t. the rank of it is @p rk */
    inline int insertAs(const int rk) {
        assert(1 < rk && rk <= siz[root]);
        int u = kth(rk - 1), v = kth(rk);
        splay(u, 0), splay(v, u), assert(!ch[v][0]);
        fa[ch[v][0] = newnd()] = v, pushup(v), pushup(u);
        return ch[v][0];
    }

    inline void relable(const int u) {
        if (!u) return ;
        relable(ch[u][0]), lab[u] = ++lab[0], relable(ch[u][1]);
    }
} X, Y;

inline void solve() {
    if (gap.empty()) {
        std::vector<int> rest;
        rep (i, 0, n - 1) if (!vis[i]) rest.push_back(i);
        assert(rest.size() == 4); // As a rectangle.
        X.insertAs(2), X.insertAs(3);
        Y.insertAs(2), Y.insertAs(3);
        rep (i, 0, 3) {
            xid[rest[i]] = !i || i == 3 ? 3 : 4;
            yid[rest[i]] = i < 2 ? 3 : 4;
        }
        // printf("%d %d %d %d\n", rest[0], rest[1], rest[2], rest[3]);
        return ;
    }

    int p = gap.front(), q = suf[p], s = pre[p], t = suf[q];
    gap.pop();
    if (vis[p] || vis[q] || tur[p] == tur[q]) return solve();
    vis[p] = vis[q] = true, suf[s] = suf[q], pre[t] = pre[p];
    assert(!vis[s] && !vis[t]);
    if (tur[s] != tur[t]) gap.push(s);
    solve();
    // printf("%d --> %d - %d <-- %d\n", s, p, q, t);

    if (yid[s] == yid[t]) {
        int sxr = X.rank(xid[s]), txr = X.rank(xid[t]);
        xid[p] = xid[q] = X.insertAs(std::min(sxr, txr) + 1);
        yid[p] = yid[s];
        if ((tur[p] == 'L') == (sxr < txr)) {
            yid[q] = yid[t] = Y.insertAs(Y.rank(yid[p]) + 1);
        } else {
            yid[q] = yid[t] = Y.insertAs(Y.rank(yid[p]));
        }
    } else {
        int syr = Y.rank(yid[s]), tyr = Y.rank(yid[t]);
        yid[p] = yid[q] = Y.insertAs(std::min(syr, tyr) + 1);
        xid[p] = xid[s];
        if ((tur[p] == 'R') == (syr < tyr)) {
            xid[q] = xid[t] = X.insertAs(X.rank(xid[p]) + 1);
        } else {
            xid[q] = xid[t] = X.insertAs(X.rank(xid[p]));
        }
    }
}

int main() {
    // freopen("test.in", "r", stdin);
    // freopen("test.out", "w", stdout);

    scanf("%s", tur), n = strlen(tur);
    std::replace(tur, tur + n, 'P', 'R'); // No Polish :(

    int dlt = 0;
    rep (i, 0, n - 1) dlt += tur[i] == 'L' ? 1 : -1;
    if (dlt != 4) return puts("NIE"), 0;

    rep (i, 0, n - 1) {
        pre[i] = (i + n - 1) % n, suf[i] = (i + 1) % n;
        if (tur[i] != tur[(i + 1) % n]) gap.push(i);
    }

    solve();
    X.relable(X.root), Y.relable(Y.root);
    rep (i, 0, n - 1) printf("%d %d\n", X.lab[xid[i]], Y.lab[yid[i]]);
    return 0;
}

 

  顺便, 给出自己码的一个 SPJ.

/*+Rainybunny+*/

#include "testlib.h"
#include <bits/stdc++.h>

#define MSG_OK \
    "Congratulations~"
#define MSG_SOLUTION_EXISTS \
    "You don't find a solution, but jury does."
#define MSG_NOT_PARALLEL \
    "An edge isn't parallel to x-axis or y-axis (%d-th edge, 0-indexed)."
#define MSG_POINT_COINCIDE \
    "Two nodes coincide in your solution."
#define MSG_NOT_VERTICAL \
    "Two neighboring edges aren't vertical in your solution (%d-th edge and " \
    "%d-th edges, 0-indexed)."
#define MSG_OUTSIDE_WALK \
    "You're walking outside of your polygon."
#define MSG_WRONG_TURNING \
    "A turning direction doesn't meet the requirement."
#define MSG_SELF_INTER \
    "The polygon is self-intersecting in your solution."

#define rep(i, l, r) for (int i = l, rep##i = r; i <= rep##i; ++i)
#define per(i, r, l) for (int i = r, per##i = l; i >= per##i; --i)

typedef long long LL;
typedef std::pair<int, int> PII;
#define fi first
#define se second

const int MAXN = 1e5;
int n;
std::string tur;

struct Point {
    int x, y;
    inline Point operator - (const Point& u) const {
        return { x - u.x, y - u.y };
    }
    inline LL operator * (const Point& u) const {
        return 1ll * x * u.x + 1ll * y * u.y;
    }
    inline LL operator ^ (const Point& u) const {
        return 1ll * x * u.y - 1ll * y * u.x;
    }
    inline bool operator < (const Point& u) const {
        return x == u.x ? y < u.y : x < u.x;
    }
};

Point pnt[MAXN + 5];

inline void initCheck() {
    tur = inf.readToken(), n = int(tur.size());
    std::rotate(tur.begin(), tur.end() - 1, tur.end());

    std::string your = ouf.readToken(), jury = ans.readToken();
    if (your == "NIE" && jury != "NIE") quitf(_wa, MSG_SOLUTION_EXISTS);
    else if (your == "NIE") quitf(_ok, MSG_OK);
    std::reverse(your.begin(), your.end());
    for (char c: your) ouf.unreadChar(c);

    rep (i, 0, n - 1) {
        pnt[i].x = ouf.readInt(-1e9, 1e9);
        pnt[i].y = ouf.readInt(-1e9, 1e9);
        // fprintf(stderr, "? %d %d\n", pnt[i].x, pnt[i].y);
    }
}

int fail[MAXN + 5];
std::string act;
std::set<Point> apr;

inline void turningCheck() {
    rep (i, 0, n - 1) {
        if ((pnt[i].x != pnt[(i + 1) % n].x)
          && (pnt[i].y != pnt[(i + 1) % n].y)) quitf(_wa, MSG_NOT_PARALLEL, i);
        if (apr.count(pnt[i])) quitf(_wa, MSG_POINT_COINCIDE);
        apr.insert(pnt[i]);

        Point p(pnt[i] - pnt[(i + n - 1) % n]), q(pnt[(i + 1) % n] - pnt[i]);
        // fprintf(stderr, "(%d,%d) -> (%d,%d)\n", p.x, p.y, q.x, q.y);
        if (p * q) quitf(_wa, MSG_NOT_VERTICAL, (i + n - 1) % n, i);
        act += (p ^ q) > 0 ? 'L' : 'P';
    }

    int dlt = 0;
    for (int c: act) dlt += c == 'L' ? 1 : -1;
    if (dlt == -4) {
        // In this case, the answer should be "NIE", but the checker won't
        // refuse to check your answer, knowing you must be wrong before.
        quitf(_wa, MSG_OUTSIDE_WALK);
    }
    // std::cerr << "Your turning token: " << act << '\n';

    fail[0] = -1;
    for (int i = 1, j = -1; i < n; ++i) {
        while (~j && tur[j + 1] != tur[i]) j = fail[j];
        fail[i] = j += tur[j + 1] == tur[i];
    }

    for (int i = 0, j = -1; i < 2 * n; ++i) {
        while (~j && tur[j + 1] != act[i % n]) j = fail[j];
        if ((j += tur[j + 1] == act[i % n]) == n - 1) return ;
    }
    quitf(_wa, MSG_WRONG_TURNING);
}

int mx, dc[MAXN + 5];
std::vector<PII> evt[MAXN + 5], req[MAXN + 5];
std::set<int> cut;

inline void selfInterCheck() {
    rep (i, 0, n - 1) dc[++mx] = pnt[i].x;
    std::sort(dc + 1, dc + mx + 1);
    mx = std::unique(dc + 1, dc + mx + 1) - dc - 1;
    rep (i, 0, n - 1) {
        pnt[i].x = std::lower_bound(dc + 1, dc + mx + 1, pnt[i].x) - dc;
    }

    rep (i, 0, n - 1) {
        if (pnt[i].x == pnt[(i + 1) % n].x) {
            int ya = pnt[i].y, yb = pnt[(i + 1) % n].y;
            if (ya > yb) std::swap(ya, yb);
            req[pnt[i].x].emplace_back(ya, yb);
        } else {
            int xa = pnt[i].x, xb = pnt[(i + 1) % n].x;
            if (xa > xb) std::swap(xa, xb);
            evt[xa].emplace_back(pnt[i].y, 1);
            evt[xb].emplace_back(pnt[i].y, 0);
        }
    }

    rep (i, 1, mx) {
        for (const PII& p: evt[i]) if (!p.se) cut.erase(p.fi);
        for (const PII& p: req[i]) {
            auto&& it = cut.upper_bound(p.se);
            if (it != cut.begin() && *--it >= p.fi) quitf(_wa, MSG_SELF_INTER);
        }

        for (const PII& p: evt[i]) if (p.se) {
            if (cut.count(p.fi)) quitf(_wa, MSG_SELF_INTER);
            cut.insert(p.fi);
        }

        for (const PII& p: evt[i]) if (!p.se) cut.insert(p.fi);
        for (const PII& p: req[i]) if (p.fi + 2 <= p.se) {
            auto&& it = cut.upper_bound(p.se - 1);
            if (it != cut.begin() && *--it > p.fi) quitf(_wa, MSG_SELF_INTER);
        }

        for (const PII& p: evt[i]) if (!p.se) cut.erase(p.fi);
    }
}

int main(int argc, char** argv) {
    registerTestlibCmd(argc, argv);

    initCheck();
    turningCheck();
    selfInterCheck();

    quitf(_ok, MSG_OK);
    return 0;
}