排列组合，递推，记忆化搜索（葛伦堡博物馆，LA 4123）

就是容易发现一共有numo=(n-4)/2个O，一共有numr=(n+4)/2个R。然后不能有两个O连在一起，头和尾同时为O也不行。就是插空法啦。现在C（numr+1,numo）-C（numr-1，numo-2）。意思是numr+1个空里选numo个减去numr-1个空里选numo-2个。即随便插空减去头和尾都是O的情况。由于（numr-numo）<5所以组合数不会很大，long long完全够用。然后n<4以及奇数的情况直接输出0就好了。

书上用的是递推，记忆化搜索。虽然麻烦但是有助于锻炼思维。

题目有一个隐含条件：不能有两个O连在一起     <==>     一定有4个R连在一起（头和尾也算连在一起）。

第一个方法是利用：     不能有两个O连在一起。

定义状态dp[i][j][p][q]。表示有i个R，j个O，头是p，尾是q。（0表示R，1表示O）。
这样就有状态转移方程

当q=1时dp[i][j][p][1]=dp[i][j-1][p][0]。表示如果最后一位是O那么只能由最后一位是R转移过来。

当q=0时dp[i][j][p][0]=dp[i-1][j][p][0]+dp[i-1][j][p][1]。表示如果最后一位是R，就能由最后一位是O或者R转移过来。

由于|i-j|<5，所以可以剪枝，直接返回0。

而递归边界就是dp[1][0][0][0]=dp[0][1][1][1]=1。以及（i<0||j<0）时直接返回0。

答案就是dp[numr][numo][0][0]+dp[numr][numo][1][0]+dp[numr][numo][0][1]。

由于有剪枝所以时间复杂度为O（n）。

第二个方法是利用：     一定有4个R连在一起。（我们知道头和尾连在一起也算，但是编程时这种情况当成只有3个R连在一起，具体情况如下）

定义状态dp[i][j][k]。表示有i个R，j对R，头是k，尾是R。

这样就有状态转移方程dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k]。其中第一项表示在末尾添加OR，第二项表示在末尾添加R。

而递归边界就是dp[1][0][0]=dp[1][0][1]=1。分别表示OR和R。以及（i<0||j<0）时直接返回0。

答案就是dp[numr][4][0]+dp[numr][4][1]+dp[numr][3][0]。分别表示（头是R，尾是O），（头是O，尾是R），（头尾都是R）。

两个方法都可以用记忆化搜索来实现。

排列组合

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

ll L,kase;

ll C(ll m,ll n)
{
    n=min(n,m-n);
    ll ans=1;
    for(ll i=0;i<n;i++)
        ans*=(m-i);
    for(ll i=1;i<=n;i++)
        ans/=i;
    return ans;
}

ll solve(ll num)
{
    if(num<4||num&1) return 0;
    if(num==4) return 1;
    if(num==6) return 6;
    ll numo=(num-4)/2;
    ll numr=num-numo;
    return C(numr+1,numo)-C(numr-1,numo-2);
}

int main()
{
    while(scanf("%lld",&L)==1&&L)
        printf("Case %lld: %lld\n",++kase,solve(L));
    return 0;
}

方法一：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

ll L,kase;
ll dp[1010][1010][2][2];

ll f(ll n1,ll n2,ll p,ll q)
{
    ll& ans=dp[n1][n2][p][q];
    if(ans!=-1) return ans;
    if(q==1) return ans=!n2?0:f(n1,n2-1,p,0);
    else return ans=!n1?0:f(n1-1,n2,p,0)+f(n1-1,n2,p,1);
}

ll solve(ll num)
{
    if(num<4||num&1) return 0;
    ll numo=(num-4)/2;
    ll numr=(num+4)/2;
    return f(numr,numo,0,0)+f(numr,numo,1,0)+f(numr,numo,0,1);
}

int main()
{
    memset(dp,-1,sizeof(dp));
    dp[1][0][0][0]=dp[0][1][1][1]=1;
    while(scanf("%lld",&L)==1&&L)
        printf("Case %lld: %lld\n",++kase,solve(L));
    return 0;
}

方法二：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

ll L,kase;
ll dp[1010][1010][2][2];

ll f(ll n1,ll n2,ll p,ll q)
{
    ll& ans=dp[n1][n2][p][q];
    if(ans!=-1) return ans;
    if(abs(n1-n2)>5) return ans=0;
    if(q==1) return ans=!n2?0:f(n1,n2-1,p,0);
    else return ans=!n1?0:f(n1-1,n2,p,0)+f(n1-1,n2,p,1);
}

ll solve(ll num)
{
    if(num<4||num&1) return 0;
    ll numo=(num-4)/2;
    ll numr=(num+4)/2;
    return f(numr,numo,0,0)+f(numr,numo,1,0)+f(numr,numo,0,1);
}

int main()
{
    memset(dp,-1,sizeof(dp));
    dp[1][0][0][0]=dp[0][1][1][1]=1;
    while(scanf("%lld",&L)==1&&L)
        printf("Case %lld: %lld\n",++kase,solve(L));
    return 0;
}