CodeForces 821E Okabe and El Psy Kongroo

        题意为：从（0,0）点出发，只能向右下，右或右上移动，每一段区域会给一个最高值，向上不能超过这个最高值，向下不能低于0，要求，到达（k,0）这个点的方案数。

        如果k的值很小，我们会想到对于每一个点，答案数为能转移到它的点答案加和。但是我们发现它的k有1018 之大，但是实际的上端有差别的只有100个，所以对于很多状态转移是相似的，这时就可以使用矩阵优化了。

       我们将转移矩阵作为图的邻接矩阵，如果能转移到（有边）那么po[i][j]=1。初始矩阵中，仅考虑边界这一列的情况

，最开始将起点0,0的值赋为1，那么对于每次上界改变的边缘情况暴力转移，对于上界不变的情况矩阵快速幂优化，

即可在nlogk的时间复杂度内解决问题。不过，这道题对于边界条件的处理也极为关键，对于每一次上界变低的情况，

我们都需要将这次的上界，到上一次的上界的值清为0，以避免多算答案。

       下附AC代码。

#include
#include
#include
#include
#include
#define maxn 20
using namespace std;
struct Matrix
{
	int n,m;
	long long val[maxn][maxn];
};
long long mod=1000000007;
Matrix quickmul(Matrix mat1,Matrix mat2)
{
	Matrix ans;
	ans.n=mat1.n;
	ans.m=mat2.m;
	memset(ans.val,0,sizeof(ans.val));
	for(int i=0;i<=mat1.n;i++)
	{
		for(int j=0;j<=mat2.m;j++)
		{
			for(int k=0;k<=mat1.m;k++)
			{
				ans.val[i][j]+=mat1.val[i][k]*mat2.val[k][j];
				ans.val[i][j]%=mod;
			}
		}
	}
	return ans;
}

Matrix quickpow(Matrix n,long long k)
{
	Matrix ans;
	memset(ans.val,0,sizeof(ans));
	ans.n=n.n;
	ans.m=n.m;
	for(int i=0;i<=n.n;i++)
	ans.val[i][i]=1;
	while(k)
	{
		if(k&1)
		{
			ans=quickmul(ans,n);
		}
		n=quickmul(n,n);
		k=k>>1;
	}
	return ans;
}
Matrix now,po,pre;
long long n,k;
int main()
{
	scanf("%I64d%I64d",&n,&k);
	memset(pre.val,0,sizeof(pre.val)); 
	memset(po.val,0,sizeof(po.val));
	
	for(int i=0;i<16;i++)
	for(int j=-1;j<=1;j++)
	if(i+j>=0 && i+j<16)
	{
		po.val[i][i+j]=1;
	}
	
	bool flag=false;
	pre.val[0][0]=1;
	for(int i=1;i<=n;i++)
	{
		long long l,r;
		int len;
		scanf("%I64d%I64d%d",&l,&r,&len);
		if(r>=k)
		{
			r=k;
			flag=true;
		}
		po.n=len;
		po.m=len;
		pre.n=len;
		pre.m=len;
		
		now=quickpow(po,r-l);  
        for(int j=len+1;j<=15;j++)
		pre.val[j][0]=0;
        now=quickmul(now,pre);  
        for(int j=0;j<=len;j++)  
        {  
            pre.val[j][0]=now.val[j][0];  
        }  
		if(flag) break;
	}
	printf("%I64d\n",now.val[0][0]);
}