codeforce 149D:Coloring Brackets（区间dp）

题目链接：点击打开链接

参考博客：点击打开链接

题目大意：

给你一串匹配的括号，然后可以给括号上色，可以选择上红色，上蓝色，或者不上色。求最终的方案数是多少。

上色有一定的规则：

（1）：每一对括号只能其中一个上色。

（2）：相邻的两个不能上同样的颜色，可以都不上色。

题意解析：

算是近期接触到难度最大的一道区间dp题。看着别人的代码，最终理解倒是不太困难，就是细节方面太多。要考虑的点很多。

dp[l][r][i][j]表示l到r区间l上i颜色，r上j颜色的方案数。颜色可以用0,1,2来表示，分别表示无色，蓝色，红色。

代码的实现靠递归，刚开始看了大神博客的转移方程以后，直接去写递推式，感觉越写越不对。深搜有时候真的好用。

现在问题就是每一种情况的状态转移方程，代码里详写。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <algorithm>
#include <set>
#define next ne
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
int mod=1e9+7;
int n,m,k;
char a[1000];
int match[1000];
int tmp[1000];
ll dp[710][710][4][4];
void getmatch(int len)
{
    int g=0;                            //这个函数求解一些神奇的东西,也就是
    for(int i=0;i<len;i++)              //每个括号与它相匹配的扩号是哪一个,
    {                                   //注意不是简单的l是'('和r是')'就行
        if(a[i]=='(')                   //要找到与跟它在序列里"匹配"的扩号的位置
            tmp[g++]=i;                 //具体可以自己打印看一下
        else
        {
            match[i]=tmp[g-1];
            match[tmp[g-1]]=i;
            g--;
        }
    }
}
void dfs(int l,int r)
{
    if(l+1==r)                          //这个应该不用多解释了吧
    {
        dp[l][r][0][1]=1;
        dp[l][r][1][0]=1;
        dp[l][r][0][2]=1;
        dp[l][r][2][0]=1;
        return ;
    }
    if(match[l]==r)                     //如果l和当前r正好匹配就深搜一下他们的
    {                                   //中间区间,第一次写的时候只是简单判断了
        dfs(l+1,r-1);                   //一下括号是否配对,结果样例都没过
        for(int i=0;i<3;i++)
        {
            for(int j=0;j<3;j++)        //搞清楚每个状态,应该很容易理解状态转移方程
            {
                if(j!=1)
                dp[l][r][0][1]=(dp[l][r][0][1]+dp[l+1][r-1][i][j])%mod;
                if(i!=1)
                dp[l][r][1][0]=(dp[l][r][1][0]+dp[l+1][r-1][i][j])%mod;
                if(j!=2)
                dp[l][r][0][2]=(dp[l][r][0][2]+dp[l+1][r-1][i][j])%mod;
                if(i!=2)
                dp[l][r][2][0]=(dp[l][r][2][0]+dp[l+1][r-1][i][j])%mod;
            }
        }
        return ;
    }
    else
    {
        int p=match[l];                 //如果不配对,找到当前的与它配对的括号
        dfs(l,p);                       //的位置,分为两个区间分别继续搜索
        dfs(p+1,r);
        for(int i=0;i<3;i++)
        {
            for(int j=0;j<3;j++)
            {
                for(int k=0;k<3;k++)
                {
                    for(int q=0;q<3;q++)        //方案数等于两区间方案数相乘
                    {
                        if(!((k==1&&q==1)||(k==2&&q==2)))   //注意此处为判断相邻位置不能同色
                        dp[l][r][i][j]=(dp[l][r][i][j]+(dp[l][p][i][k]*dp[p+1][r][q][j])%mod)%mod;
                    }
                }
            }
        }
    }
}
int main()
{
    while(scanf(" %s",a)!=EOF)
    {
        memset(dp,0,sizeof(dp));
        int len=strlen(a);
        getmatch(len);          //神奇的函数求一些神奇的东西
        dfs(0,len-1);
        ll ans=0;
        for(int i=0;i<3;i++)
        {
            for(int j=0;j<3;j++)        //找出当前所有方案数总和
            {
                ans=(ans+dp[0][len-1][i][j])%mod;
            }
        }
        printf("%lld\n",ans);
    }
}