P1990-覆盖墙壁

我先是看了一个作者的题解，再根据题解优化得出了新的递推公式，这里先说上述作者的题解（有些不同）

首先：当最后一列被排满以这样结尾的方案种数为F[N-1]

        

以这种结尾的方案种数为F[N-2]

        

那么如果是以L型结尾的应该是如何呢？

分别为：

        

         

但是其实这两种只算一种，最后乘以2就好

所以，当以这样结尾方案种数为G[N-1]（实际上只铺满了一列，还有N-1列没有被铺满，所所以是G[N-1]，原作者是G[N-2]，这里是我和他不同的地方）

         

 那么这样结尾应该怎么算呢？有两种办法

第一种将它铺满为一个矩形，此时C[N-1]=F[N-3]

        

 第二种加上一个矩形，此时G[N-1]=G[N-2]

        

 综上所述：G[N-1]=F[N-3]+G[N-2]，化简为：G[N]=F[N-2]+G[N-1]

总结：F[N]=F[N-1]+F[N-2]+2*G[N-1]

           G[N]=F[N-2]+G[N-1]        记得取模

这样就有一种解决方案，代码如下：

#include<iostream>    //    这是我第一次交的代码，我的是：G[N]=F[N-2]+G[N-1],作者的是：G[N=F[N-1]+G[N-1]，当然这里不一样上面那一行代码也不一样。仔细看看
using namespace std;

const int maxn=1000002;
const int mod=10000;

int f[maxn],g[maxn];

int main()
{
    int n;
    cin>>n;
    f[0]=f[1]=g[2]=1;
    for(int i=2;i<=n;i++)
    {
        f[i]=((f[i-1]+f[i-2])%mod+2*g[i-1]%mod)%mod;
        
        g[i]=(g[i-1]+f[i-2])%mod;
    }
    
    cout<<f[n];
    return 0;
}


#include<iostream>    //作者的源代码
using namespace std;

const int maxn=1000002;
const int mod=10000;

int f[maxn],g[maxn];

int main()
{
	int n;
	
	cin>>n;
	
	f[0]=1;	//g[0]=0
	
	f[1]=g[1]=1;
	
	for(int i=2;i<=n;i++)
	{
		f[i]=((f[i-1]+f[i-2])%mod+2*g[i-2]%mod)%mod;
		
		g[i]=(g[i-1]+f[i-1])%mod;
	}
	
	cout<<f[n];
	
	return 0;
}

接下来说我的优化！！！

首先根据递推公式：

           F[N]=F[N-1]+F[N-2]+2*G[N-1]

           G[N]=F[N-2]+G[N-1]            

G[1]=0，公式推出的。

将G带入F：

F[N]=F[N-1]+F[N-2]+2*G[N-1]        N=2

F[N]=F[N-1]+F[N-2]+2*F[N-3]+2*G[N-2]        N=3

F[N]=F[N-1]+F[N-2]+2*F[N-3]+2*F[N-4]+2*G[N-3]        N=4

F[N]=F[N-1]+F[N-2]+2*F[N-3]+2*F[N-4]+2*F[N-5]+2*G[N-4]        N=5

...

F[N]=F[N-1]+F[N-2]+2*∑F[i]        i[0,N-3]

举例：

F[5]=F[4]+F[3]+2*∑F[i]        i=0,1,2

F[6]=F[5]+F[4]+2*∑F[i]        i=0,1,2,3

F[6]=F[5]+F[4]+(F[5]-F[4]-F[3]+2*F[3])

F[6]=2*F[5]+F[3]

...

F[N]=2*F[N-1]+F[N-3]

代码如下：

#include<iostream>
using namespace std;
int f[1000009];
int main()
{
    int n;
    cin>>n;
    f[1]=1;
    f[2]=2;
    f[3]=5;
    for(int i=4;i<=n;i++)
        f[i]=(2*f[i-1]+f[i-3])%10000;
    cout<<f[n];
    return 0;
}

第一次体会到优化的快乐（虽然算不上什么在这里），当时看题解，有博主也用了这个公式但是博主是玄学来的，评论都在问怎么得来的，我也迷惑，谁知下一秒我就弄出来了🙂