CF1252K Addition Robot 题解

题目链接

思路

对于 \(A = A + B\)，\(B = A + B\) 这种的递推式可以考虑矩阵加速递推，可得：

\[\left ( \begin{matrix} A + B & B \end{matrix} \right ) = \left ( \begin{matrix} A & B \end{matrix} \right ) \left ( \begin{matrix} 1 & 0 \\ 1 & 1 \end{matrix} \right ) \]

\[\left ( \begin{matrix} A & A + B \end{matrix} \right ) = \left ( \begin{matrix} A & B \end{matrix} \right ) \left ( \begin{matrix} 1 & 1 \\ 0 & 1 \end{matrix} \right ) \]

把 \(A,B\) 二元组看作单位向量 \(\left ( \begin{matrix} A & B \end{matrix} \right )\)，设 \(S_i\) 对应的转移矩阵为 \(G_i\)，则一次 F 函数操作得到的 \(A,B\) 二元组对应的向量就是：

\[\left ( \begin{matrix} A & B \end{matrix} \right ) \prod_{i = l}^{r} G_i \]

由于矩阵乘法满足结合律，对于一段区间的矩阵的乘积，我们可以用线段树维护。

考虑区间取反操作怎么实现，我们通过打表观察上方给出的两个转移矩阵，发现它们都是对方旋转了 \(180^{\circ}\)。感性理解一下，设有矩阵 \(A,B,C\)，有：

\[A = \left ( \begin{matrix} a_1 & b_1 \\ c_1 & d_1 \end{matrix} \right ) \]

\[B = \left ( \begin{matrix} a_2 & b_2 \\ c_2 & d_2 \end{matrix} \right ) \]

\[C = A \times B = \left ( \begin{matrix} a_1a_2 + b_1c_2 & a_1b_2 + b_1d_2 \\ c_1a_2 + d_1c_2 & c_1b_2 + d_1d_2 \end{matrix} \right ) \]

设 \(A'\)，\(B'\) 为 \(A\)，\(B\) 各旋转 \(180^{\circ}\) 后的矩阵，有:

\[A' = \left ( \begin{matrix} d_1 & c_1 \\ b_1 & a_1 \end{matrix} \right ) \]

\[B' = \left ( \begin{matrix} d_2 & c_2 \\ b_2 & a_2 \end{matrix} \right ) \]

\[C' = A' \times B' = \left ( \begin{matrix} d_1d_2 + c_1b_2 & d_1c_2 + c_1a_2 \\ b_1d_2 + a_1b_2 & b_1c_2 + a_1a_2 \end{matrix} \right ) \]

可以发现 \(C'\) 也是 \(C\) 旋转 \(180^{\circ}\) 后的结果，所以推广这个结论到 \(A,B\) 的反转操作上，就是直接交换矩阵对角线上的元素。就像维护01序列的翻转那样维护线段树就行了。时间复杂度 \(\Theta (2 ^ 3 n \log n)\) 。

Code

#include<cstdio>
#include<cstring>
#include<algorithm>

#define LL long long

using namespace std;

const int Mod = 1e9 + 7;
const int MAXN = 1e5 + 10, SIZE = 3;
int n, q;
char s[MAXN];

struct Matrix{
    int hig, wid;
    LL num[SIZE][SIZE];

    Matrix(){
        hig = wid = 0;
        memset(num, 0, sizeof(num));
    }

    Matrix operator * (const Matrix &b) const{
        Matrix c;
        c.hig = hig, c.wid = b.wid;
        for(register int i = 1; i <= c.hig; i++){
            for(register int k = 1; k <= b.hig; k++){
                LL res = num[i][k];
                for(register int j = 1; j <= c.wid; j++)
                    c.num[i][j] = 1LL * (c.num[i][j] + res * b.num[k][j] % Mod) % Mod;
            }
        }

        return c;
    }

    void Reverse(){
        swap(num[1][1], num[2][2]);
        swap(num[1][2], num[2][1]);
    }
}base, G1, G2, I;

struct Segment_Tree{
    struct Tree{
        int l, r;
        Matrix sum;
        int lazy;
    }tr[MAXN << 2];

    inline int lson(int rt){
        return rt << 1;
    }

    inline int rson(int rt){
        return rt << 1 | 1;
    }

    inline void Pushup(int rt){
        tr[rt].sum = tr[lson(rt)].sum * tr[rson(rt)].sum;
    }

    void Build(int rt, int l, int r){
        tr[rt].l = l, tr[rt].r = r;
        if(l == r){
            if(s[l] == 'A') tr[rt].sum = G1;
            else tr[rt].sum = G2;
            return;
        }

        int mid = (l + r) >> 1;
        Build(lson(rt), l, mid);
        Build(rson(rt), mid + 1, r);

        Pushup(rt);
    }

    inline void Pushdwon(int rt){
        if(tr[rt].lazy){
            tr[lson(rt)].lazy ^= 1;
            tr[rson(rt)].lazy ^= 1;
            tr[lson(rt)].sum.Reverse();
            tr[rson(rt)].sum.Reverse();
            tr[rt].lazy = 0;
        }
    }

    void Update_Rev(int rt, int l, int r){
        if(tr[rt].l >= l && tr[rt].r <= r){
            tr[rt].sum.Reverse();
            tr[rt].lazy ^= 1;
            return;
        }

        Pushdwon(rt);

        int mid = (tr[rt].l + tr[rt].r) >> 1;
        if(l <= mid) Update_Rev(lson(rt), l, r);
        if(r > mid) Update_Rev(rson(rt), l, r);

        Pushup(rt);
    }

    Matrix Query_Sum(int rt, int l, int r){
        if(tr[rt].l >= l && tr[rt].r <= r) return tr[rt].sum;

        Pushdwon(rt);

        Matrix ans = base;
        int mid = (tr[rt].l + tr[rt].r) >> 1;
        if(l <= mid) ans = ans * Query_Sum(lson(rt), l, r);
        if(r > mid) ans = ans * Query_Sum(rson(rt), l, r);

        return ans;
    }
}S;

void init(){
    base.hig = base.wid = 2;
    base.num[1][1] = base.num[2][2] = 1;
    G1.hig = G1.wid = 2;
    G1.num[1][1] = G1.num[2][1] = G1.num[2][2] = 1;
    G2.hig = G2.wid = 2;
    G2.num[1][1] = G2.num[1][2] = G2.num[2][2] = 1;
    I.hig = 1, I.wid = 2;
}

int main(){
    init();

    scanf("%d%d", &n, &q);
    scanf("%s", s + 1);

    S.Build(1, 1, n);

    for(register int i = 1; i <= q; i++){
        int opt;
        scanf("%d", &opt);

        if(opt == 1){
            int l, r;
            scanf("%d%d", &l, &r);
            S.Update_Rev(1, l, r);
        }
        else{
            int l, r, a, b;
            scanf("%d%d%d%d", &l, &r, &a, &b);
            I.num[1][1] = a, I.num[1][2] = b;
            I = I * S.Query_Sum(1, l, r);
            printf("%lld %lld\n", I.num[1][1], I.num[1][2]);
        }
    }

    return 0;
}

马蜂冗长，不喜勿喷。