第一题 A ：
这棵树由n个节点以及n - 1条有向边构成，每条边都从父亲节点指向儿子节点，保证除了根节点以外的每个节点都有一个唯一的父亲。树上的节点从1到n标号。该树的一棵子树的定义为某个节点以及从该节点出发能够达到的所有节点的集合，显然这棵树共有n棵子树。小A认为一棵有根树是美丽的当且仅当这棵树内节点的标号构成了一个连续的整数区间。现在小A想知道这棵树上共有多少棵美丽的子树。
解：
拿到这道题就一下子冒出来一个想法，记录每一个节点开始的子树的节点最大值、最小值，和节点数。如果max-min+1=sum，那么就成立。于是半个小时后，我就解决了第一题。看来好的想法很重要。自己就冒出来了，还不需要想。
其实也是一个dp。只不过我又用的dfs。
1 #include<iostream>
2 #include<cstdio>
3 #include<string>
4 #include<cstring>
5 #include<algorithm>
6 #define maxn 100005
7 using namespace std;
8 struct tree{
9 int sum,ma,mi;
10 };
11 tree f[maxn];
12 int n,ans;
13 int tot,he[maxn],ne[maxn],to[maxn];
14 bool r[maxn];
15 void add(int a,int b)
16 {
17 tot++;ne[tot]=he[a];to[tot]=b;he[a]=tot;
18 if (!f[a].sum) f[a].sum=1;
19 if (!f[b].sum) f[b].sum=1;
20 if (!f[a].ma) f[a].ma=f[a].mi=a;
21 if (!f[b].ma) f[b].ma=f[b].mi=b;
22 }
23 void dfs(int x)
24 {
25 for (int i=he[x];i;i=ne[i])
26 {
27 int t=to[i];
28 dfs(t);
29 f[x].sum+=f[t].sum;
30 if (f[t].ma>f[x].ma) f[x].ma=f[t].ma;
31 if (f[t].mi<f[x].mi) f[x].mi=f[t].mi;
32 }
33 if (f[x].ma-f[x].mi+1==f[x].sum) ans++;
34 }
35 int main()
36 {
37 freopen("A.in","r",stdin);
38 freopen("A.out","w",stdout);
39 cin>>n;
40 for (int i=1;i<n;i++)
41 {
42 int a,b;
43 scanf("%d%d",&a,&b);
44 r[b]=true;
45 add(a,b);
46 }
47 for (int i=1;i<=n;i++)
48 if (!r[i]){//root
49 dfs(i);break;
50 }
51 printf("%d",ans);
52 return 0;
53 }
第二题 B ：
对于一个排列，考虑相邻的两个元素，如果后面一个比前面一个大，表示这个位置是上升的，用I表示，反之这个位置是下降的，用D表示。如排列3,1,2,7,4,6,5可以表示为DIIDID。
现在给出一个长度为n-1的排列表示，问有多少种1到n的排列满足这种表示。
解：
写不来正解，直接用暴力搜索20%，还被卡了一个点，只有10分。
正解： 用 dp[i][j]表示前 i 个数的第 i 位（最后这一位）放 j 的方案数。（假设前 i 位只放1~ i 数字）有三种情况：
I :第i 位的j 要比上一位大，所以由∑ dp[i-1][k] (1<=k<=j-1) 推来，因为有可能 j 数字在之前填过了，但是不影响结果，因为我们可以认为所有填的>=j的数字都+1，还保证了情况的全面性（即前 i 位可以填> i 的数字）。
D：第 i 位的 j 要比上一位小，所以由∑ dp[i-1][k] (j<k<i-1) 推来，同样的道理，j 数字也可能填过了，也可以认为+1.
?：无所谓第 i 位上的数，可以把以上两种情况的方案数加起来。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define M 1000000007
#define ll long long
using namespace std;
ll dp[5][1005],idx=1,cur=0,ans;
int main()
{
freopen("B.in","r",stdin);
freopen("B.out","w",stdout);
char c=getchar();
dp[0][1]=1;
while (c=='I'||c=='D'||c=='?')
{
cur^=1;idx++;
for (int i=1;i<=idx-1;i++)
{
dp[cur^1][i]+=dp[cur^1][i-1]%M;
dp[cur][i]=0;
}
if (c!='D'){
for (int i=2;i<=idx;i++)
dp[cur][i]=dp[cur^1][i-1]%M;
}
if (c!='I'){//不加else
for (int i=1;i<idx;i++)
dp[cur][i]+=((dp[cur^1][idx-1]-dp[cur^1][i-1])%M+M)%M;
}
c=getchar();//***
}
for (int i=1;i<=idx;i++)
ans=(ans+dp[cur][i])%M;
cout<<ans;
return 0;
}
第三题 C ：
两个字符串分别为X，Y。小A非常开心，但在开心之余她还想考考小K。小A定义L为X与Y的最长公共子序列的长度（子序列在字符串内不一定连续，一个长度为L的字符串有2^L个子序列，包括空子序列）。现在小A取出了X的所有长度为L的子序列，并要求小K回答在这些子序列中，有多少个是Y的子序列。因为答案可能很大，所以小K只需要回答最终答案模10^9 + 7。
解：
首先是一个预处理LCS。然后再dp答案。
LCS：最长公共子序列。用n^2的方法算。
for (int i=1;i<=lena;i++)
for (int j=1;j<=lenb;j++)
{
lcs[i][j]=max(lcs[i-1][j],lcs[i][j-1]);
if (a[i]==b[j]) lcs[i][j]=max(lcs[i][j],lcs[i-1][j-1]+1);
}
然后f[i][j]表示：A串的前 i 个，B 串的前 j 个长度为lcs[i][j]的答案。对于A[i]:
1.没有新贡献，直接是f[i-1][j]
2.由新贡献，即选择 i 后，答案会改变。这时，当 离 j 最近的==A[i]的字符所在位置 p，如果lcs[i-1][p-1]+1==lcs[i][j]则说明，i 加入后，又可以在B 串中找到一个新的答案f[i-1][p-1]。
动态规划比较抽象，所以不容易理解，打表可以帮助理解，还有就是基础不是很牢，没有形成动态规划的基本脑回路。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define maxn 1005
#define M 1000000007
using namespace std;
int lena,lenb,lcs[maxn][maxn],f[maxn][maxn];
int pos[30],pre[maxn][30];
char a[maxn],b[maxn];
int main()
{
freopen("C.in","r",stdin);
freopen("C.out","w",stdout);
scanf("%s",a+1);scanf("%s",b+1);
lena=strlen(a+1);lenb=strlen(b+1);
for (int i=1;i<=lena;i++)
for (int j=1;j<=lenb;j++)
{
lcs[i][j]=max(lcs[i-1][j],lcs[i][j-1]);
if (a[i]==b[j]) lcs[i][j]=max(lcs[i][j],lcs[i-1][j-1]+1);
}
memset(pre,-1,sizeof(pre));
for (int i=1;i<=lenb;i++)
{
pos[b[i]-'a']=i;
for (int j=0;j<26;j++)
pre[i][j]=pos[j];
}
for (int i=0;i<=lena;i++) f[i][0]=1;
for (int i=0;i<=lenb;i++) f[0][i]=1;
for (int i=1;i<=lena;i++)
for (int j=1;j<=lenb;j++)
{
if (lcs[i][j]==lcs[i-1][j]) f[i][j]=(f[i][j]+f[i-1][j])%M;
int p=pre[j][a[i]-'a'];
if (p!=-1&&lcs[i-1][p-1]+1==lcs[i][j]) f[i][j]=(f[i][j]+f[i-1][p-1])%M;
}
printf("%d",f[lena][lenb]);
return 0;
}
