Coloring Brackets CF-149D（区间DP）

题意：

给定合法括号序列，可以给括号涂三种颜色：红色，蓝色，不上色。涂色需要满足以下两个要求：

①匹配括号必须一个上色一个不上色。

②相邻括号不能上同一种颜色，但可以同时不上色。

求上色方案数。

思路：

$dp[i][j][k][l]$表示区间$(i,j)$中$i$上颜色$k$，$j$上颜色$l$的方案数。分三种情况：

①$i$和$j$相邻，则可以保证$i$和$j$匹配，那么$dp[i][j][0][1]=dp[i][j][0][2]=dp[i][j][1][0]=dp[i][j][2][0]=1$。

②$i$和$j$匹配，递归求得$dp[i+1][j-1][k][l]$的相应的方案数，转移得到：

　　$dp[i][j][0][1] += dp[i + 1][j - 1][k][0] + dp[i + 1][j - 1][k][2]$

　　$dp[i][j][0][2] += dp[i + 1][j - 1][k][0] + dp[i + 1][j - 1][k][1]$

　　$dp[i][j][1][0] += dp[i + 1][j - 1][0][k] + dp[i + 1][j - 1][2][k]$

　　$dp[i][j][2][0] += dp[i + 1][j - 1][0][k] + dp[i + 1][j - 1][1][k]$

③$i$和$j$不匹配，那么找到i的匹配点，将$(i,j)$区间拆分成$(i,mat[i])$和$(mat[i]+1,j)$，可以保证，每个区间内可以找到自己的匹配，不存在交叉匹配。

　　$dp[i][j][k][l]=dp[i][mat[i]][k][u]*dp[mat[i]+1][j][o][l]$

代码：

//#include<bits/stdc++.h>
#include <set>
#include <map>
#include <stack>
#include <cmath>
#include <queue>
#include <cstdio>
#include <string>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
 
#define ll long long
#define pll pair<ll,ll>
#define pii pair<int,int>
#define bug printf("*********
")
#define FIN freopen("input.txt","r",stdin);
#define FON freopen("output.txt","w+",stdout);
#define IO ios::sync_with_stdio(false),cin.tie(0)
#define ls root<<1
#define rs root<<1|1
#define Q(a) cout<<a<<endl
 
using namespace std;
const int inf = 2e9 + 7;
const ll Inf = 1e18 + 7;
const int maxn = 700 + 5;
const int mod = 1e9 + 7;
 
char s[maxn];
int mat[maxn];
ll dp[maxn][maxn][5][5];
stack<int>sta;
 
void DP(int i, int j)
{
    if (i + 1 == j)//最小括号
    {
        for (int k = 1; k <= 2; ++k) dp[i][j][k][0] = dp[i][j][0][k] = 1;
        return;
    }
    if (mat[i] == j)//匹配的括号
    {
        DP(i + 1, j - 1);
        for (int k = 0; k <= 2; ++k)
        {
            dp[i][j][0][1] += dp[i + 1][j - 1][k][0] + dp[i + 1][j - 1][k][2];
            dp[i][j][0][2] += dp[i + 1][j - 1][k][0] + dp[i + 1][j - 1][k][1];
            dp[i][j][1][0] += dp[i + 1][j - 1][0][k] + dp[i + 1][j - 1][2][k];
            dp[i][j][2][0] += dp[i + 1][j - 1][0][k] + dp[i + 1][j - 1][1][k];
        }
        dp[i][j][0][1] %= mod;
        dp[i][j][0][2] %= mod;
        dp[i][j][1][0] %= mod;
        dp[i][j][2][0] %= mod;
        return;
    }
    //划分区间，两个区间不存在交叉匹配
    DP(i, mat[i]);
    DP(mat[i] + 1, j);
    for (int k = 0; k <= 2; ++k)
        for (int l = 0; l <= 2; ++l)
            for (int u = 0; u <= 2; ++u)
                for (int o = 0; o <= 2; ++o)
                {
                    if (l == u && l != 0)   continue;
                    dp[i][j][k][o] += dp[i][mat[i]][k][l] * dp[mat[i] + 1][j][u][o];
                    dp[i][j][k][o] %= mod;
                }
}
 
int main()
{
    memset(dp, 0, sizeof dp);
    scanf("%s", s);
    int len = strlen(s);
    for (int i = 0; i < len; ++i)//配对
    {
        if (s[i] == '(')    sta.push(i);
        if (s[i] == ')')
        {
            mat[i] = sta.top();
            mat[sta.top()] = i;
            sta.pop();
        }
    }
    DP(0, len-1);
    ll ans = 0;
    for(int i=0;i<=2;++i)
        for (int j = 0; j <= 2; ++j)
        {
            ans += dp[0][len - 1][i][j];
            ans %= mod;
        }
    printf("%lld
", ans);
}