CF954F Runner's Problem

离散化+矩阵快速幂

首先看数据范围可以确定该题的算法为矩阵快速幂

然后易得转移矩阵

\[\begin{bmatrix} 1 & 1 & 0 \\ 1 & 1 & 1 \\ 0 & 1 & 1 \end{bmatrix}\]

然后把障碍离散下来重构，获取每段区间内障碍的情况（共\(2^3=8\)种）

重构的时候用辅助变量\(pre\)表示上一段区间对应的情况，易得重构部分的算法

若某一列有障碍，则将转移矩阵中的这一列全置0即可

为了减小代码复杂度，我们将每种情况与预处理后的转移矩阵一一对应，即可快速选择需要的转移矩阵

代码中用对应\(.kd\)二进制位为1表示该列有障碍

初始矩阵显然是

\[\begin{bmatrix} 0 \\ 1 \\ 0 \end{bmatrix}\]

分段求矩阵快速幂即可

时间复杂度\(\Theta(n \log n + siz^3n \log m)\)

#include"cstdio"
#include"cstring"
#include"iostream"
#include"algorithm"
using namespace std;

const int siz=8;
const int MAXN=1e4+5;
const int MOD=1e9+7;

int n,pre,np;
long long m;
int cnt[siz];
struct Matrix{
    int v[siz][siz];
    int x,y;

    void clear(){memset(v,0,sizeof(v));x=y=0;}
    void Mmul(Matrix a,Matrix b)
    {
        clear();x=a.x,y=b.y;int c=a.y;
        for(int i=1;i<=x;++i){
            for(int j=1;j<=y;++j){
                for(int k=1;k<=c;++k){
                    v[i][j]+=(long long)a.v[i][k]*b.v[k][j]%MOD;
                    v[i][j]%=MOD;
                }
            }
        }return;
    }

    Matrix Mpw(Matrix a,long long b)
    {
        Matrix x;x.clear();x.x=x.y=a.x;
        for(int i=1;i<=x.x;++i) x.v[i][i]=1;
        while(b){
            if(b&1) x.Mmul(x,a);
            b>>=1;a.Mmul(a,a);
        }return x;
    }

    void write()
    {
        for(int i=1;i<=x;++i){
            for(int j=1;j<=y;++j){
                printf("%d ",v[i][j]);
            }puts("");
        }puts("");
        return;
    }
}A[siz],B;
struct rpg{
    long long x;
    int h;
    bool kd;
}a[MAXN<<1];
struct lint{
    long long siz;
    int kd;
}line[MAXN<<1];

bool cmp(rpg a,rpg b){return a.x<b.x;}
void build()
{
    for(int i=0;i<siz;++i) A[i].x=A[i].y=3;
    for(int i=0;i<siz;++i){
        for(int j=1;j<=2;++j){
            for(int k=1;k<=2;++k){
                A[i].v[j][k]=A[i].v[4-j][4-k]=1;
            }
        }for(int j=0;j<3;++j){
            if(i&(1<<j)){
                for(int k=1;k<=3;++k){
                    A[i].v[k][j+1]=0;
                }
            }
        }
    }B.x=3,B.y=B.v[2][1]=1;
    return;
}

void init()
{
    build();
    scanf("%d%lld",&n,&m);
    for(int i=1;i<=n;++i) scanf("%d%lld%lld",&a[i].h,&a[i].x,&a[i+n].x),a[i+n].kd=1,a[i+n].h=a[i].h,++a[i+n].x;
    sort(a+1,a+(n<<1)+1,cmp);np=line[1].siz=1;
    for(int i=1;i<=n<<1;++i){
        if(a[i].kd) --cnt[a[i].h];
        else ++cnt[a[i].h];
        if(a[i+1].x!=a[i].x){
            int nw=0;
            for(int j=1;j<=3;++j) if(cnt[j]) nw|=1<<j-1;
            if(nw!=pre){
                line[np].siz=a[i].x-line[np].siz;
                pre=nw;
                line[++np]=(lint){a[i].x,pre};
            }
        }
    }line[np].siz=m-line[np].siz;
    return;
}

void solve()
{
    for(int i=1;i<=np;++i) B.Mmul(A[line[i].kd].Mpw(A[line[i].kd],line[i].siz),B);
    printf("%d\n",B.v[2][1]);
    return;
}

int main()
{
    init();
    solve();
    return 0;
}

转载于:https://www.cnblogs.com/AH2002/p/10115224.html