P6864 RC-03 记忆

P6864 RC-03 记忆。

设当前括号串 $S$ 中：

• 合法括号非空 子串 数量为 $\mathrm{ans}$。
• 合法括号非空 后缀子串 数量为 $\mathrm{cnt}$。

例： $S = \mathtt{()()}$，则 $\mathrm{ans} = 3$，$\mathrm{cnt} = 2$。

设 $S$ 进行一步操作一后，变为括号串 $S_1 = \overline{S\mathtt{()}}$，相应参数变为 $\mathrm{ans}_1$ 和 $\mathrm{cnt}_1$。

现试图找到 $\mathrm{ans_1}$ 和 $\mathrm{ans}$、$\mathrm{cnt_1}$ 和 $\mathrm{cnt}$ 的关系。

不难发现 $\mathrm{cnt_1 = cnt + 1}$，$\mathrm{ans_1 = ans + cnt + 1}$。

再设 $S$ 进行一步操作二后，变为括号串 $S_2 = \overline{\mathtt ( S\mathtt)}$，相应参数 $\mathrm{ans_2}$ 和 $\mathrm{cnt_2}$。

我们试图证明，新增的合法括号非空子串只有 $\boldsymbol{S_2}$ 本身一个。

反证法，我们考虑有没有可能，新加的这对括号中的左括号，和 $S$ 的一段前缀组成一段合法括号子串？

很明显，这要求 $S$ 的这段前缀中，右括号比左括号多一个。

但在操作的变换中，字符串始终是合法括号串。因此，$S$ 不可能存在一段右括号比左括号多的前缀。

那有无可能，新加的这对括号中的右括号，和 $S$ 的一段后缀组成一段合法括号子串？

这要求 $S$ 的这段后缀里，左括号比右括号多一个。

可以发现，这就意味着 $S$ 除去这段后缀的剩余那部分前缀，右括号比左括号多一个（因为整个括号串左右括号数相等），所以同样不可能。

那么新增的合法括号子串只有 $S_2$ 本身一个咯。

所以 $\mathrm{cnt_2} = 1$，$\mathrm{ans_2} = \mathrm{ans} + 1$。

现在考虑撤销操作。发现撤销操作对 $\mathrm{cnt}$ 和 $\mathrm{ans}$ 的变化并不平凡。

然后这里有一个比较不朴素的想法……那就是用矩阵刻画上面两种操作的变换。

刻画还是较为容易的：

$$\begin{bmatrix}\mathrm{ans} & \mathrm{cnt} & \mathrm{1}\end{bmatrix} \times\begin{bmatrix}1 & 0 & 0\\1 & 1 & 0\\1 & 1 & 1\end{bmatrix} = \begin{bmatrix}\mathrm{ans_1} & \mathrm{cnt_1} & \mathrm{1}\end{bmatrix}$$

$$\begin{bmatrix}\mathrm{ans} & \mathrm{cnt} & \mathrm{1}\end{bmatrix} \times\begin{bmatrix}1 & 0 & 0\\0 & 0 & 0\\1 & 1 & 1\end{bmatrix} = \begin{bmatrix}\mathrm{ans_2} & \mathrm{cnt_2} & \mathrm{1}\end{bmatrix}$$

那么答案可以看做初始矩阵 $\begin{bmatrix}1 & 1 & 1\end{bmatrix}$ 经过一系列矩阵乘法得到的结果。

那撤销是什么？题目的撤销还可以撤销一个撤销操作，看起来很高级，但它的影响最后无非都是：

• 将某个非撤销操作（即操作一或操作二）从进行改为不进行。
• 将某个非撤销操作（即操作一或操作二）从不进行改为进行。

不进行操作也是可以刻画出矩阵的，即单位矩阵 $\begin{bmatrix}1 & 0 & 0 \\0 & 1 & 0 \\ 0 & 0 & 1\end{bmatrix}$。

所以任何一个撤销操作都是将一个非撤销操作对应的矩阵单点修改，要么是从操作矩阵修改成单位矩阵，要么是从单位矩阵修改成操作矩阵。

因此现在变成一个对矩阵单点修改，求矩阵全局乘法的问题。因为矩阵乘法有结合律，可以用线段树维护。

因为矩阵乘法没法差分，所以不能用单 $\log$ 的树状数组。

时间复杂度 $\Theta(K^3 n \log n)$，其中 $K = 3$。

/*
 * @Author: crab-in-the-northeast 
 * @Date: 2023-05-15 16:06:19 
 * @Last Modified by: crab-in-the-northeast
 * @Last Modified time: 2023-05-15 19:15:26
 */
#include <bits/stdc++.h>
#define int long long
inline int read() {
    int x = 0;
    bool f = true;
    char ch = getchar();
    for (; !isdigit(ch); ch = getchar())
        if (ch == '-')
            f = false;
    for (; isdigit(ch); ch = getchar())
        x = (x << 1) + (x << 3) + ch - '0';
    return f ? x : (~(x - 1));
}
inline int ls(int p) {
    return p << 1;
}
inline int rs(int p) {
    return p << 1 | 1;
}

struct phalanx {
    int a[4][4];

    phalanx () {
        for (int i = 1; i <= 3; ++i)
            for (int j = 1; j <= 3; ++j)
                a[i][j] = 0;
    }
    phalanx (std :: vector <int> v) {
        for (int i = 1; i <= 3; ++i)
            for (int j = 1; j <= 3; ++j)
                a[i][j] = v[(i - 1) * 3 + j - 1];
    }

    const phalanx operator * (const phalanx b) const {
        phalanx ans;
        for (int i = 1; i <= 3; ++i)
            for (int j = 1; j <= 3; ++j)
                for (int k = 1; k <= 3; ++k)
                    ans.a[i][j] += a[i][k] * b.a[k][j];
        return ans;
    }
};

const phalanx UNIT({1, 0, 0, 0, 1, 0, 0, 0, 1}), 
                OP1({1, 0, 0, 1, 1, 0, 1, 1, 1}),
                OP2({1, 0, 0, 0, 0, 0, 1, 1, 1});

const int N = (int)2e5 + 5;

struct node {
    int l, r;
    phalanx ans;
} t[N << 2];

inline node con(node lef, node rgt) {
    return (node){
        l: lef.l,
        r: rgt.r,
        ans: lef.ans * rgt.ans
    };
}

inline void up(int p) {
    t[p] = con(t[ls(p)], t[rs(p)]);
}

void build(int p, int l, int r) {
    if (l == r) {
        t[p].l = t[p].r = l;
        t[p].ans = UNIT;
        return ;
    }
    int mid = (l + r) >> 1;
    build(ls(p), l, mid);
    build(rs(p), mid + 1, r);
    up(p);
}

void modify(int p, int x, int op) {
    int l = t[p].l, r = t[p].r;
    if (l == r) {
        if (op == 1)
            t[p].ans = OP1;
        else if (op == 2)
            t[p].ans = OP2;
        else
            t[p].ans = UNIT;
        return ;
    }
    int mid = (l + r) >> 1;
    if (x <= mid)
        modify(ls(p), x, op);
    else
        modify(rs(p), x, op);
    up(p);
}

int ops[N];
int pos[N];

signed main() {
    int n = read();
    build(1, 1, n);

    for (int i = 1; i <= n; ++i) {
        int op = ops[i] = read();
        pos[i] = i;
        if (op <= 2)
            modify(1, i, op);
        else {
            int p = read();
            p = pos[i] = pos[p];
            ops[p] = -ops[p];
            modify(1, p, ops[p]);
        }
        phalanx ans = t[1].ans;
        printf("%lld\n", ans.a[1][1] + ans.a[2][1] + ans.a[3][1]);
    }
    return 0;
}