ACM: uva 1362 -&n…

Exploring Pyramids

Archaeologists have discovered a new set of hidden
caves in one of the Egyptian pyramids. The decryption of ancient
hieroglyphs on the walls nearby showed that the caves structure is
as follows. There
are n caves in a pyramid,
connected by narrow passages, one of the caves is connected by a
passage to the outer world. The system of the passages is organized
in such a way, that there is exactly one way to get from outside to
each cave along passages. All caves are located in the basement of
the pyramid, so we can consider them being located in the same
plane. Passages do not intersect. Each cave has its walls colored
in one of several various colors.
The scientists have decided to create a more
detailed description of the caves, so they decided to use an
exploring robot. The robot they are planning to use has two types
of memory - the output tape, which is used for writing down the
description of the caves, and the operating memory organized as a
stack.
The robot first enters the cave connected to the
outer world along the passage. When it travels along any passage
for the first time, it puts its description on the top of its
stack. When the robot enters any cave, it prints the color of its
walls to its output tape. After that it chooses the leftmost
passage among those that it has not yet travelled and goes along
it. If there is no such passage, the robot takes the passage
description from the top of its stack and travels along it in the
reverse direction. The robot's task is over when it returns to the
outside of the pyramid. It is easy to see that during its trip the
robot visits each cave at least once and travels along each passage
exactly once in each direction.
The scientists have sent the robot to its mission.
After it returned they started to study the output tape. What a
great disappointment they have had after they have understood that
the output tape does not describe the cave system uniquely. Now
they have a new problem - they want to know how many different cave
systems could have produced the output tape they have. Help them to
find that out.
Since the requested number can be quite large, you
should output it modulo 1 000 000 000. Please note, that the
absolute locations of the caves are not important, but their
relative locations are important, so the caves (c) and (d) on the
picture below are considered different.




 
Input 
The input file contains several test cases, and
each of them consists of a single line with the output tape that
the archaeologists have. The output tape is the sequence of colors
of caves in order the robot visited them. The colors are denoted by
capital letters of the English alphabet. The length of the tape
does not exceed 300 characters.
Output 
For each input case, write to the output a single
line containing one integer number - the number of different cave
systems (modulo 1 000 000 000) that could produce the output
tape.
Sample
Input 
ABABABA
AB
Sample
Output 
5
0
 

题意: 给定一个字符序列, 要求在一棵多叉树上, 每次尽量往左走, 走不通了就回溯, 把每个节点的字母

     
记录下来, 可以得到一个序列, 问给定的序列可以与多少棵树对应.

 

解题思路:

      
1. 典型的记忆化索搜题, 设dp[i][j]表示第i个字符到第j个字符对应的树的个数, 边界dp[i][i]=1

         
并且str[i]!=str[j]时, dp[i][j]=0,因为最后回溯会回到起点.

       2.
分析: 左右分即可. 将当前序列str[i]~str[j]分成两部分, str[i]~str[k],
str[k]~str[j];

         
第一部分必须满足str[i] == str[k]; 则这部分的序列对应str[i+1]~str[k-1];

         
第一部分的解: dp[i+1][k-1], 第二部分相应的解: dp[k][j]; (两部分独立, 满足乘法法则)

         
得方程 dp[i][j] = sum(dp[i+1][k-1]*dp[k][j] |
i+2<=k<=j, str[i]=str[k]=str[j]);

 

代码:

#include <cstdio>

#include <iostream>

#include <cstring>

using namespace std;

#define MAX 305

#define MOD 1000000000

typedef long long ll;

char str[MAX];

int dp[MAX][MAX];

int DP(int i, int j)

{

 if(i == j) return 1;

 if(str[i] != str[j]) return 0;

 if(dp[i][j] != -1) return dp[i][j];

 int ans = 0;

 for(int k = i+2; k <= j;
++k)

  if(str[i] == str[k])

   ans = (ans +
(ll)DP(i+1, k-1)*(ll)DP(k, j))%MOD;

 

 dp[i][j] = ans;

 return dp[i][j];

}

int main()

{

// freopen("input.txt", "r", stdin);

 while(scanf("%s", str) != EOF)

 {

  memset(dp, -1,
sizeof(dp));

  printf("%d\n", DP(0,
strlen(str)-1));

 }

 return 0;

}