Ural 1635 Mnemonics and Palindromes(DP)

题目地址:Ural 1635

又是输出路径的DP。。。连着做了好多个了。。

状态转移还是挺简单的。要先预处理出来所有的回文串,tag[i][j]为1表示字符串i--j是一个回文串,否则不是回文串。预处理时要用n^2的方法,即枚举回文串中间,可以分奇数和偶数两种分别求一次。

然后dp转移方程为,若tag[j][i]==1,dp[i]=min(dp[i],dp[j-1]+1);

对于最令人讨厌的路径输出,可以用pre来记录回文串前驱分裂点,然后根据这些分裂点来输出。

代码如下:

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <queue>
#include <map>
#include <set>
#include <algorithm>

using namespace std;
#define LL __int64
const int INF=0x3f3f3f3f;
char s[5000];
int dp[5000], tag[4001][4001], len, pre[4001], a[4001];
void init()
{
    int i, j, k, l, r;
    memset(tag,0,sizeof(tag));
    for(i=0;i<len;i++)
        tag[i][i]=1;
    for(i=1;i<len;i++)
    {
        for(j=1;j<=i;j++)
        {
            l=i-j;r=i+j;
            if(r>=len) break;
            if(s[l]==s[r])
            {
                tag[l][r]=1;
            }
            else break;
        }
    }
    for(i=0;i<len-1;i++)
    {
        if(s[i]==s[i+1])
        {
            tag[i][i+1]=1;
            for(j=1;j<=i;j++)
            {
                l=i-j;r=i+j+1;
                if(r>=len) break;
                if(s[l]==s[r])
                {
                    tag[l][r]=1;
                }
                else
                    break;
            }
        }
    }

}
int main()
{
    int i, j, k, cnt;
    scanf("%s",s);
    len=strlen(s);
    init();
    dp[0]=0;
    memset(pre,-1,sizeof(pre));
    for(i=1;i<=len;i++)
    {
        dp[i]=dp[i-1]+1;
        pre[i]=i-1;
        for(j=1;j<i;j++)
        {
            if(tag[j-1][i-1])
            {
                if(dp[i]>dp[j-1]+1)
                {
                    dp[i]=dp[j-1]+1;
                    pre[i]=j-1;
                }
            }
        }
    }
    printf("%d\n",dp[len]);
    cnt=0;
    for(i=len;i!=-1;i=pre[i])
    {
        a[++cnt]=i;
        //printf("%d ",a[cnt-1]);
    }
    sort(a+1,a+cnt+1);
    /*for(i=1;i<=cnt;i++)
    {
        printf("%d ",a[i]);
    }*/
    for(i=2;i<=cnt;i++)
    {
        for(j=a[i-1];j<a[i];j++)
        {
            printf("%c",s[j]);
        }
        if(i!=cnt)
        printf(" ");
        else
            puts("");
    }
    return 0;
}
时间: 2024-10-12 09:24:43

Ural 1635 Mnemonics and Palindromes(DP)的相关文章

ural Mnemonics and Palindromes (dp)

http://acm.timus.ru/problem.aspx?space=1&num=1635 给出一个字符串,将这个字符串分成尽量少的回文串. 起初没有思路,想着应该先预处理出所有的回文串,然后进行dp.但是字符串的长度是4000,O(n^3)肯定不行,其实可以转化为O(n^2),就是枚举中点而不是枚举起点和终点,又NC了吧. 然后就是线性的dp了.dp[i]表示到第i位为止最少的回文串数,那么dp[i] = min(dp[i],dp[j+1]+1),j < i 且i到j也是回文串.

回文串+回溯法 URAL 1635 Mnemonics and Palindromes

题目传送门 1 /* 2 题意:给出一个长为n的仅由小写英文字母组成的字符串,求它的回文串划分的元素的最小个数,并按顺序输出此划分方案 3 回文串+回溯:dp[i] 表示前i+1个字符(从0开始)最少需要划分的数量,最大值是i+1,即单个回文串: 4 之前设置ok[j][j+i] 判断从j到j+i的字符是否为回文串(注意两个for的顺序,为满足ok[j][j+i] = ok[j+1][j+i-1]) 5 最后枚举找到最优划分点,用pre[i]记录前一个位置,print函数 输出空格 6 */ 7

Ural 1260 A nudnik photographer(DP)

A nudnik photographer 大意: 对1到N这些数进行排列,1必须要在最左边,相邻的两个数之间的差值不能超过2,问有多少种排列的方法. 思路: 对座位进行DP,当第一个是1,第二个是2的时候,组合为dp[i-1]:当第一个是1,第二个是3的时候,第三个也确定了是2,组合为dp[i-3]:还有最后一种情况是1357--8642. 所以DP方程为dp[i] = dp[i-1]+dp[i-3]+1. #include <stdio.h> int n; int dp[100]; int

Ural 1081 Binary Lexicographic Sequence(DP)

题目地址:Ural 1081 先用dp求出每个长度下的合法序列(开头为1)的个数.然后求前缀和.会发现正好是一个斐波那契数列.然后每次判断是否大于此时长度下的最少个数,若大于,说明这一位肯定是1,若小于,则肯定是0.就这样不断输出出来即可. 代码如下: #include <iostream> #include <cstdio> #include <string> #include <cstring> #include <stdlib.h> #in

【uva-11584】Partitioning by Palindromes(dp)

粗略的复杂度是L^3,长度最大是1000,,没敢做,之后发现其实这个复杂度的系数也不大,可以过,而且很快. dp[j] = dp[i - 1] + 1 (if(str[i] ~ str[j]为回文) 14327451 11584 Partitioning by Palindromes Accepted C++ 0.052 2014-10-09 09:33:17 #include<set> #include<map> #include<stack> #include<

uva 11584 Partitioning by Palindromes(dp)

题目链接 题意:给定一个字符串,分解成多个子串,每个子串都是回文串,问最少能分成多少个子串. 题解: dp[i]表示前i个字符串分割成最少回文子串的数量: 0<=j<=i;如果字符串从j到i是回文串,那么dp[i]=min(dp[i],dp[j-1]+1); #include <iostream> using namespace std; int dp[1005]; string s; bool ok(int j,int i) { while(j<=i) { if(s[j]!

11584 - Partitioning by Palindromes(DP)

和上一题 "照明系统设计"类似,我们可以逐步递推出最优解,d[i] 表示1~i个字符的最优解,那么d[i] = min(d[i],d[j] + 1)|当s[j+1~i]为回文串时. 大家可以自行打印d这个数组,来体会一下状态的转移情况. 代码如下: #include<bits/stdc++.h> using namespace std; const int maxn = 1000 + 10; const int INF = 2000000000; int T,n,cnt[m

【UVa】Partitioning by Palindromes(dp)

http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=27&page=show_problem&problem=2549 设w[i,j]为i-j能分割成的最少回文串 f[i]为前i个字符能够分成的最少回文串 w[i,j]=1 当w[i+1,j-1]==1 && s[i]==s[j] 或 i==j-1 && s[i]==s[j] w[i,j]=

Ural 1353 Milliard Vasya&#39;s Function(DP)

题目地址:Ural 1353 定义dp[i][j],表示当前位数为i位时,各位数和为j的个数. 对于第i位数来说,总可以看成在前i-1位后面加上一个0~9,所以状态转移方程就很容易出来了: dp[i][j]=dp[i][j]+dp[i][j-1]+dp[i][j-2]+.......+dp[i][j-9]: 最后统计即可. 代码如下: #include <iostream> #include <cstdio> #include <string> #include <