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

题目链接：agc013e Placing Squares

题目大意：

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

题解:

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

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

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

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

代码：

#include 
#include 
#include 
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;
}