题目翻译

Description

给定一个\(01\)串 \(S_{1...n}\) 和 \(Q\) 个操作。

操作有两种类型：

1、将 \([l,r]\) 区间的数取反（将其中的\(0\)变成\(1\)，\(1\)变成\(0\)）。

2、询问字符串 \(S\) 的子串 \(S_{l...r}\) 有多少个不同的子序列。由于答案可能很大，请将答案对 \(10^9+7\) 取模。

在数学中，某个序列的子序列是从最初序列通过去除某些元素但不破坏余下元素的相对位置（在前或在后）而形成的新序列。

Input

第一行包含两个整数 \(N\) 和 \(Q\) ，分别表示字符串长度和操作次数。

第二行包含一个字符串 \(S\) 。

接下来 \(Q\) 行，每行3个整数 \(type\),\(l\),\(r\) ，其中 \(type\) 表示操作类型， \(l\),\(r\) 表示操作区间为 \([l,r]\) 。

Output

对于每一个 \(type=2\) 的询问，输出一个整数表示答案。由于答案可能很大，请将答案对 \(10^9+7\) 取模。

Sample Input

4 4
1010
2 1 4
2 2 4
1 2 3
2 1 4

Sample Output

11
6
8

HINT

数据范围与约定

对于\(5\%\)的数据， \(N≤20\),\(Q=1\)

对于\(10\%\)的数据， \(N≤1000\),\(Q=1\)

对于\(20\%\)的数据， \(N≤10^5,Q≤10\)

对于另外\(30\%\)的数据， \(1≤N≤10^5\),\(1≤Q≤10^5\),\(type=2\)

对于\(100\%\)的数据， \(1≤N≤10^5\),\(1≤Q≤10^5\)

题解

看到求子序列，我们先想到怎么求静态的\(S\)的每个前缀子序列个数。

设\(dp[i][j]\)为\(S\)的前\(i\)位以\(j\)结尾的子序列个数是多少（\(j=0\)或\(1\)）。

则当第\(i\)位为\(0\)时，\(dp\)的状态转移方程为：

\[\begin{aligned} & dp[i][0]=dp[i-1][0]+dp[i-1][1]+1\\ & dp[i][1]=dp[i-1][1]\end{aligned}\]

当第\(i\)位为\(1\)时同理，把方程的\(0\)和\(1\)反过来就好了。

我们又看到题目问的是区间修改和区间查询，就想到线段树。

关键是如何求出区间的子序列个数。

再看回\(dp\)式，自然而然地想到用矩阵维护\(dp[i-1]\)和\(dp[i]\)间的关系。

不妨把第\(i\)位的转移矩阵\(A_i\)推一下：

1. 当第\(i\)位为0时，矩阵为：

   \[
   \begin{pmatrix}
   0 & 0 & 0 \ 0 & 0 & 0\ dp[i-1][0] & dp[i-1][1] & 1
   \end{pmatrix}
   \times
   \begin{pmatrix}
   1 & 0 & 0 \ 1 & 1 & 0\ 1 & 0 & 1
   \end{pmatrix}=
   \begin{pmatrix}
   0 & 0 & 0 \ 0 & 0 & 0\ dp[i][0] & dp[i][1] & 1
   \end{pmatrix}
   \]

2. 当第\(i\)位为\(1\)时，矩阵为：

   \[
   \begin{pmatrix}
   0 & 0 & 0 \ 0 & 0 & 0\ dp[i-1][0] & dp[i-1][1] & 1
   \end{pmatrix}
   \times
   \begin{pmatrix}
   1 & 1 & 0 \ 0 & 1 & 0\ 0 & 1 & 1
   \end{pmatrix}=
   \begin{pmatrix}
   0 & 0 & 0 \ 0 & 0 & 0\ dp[i][0] & dp[i][1] & 1
   \end{pmatrix}
   \]

又由于初始时\(dp[0][0]=dp[0][1]=0\)，所以我们就不用设起始矩阵。

那么对于\(dp[i]\)所对应的矩阵，即为：

\[A_1\times A_2\times ...\times A_i\]

然后，我们再进一步地往题目的方向推，如果要求\(S_{l...r}\)的子序列个数呢？

那我们不妨把这\(S_{l...r}\)单独看成一个串，根据上面推得的结论，\(S_{l...r}\)的子序列个数所对应矩阵即为：

\[A_l\times A_{l+1}\times ...\times A_r\]

那么我们就可以用矩阵乘法维护询问区间的子序列个数了。

至于修改，我们可以用区间懒标记\(rev\)，来记录该区间的\(0\)、\(1\)是否翻转。

翻转过后，对应的矩阵也要变化，这里我们只要将矩阵的第一列与第二列交换后再将第一行与第二行交换就好了。

证明：

来自这篇博客，网址：https://www.cnblogs.com/iRedBean/p/7398272.html

最后的代码：

#include<bits/stdc++.h>

#define N 100010
#define mod 1000000007

using namespace std;

struct Matrix
{
    int a[4][4];
}zero,one,p,t[N<<2],none;

inline Matrix operator * (Matrix a,Matrix b)
{
    Matrix c=none;
    for(int i=1;i<=3;i++)
        for(int j=1;j<=3;j++)
            for(int k=1;k<=3;k++)
                c.a[i][j]=(c.a[i][j]+1ll*a.a[i][k]*b.a[k][j])%mod;
    return c;
}

int n,q,rev[N<<2];
char s[N];

inline int read()
{
    int x=0;
    char ch=getchar();
    while(ch<'0'||ch>'9')
        ch=getchar();
    while(ch>='0'&&ch<='9')
    {
        x=(x<<3)+(x<<1)+(ch^'0');
        ch=getchar();
    }
    return x;
}

inline void init()
{
    zero.a[1][1]=zero.a[2][1]=zero.a[3][1]=zero.a[2][2]=zero.a[3][3]=1;//第i位为0的时候所对应矩阵
    one.a[1][1]=one.a[1][2]=one.a[2][2]=one.a[3][2]=one.a[3][3]=1;//第i位为1的时候所对应矩阵
    p.a[1][1]=p.a[2][2]=p.a[3][3]=1;//单位矩阵
}

inline void up(int k)
{
    t[k]=t[k<<1]*t[k<<1|1];
}

inline void build(int k,int l,int r)
{
    if(l==r)
    {
        if(s[l]=='0')
            t[k]=zero;
        else
            t[k]=one;
        return;
    }
    int mid=(l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
    up(k);
}

inline void reverse(int k)
{
    rev[k]^=1;//打标记
    for(register int i=1;i<=3;i++)//换列
        swap(t[k].a[i][1],t[k].a[i][2]);
    for(register int i=1;i<=3;i++)//换行
        swap(t[k].a[1][i],t[k].a[2][i]);
}

inline void down(int k)//下传懒标记
{
    if(rev[k])
    {
        reverse(k<<1);
        reverse(k<<1|1);
        rev[k]=0;
    }
}

inline void change(int k,int l,int r,int L,int R)
{
    if(L<=l&&r<=R)
    {
        reverse(k);
        return;
    }
    down(k);
    int mid=(l+r)>>1;
    if(L<=mid)change(k<<1,l,mid,L,R);
    if(R>mid)change(k<<1|1,mid+1,r,L,R);
    up(k);
}

inline Matrix query(int k,int l,int r,int L,int R)
{
    if(L<=l&&r<=R)
        return t[k];
    down(k);
    int mid=(l+r)>>1;
    if(R<=mid)return query(k<<1,l,mid,L,R);
    if(L>mid)return query(k<<1|1,mid+1,r,L,R);
    return query(k<<1,l,mid,L,R)*query(k<<1|1,mid+1,r,L,R);
}

int main()
{
    init();
    n=read(),q=read();
    scanf("%s",s+1);
    build(1,1,n);
    while(q--)
    {
        int opt,l,r;
        opt=read(),l=read(),r=read();
        if(opt==1)
            change(1,1,n,l,r);
        if(opt==2)
        {
            Matrix ans=query(1,1,n,l,r);
            printf("%d\n",(ans.a[3][1]+ans.a[3][2])%mod);//最后要加起来
        }
    }
    return 0;
}

总结

随着题目难度的不断增加，对于线段树的合并或维护变得越来越难、越来越复杂，如矩阵乘法，小白逛公园等，所以考试时要想的全面一点。

原文地址：https://www.cnblogs.com/ez-lcw/p/11382995.html