Secret Code

Secret Code

一、题目

【NOIP模拟赛A10】Secret Code

时间限制: 1 Sec  内存限制: 128 MB
提交: 10  解决: 6
[提交][状态][讨论版]

题目描述

农夫John（以后简称“FJ”）有些不想让他的奶牛看见的秘密消息；这条消息是一个长度至少为2仅包含字符A..Z的字符串。为了加密他的消息，FJ对这条消息进行了一系列“操作”。一次对字符串S的“操作”是指去掉S开头的若干个字母（但不是全部）或末尾的若干个字母（但不是全部），然后将原来的S拼接到其开头或末尾。例如，一次对于字符串ABC的操作可能有以下8种结果：

AABC

ABABC

BCABC

CABC

ABCA

ABCAB

ABCBC

ABCC

已知最终加密后的字符串，请计算FJ有多少种可能的方法对某一源字符串进行一次或多次重复的“操作”得到该加密字符串。尽管对一个字符串的不同方法的“操作”可能得到相同的结果，这些方式也应该被视作不同而被分别计数。例如，有4种不同的操作方法从AA得到AAA。

输入

第1行：一个长度不超过100的字符串。

输出

第1行：FJ对某个长度至少为2的源字符串进行一次或多次操作后能够得到该结果字符串的不同方法数，答案可能会很大，答案请对2014求余。如果没有方法得到结果字符串，则输出0。

样例输入

ABABA

样例输出

8

提示

以下是FJ可以得到ABABA的不同方法：

1. Start with ABA
-> AB+ABA 
2. Start with ABA
-> ABA+BA 
3. Start with AB
-> AB+A -> AB+ABA 
4. Start with AB
-> AB+A -> ABA+BA 
5. Start with BA
-> A+BA -> AB+ABA 
6. Start with BA
-> A+BA -> ABA+BA 
7. Start with ABAB
-> ABAB+A 
8. Start with BABA -> A+BABA

二、代码及分析

代码一：

 /*
  * 状态：
  * f[i][j]表示以i为起点以j为终点的字符串出现的次数
  * 最终状态：
  * f[1][n]
  * 初始状态：
  * 初始结果字符串的所有的子字符串出现的次数都为1
  * 因为我们是要用子串得到别的串，而这个子串最开始出现的次数就为1
  * 状态转移方程：
  * f[i][j]+=f[i][k]*f[k+1][j] (i<=k<j)（并且满足短串是长串的头尾字串）;
  *
  * f[1][3]=f[1][1]*f[2][3]+f[1][2]*f[3][3];
  * 短的串要是长的串的子串（并且是那种只截取前面或者只截取后面的那种）
  */

 #include <iostream>
 #include <cstring>
 using namespace std;
 int f[][];
 char s[];
 int len;

 void printRead();
 void readData(){
     scanf("%s",s+);
     len=strlen(s+);
 }

 void printArr_f();
 void initArr_f(){
     //因为任意一个长度不为Len的串都可以作为起始串
     //所以任意一个长度不为Len的串起始可能性都为1
     for(int i=;i<=len;i++){
         for(int j=i;j<=len;j++){
             f[i][j]=;
         }
     }
     //因为必须要截掉头尾，故长度为len的串不行
     //我不可能去用1-n这个字符串去得到别的字符串吧，所以出现次数为0
     f[][len]=;
 }

 //求字符串(c,d)是不是(a,b)的前子字符串
 bool frontSubstring(){

 }

 //求字符串(c,d)是不是(a,b)的后子字符串
 bool backSubstring(){

 }

 void init(){
     readData();
     printRead();
     initArr_f();
     printArr_f();
 }

 void dp(){
     for(int i=len;i>=;i++){
         for(int j=i+;j<=len;j++){
             for(int k=i;k<=j;k++){
                 f[i][j]+=f[i][k]*f[k+][j];
             }
         }
     }
 }

 int main(){
     freopen("src/in.txt","r",stdin);
     init();
     dp();
     return ;
 }

 void printRead(){
     for(int i=;i<=len;i++){
         cout<<s[i];
     }
     cout<<endl;
 }

 void printArr_f(){
     for(int i=;i<=len;i++){
         for(int j=;j<=len;j++){
             cout<<f[i][j]<<" ";
         }
         cout<<endl;
     }
 }

AC代码

 #include<bits/stdc++.h>
 using namespace std;
 char s[];
 int ans[][];
 //ans[i][j]中存储从s中的第i个元素到第j个元素有多少种出现的可能
 bool Front_Maybe(int a,int b,int c,int d)
 {
     for(int i = a;i <= b;i ++)
     {
         if(s[i] != s[c + i - a])    return ;
     }
 //    printf("前面%d %d %d %d\n",a,b,c,d);
     return ;
 }
 bool Behind_Maybe(int a,int b,int c,int d)
 {
     for(int i = b;i >= a;i --)
     {
         if(s[i] != s[d - b + i])    return ;
     }
 //    printf("后面%d %d %d %d\n",a,b,c,d);
     return ;
 }
 int main()
 {
     freopen("src/in.txt","r",stdin);
     scanf("%s",s + );
     int Len = strlen(s + );
     for(int i = ;i < Len;i ++)//起始串的长度
     {
         for(int j = ;j <= Len;j ++)//起始串的起点
         {
             //i是长度，j是起点，那么i+j-1就是终点
             //如果终点大于长度
             if(i + j -  > Len)    continue;
             ans[j][i + j - ] = ;
             //因为任意一个长度不为Len的串都可以作为起始串
             //所以任意一个长度不为Len的串起始可能性都为1
         }
     }
     for(int i = ;i < Len;i ++)//当前要处理串的长度
     {
         for(int j = ;j <= Len;j ++)//当前要处理串的起点
         {
             if(i + j -  > Len)    continue;
             for(int x = ;x < i;x ++)//添加串的长度
             {
                 if(j - x > )//向后加处理串 起点合法
                 {
                     if(Front_Maybe(j - x,j - ,j,j + i - ))
                     {
                         ans[j - x][i + j - ] += ans[j][i + j - ];
                     }
                     if(Behind_Maybe(j - x,j - ,j,j + i - ))
                     {
                         ans[j - x][i + j - ] += ans[j][i + j - ];
                     }
                     ans[j - x][i + j - ] %= ;
                 }
                 if(i + j -  + x <= Len)//向前加处理串 终点合法
                 {
                     if(Front_Maybe(j + i,j + i -  + x,j,j + i - ))
                     {
                         ans[j][i + j -  + x] += ans[j][i + j - ];
                     }
                     if(Behind_Maybe(j + i,j + i -  + x,j,j + i - ))
                     {
                         ans[j][i + j -  + x] += ans[j][i + j - ];
                     }
                     ans[j][i + j -  + x] %= ;
                 }
             }
         }
     }
     printf("%d",ans[][Len]);
     return ;
 }