POJ 2955-Brackets

区间 DP
题目描述:求一个字符串的最长括号匹配子串(非连续)
解题分析:状态转移方程全在题目里,定义了两种括号匹配的子串:
1若s是匹配的字符串,则(s),[s]也是,那么状态转移方程是if(s[i] == '(' && s[j] ==')' || s[i] == '[' && s[j] ==']') dp[i][j] = max(dp[i][j],dp[i + 1][j - 1] + 2);。

2.若a是匹配的字符串,且b也是匹配的字符串,则ab是匹配的字符串。那么状态转移方程式:dp[i][j] = max(dp[i][j],dp[i][k] + dp[k+1][j])(i <= k < j).

先写了一个记忆化搜索的:时间 170ms
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;

const int maxn = 100 + 10;
int dp[maxn][maxn];
char s[maxn];

int dfs(int u,int v)
{
    if(dp[u][v] > -1) return dp[u][v];
    if(u > v) return dp[u][v] = 0;
    if(u == v) return dp[u][v] = 0;
    int ans = 0;
    if((s[u] == '(' && s[v] ==')' || s[u] == '[' && s[v] ==']' ) && v > u)
    {
        ans = max(ans,dfs(u + 1,v - 1) + 2);
    }
    for(int i = u; i < v; i++)
    {
        ans = max(ans,dfs(u,i) + dfs(i + 1,v));
    }
    return dp[u][v] = ans;
}

int main()
{
    while(scanf("%s",s + 1) != EOF)
    {
        if(strcmp(s + 1,"end") == 0) break;
        int n = strlen(s + 1);
        memset(dp,-1,sizeof(dp));
        cout << dfs(1,n) << endl;
    }
    return 0;
}
之后尝试些递推的,想了想,关于循环是顺序还是逆序这个得看状态转移方程,因为最终的答案是dp[1][n],第一维的下标是由值大的下标推出来的,所以第一层循环是逆序,第二位下标由小的递推过来,所以第二层循环是顺序的。简而言之,就是看状态转移方程右边是如何递推出来左边的,从而确定循环的顺序。
代码如下:
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;

const int maxn = 100 + 10;
int dp[maxn][maxn];
char s[maxn];

int main()
{
    while(scanf("%s",s + 1) != EOF)
    {
        if(strcmp(s + 1,"end") == 0) break;
        int n = strlen(s + 1);
        memset(dp,0,sizeof(dp));
        for(int i = n; i >= 1; i--)
        {
            for(int j = i + 1; j <= n; j++)
            {
                for(int k = i; k < j; k++)
                {
                    dp[i][j] = max(dp[i][j],dp[i][k] + dp[k+1][j]);
                }
                if(s[i] == '(' && s[j] ==')' || s[i] == '[' && s[j] ==']')
                {
                    dp[i][j] = max(dp[i][j],dp[i + 1][j - 1] + 2);
                }
            }
        }
        cout << dp[1][n] <<endl;
    }
    return 0;
}
时间47ms,看来还是递推比较快。但无论怎样,记忆化搜索还是迭代的方法都不是绝对的,哪种能更好的A掉这个题,就选哪种。
如果要打印路径的话,代码如下:
void Print(int u,int v)
{
    if(u > v) return;
    if(dp[u + 1][v - 1] + 2 == dp[u][v] && (s[u] == '(' && s[v] ==')' || s[u] == '[' && s[v] ==']' ))
    {
        cout << s[u];
        Print(u + 1,v - 1);
        cout << s[v];
    }
    else
    {
        for(int k = u ; k < v; k++)
        {
            if(dp[u][v] == dp[u][k] + dp[k + 1][v])
            {
                Print(u,k);
                Print(k + 1,v);
                break;
            }
        }
    }
}
全部评论

相关推荐

挣K存W养DOG:我记得好多人说这个公司就是白嫖方案的,现在有大体方案要让你给他展示实现细节了,也是无敌了
点赞 评论 收藏
分享
评论
点赞
收藏
分享

创作者周榜

更多
牛客网
牛客企业服务