agc013e Placing Squares（模型转化+dp+矩阵优化）

题目链接：agc013e Placing Squares

题目大意：

给你一个正整数序列S,长度为m，还有一个正整数n，S中元素升序且都小于n$(1\le X_1<X_2<...<X_m\le n-1)$,现在对于一个正整数序列，如果它的任意一个前缀和属于集合S就是非法的。
一个合法序列a贡献是$\prod_{i=1}^k ai^2$，求所有合法序列的贡献和。(mod 10^9+7)

题解:

这个模型转化太妙了（这个题属于模型一转换就会，不转换做死的题）

问题等价于n个位置，每个位置可以放一个红球或一个绿球或一红一绿，什么都不放也可以，两个位置之间可以放隔板，第一个位置前和第n个位置后固定有隔板，但第$X_i$个位置和第$X_{i+1}$个位置之间不能放隔板，要求每两个隔板之间必须恰好有1个红球和一个绿球的方案数。

显然是套路性的dp+矩阵快速幂优化,可以放隔板的地方用矩阵快速幂转移，其余地方暴力转移（写的时候加了个快速乘结果被卡两个点）

这个模型转化妙就妙在红绿球。方案太多了，$\prod_{i=1}^k ai^2$难以处理导致只能先将具体方案算出再算贡献，这样就挂了。红绿球则以一种很容易dp的方式把这个式子融入了整体中，使其可以一次算出。

代码：

#include <iostream>
#include <string.h>
#include <stdio.h>
using namespace std;
const int M=1e5+5;
const int N=1e9+5;
const int mod=1e9+7;
struct Matrix{
    int n,m;
    int ju[5][5];
    Matrix(){
        n=m=3;
        memset(ju,0,sizeof(ju));
        ju[1][1]=ju[2][2]=ju[0][0]=1;
    }
    Matrix(int n1,int m1){
        n=n1,m=m1;
        memset(ju,0,sizeof(ju));
    }
    int MUL(int a,int b){
        int ret=0;
        while(b){
            if((b&1))
                ret=(ret+a)%mod;
            a=(a+a)%mod;
            b>>=1;
        }
        return ret;
    }
    Matrix Se(){
        Matrix ret(n,m);
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
                ret.ju[i][j]=ju[i][j];
        return ret;
    }
    Matrix operator*(const Matrix dd){
        Matrix ret(n,dd.m);
        if(dd.n!=m)
        {
            printf("Error\n");
            return ret;
        }
        for(int i=0;i<ret.n;i++)
            for(int j=0;j<ret.m;j++)
                for(int k=0;k<m;k++)
                    ret.ju[i][j]=(ret.ju[i][j]+(((long long)ju[i][k])*((long long)dd.ju[k][j])%mod))%mod;
//                  ret.ju[i][j]=(ret.ju[i][j]+MUL(ju[i][k],dd.ju[k][j]))%mod;
        return ret;
    }
    Matrix operator^(int p){
        Matrix ret,Self=Se();
        while(p)
        {
            if((p&1))
                ret=ret*Self;
            Self=Self*Self;
            p>>=1;
        }
        return ret;
    }
}EM(3,3),dp(1,3),ES(3,3);

int n,m;
int Si[M],E[3][3]={{1,2,1},{0,1,1},{1,2,2}};

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
        scanf("%d",&Si[i]);
    for(int i=0;i<3;i++)
        for(int j=0;j<3;j++)
            EM.ju[i][j]=E[i][j];
    ES=EM;
    ES.ju[2][0]=ES.ju[2][1]=0;
    ES.ju[2][2]=1;
    dp.ju[0][0]=1,dp.ju[0][1]=2,dp.ju[0][2]=1;
    for(int i=1;i<=m;i++)
    {
        dp=dp*(EM^(Si[i]-Si[i-1]-1));
        dp=dp*ES;
    }
    dp=dp*(EM^(n-Si[m]-1));
    cout<<dp.ju[0][2]<<endl;
    return 0;
}