URAL

题意：

演队在口试中非常不幸。在42道考题中，他恰好没有准备最后一道题，而刚好被问到的正是那道题。演队坐在教授面前，一句话也说不出来。但教授心情很好，给了演队最后一次通过考试的机会。他让这个可怜的学生说出考试要考的科目。不幸的是，演队想不起这个科目名字，尽管他记得科目里有诸如安全、程序、设备、可能还有信息学……

为了准备复试，演队决定记住这门课的名字。为了更好地记住那根长字符串，他决定把它分解成回文，并分别学习每个回文。当然，分解过程中的回文数必须尽可能少。

Input

输入一行字符串表示为这门课的名字。这是由小写英文字母组成的非空行。这一行的长度最多是4000个字符。

Output

 第一行输出可以分解科目名称的最小的回文字符串数目。在第二行输出回文所有的回文字符串，由空格分隔。如果有几个答案是可能的，输出其中任何一个。

Input

pasoib

Output

6
p a s o i b

Input

zzzqxx

Output

3
zzz q xx

Input

wasitacatisaw

Output

1
wasitacatisaw

题解：

可以对每一个区间[l,r]用哈希赋一个唯一的值，对区间[l,r]正序哈希一个值，逆序哈希一个值。那么如果区间[l,r]是回文串，那么这个区间的正序哈希值应该等于逆序哈希值

dp[i]=min(dp[j-1]+1,dp[i]),dp[i]代表从1-i区间的回文序列数量

这个状态转移方程就是当区间[j,i]是回文串的时候

如果不会哈希，也可以用一个二维数组来记录一下区间[l,r]是不是回文串，判断回文串就用while循环（这种方法见代码2）

代码1：

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
#include<map>
#define mem(a,x) memset(a,x,sizeof(a))
using namespace std;
const int INF=0x3f3f3f3f;
const int maxn=4005;
const int mod=1000000009;
const int base=13333;
typedef long long ll;
ll dp[maxn];//从1--i中回文串的最少个数
ll h1[maxn],h2[maxn],p[maxn],n;
ll pre[maxn];
char s[maxn];
string str[maxn];
//找出来[l,r]这个区间正序的哈希值
ll get1(ll l,ll r)
{
    return h1[r]-h1[l-1]*p[r-l+1];
}
//找出来[l,r]这个区间倒序的哈希值
ll get2(ll l,ll r)
{
    return h2[r]-h2[l-1]*p[r-l+1];
}
//如果区间[l,r]的正序逆序哈希值一样，那么这个区间就是回文串
bool check(ll i,ll j)
{
    if(get1(i,j)==get2(n-j+1,n-i+1))
        return true;
    return false;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    memset(dp,INF,sizeof dp);
    dp[0]=0;
    cin>>(s+1);
    n=strlen(s+1);
    p[0]=1;
    for(ll i=1; i<=n; i++)
    {
        h1[i]=h1[i-1]*base-s[i]-'a'+1;
        h2[i]=h2[i-1]*base-s[n+1-i]-'a'+1;
        p[i]=p[i-1]*base;
    }
    for(ll i=1; i<=n; i++)
    {
        for(ll j=1; j<=i; j++)
        {
            if(check(j,i))
            {
                if(dp[i]>(dp[j-1]+1))
                {
                    pre[i]=j;  //记录路径
                    dp[i]=dp[j-1]+1;
                }
            }
        }
    }
    cout<<dp[n]<<endl;
    int id=0;
    int now=n;
    while(now)
    {
        for(int i=pre[now]; i<=now; i++)
            str[id]+=s[i];  //str串记录回文串
        now=pre[now]-1;
        id++;
    }
    for(int i=id-1; i>=0; i--)
    {
        if(i!=0)
            cout<<str[i]<<' ';
        else
            cout<<str[i]<<endl;
    }
}

代码2：（参考：https://blog.csdn.net/zmx354/article/details/20078995）

#include <iostream>

#include <algorithm>

#include <cstdlib>

#include <cstdio>

#include <cstring>

#include <queue>

#include <cmath>

#include <stack>

 

#pragma comment(linker, "/STACK:1024000000");

#define LL long long int

#define ULL unsigned long long int

#define _LL __int64

#define INF 0x3f3f3f3f

#define Mod 1000000009

 

using namespace std;

 

char s[4010];

 

bool dp[4001][4001];

 

int ans[4010];

 

int di[4010];

 

void Output(int l)

{

    if(l == 0)

        return ;

 

    Output(di[l]);

 

    if(di[l] != 0)

        printf(" ");

 

    for(int i = di[l]+1;i <= l; ++i)

    {

        printf("%c",s[i]);

    }

}

 

int main()

{

    int l,i,j,h,e;

 

    scanf("%s",s+1);

 

    l = strlen(s+1);

 

    memset(dp,false,sizeof(dp));

 

    for(i = 1;i <= l; ++i)

    {

        dp[i][i] = true;

        h = i-1;

        e = i+1;

 

        while(1 <= h && e <= l && s[h] == s[e])

        {

            dp[h][e] = true;

            h--,e++;

        }

 

        h = i,e = i+1;

 

        while(1 <= h && e <= l && s[h] == s[e])

        {

            dp[h][e] = true;

            h--,e++;

        }

    }

 

    memset(ans,INF,sizeof(ans));

 

    ans[0] = 0;

 

    di[1] = 0;

 

    for(i = 1;i <= l; ++i)

    {

        for(j = i;j >= 1; --j)

        {

            if(dp[j][i])

            {

                if(ans[i] > ans[j-1]+1)

                {

                    ans[i] = ans[j-1]+1;

                    di[i] = j-1;

                }

            }

        }

    }

 

    printf("%d
",ans[l]);

 

    Output(l);

 

    puts("");

 

    return 0;

}