[NOIP模拟题][DFS][DP]

T1

给定一棵树，定义一棵子树美丽当且仅当子树所以节点编号为连续整数区间，求美丽子树个数

dfs记录每一棵子树的总节点数，最大编号，最小编号，若max-min+1=cnt,则ans++

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cctype>
using namespace std;
const int maxn=1e5+5;
int n,edge,ans,cnt[maxn],to[maxn],nxt[maxn],head[maxn],ind[maxn],maxnum[maxn],minnum[maxn];
int readint()
{
    int x=0; char ch=getchar();
    while (!isdigit(ch)) ch=getchar();
    while (isdigit(ch)) {x=x*10+ch-'0'; ch=getchar();}
    return x;
}
void edge_add(int u,int v)
{
    to[++edge]=v; nxt[edge]=head[u]; head[u]=edge;
}
void dfs(int u)
{
    cnt[u]=1; maxnum[u]=minnum[u]=u;
    for (int E=head[u];E;E=nxt[E])
    {
        int v=to[E]; dfs(v); cnt[u]+=cnt[v];
        maxnum[u]=max(maxnum[u],maxnum[v]);
        minnum[u]=min(minnum[u],minnum[v]);
    }
    if (maxnum[u]-minnum[u]+1==cnt[u]) ans++; 
}
int main()
{
    freopen("A.in","r",stdin);
    freopen("A.out","w",stdout);
    n=readint();
    for (int i=1;i<n;i++)
    {
        int u,v;
        u=readint(); v=readint();
        edge_add(u,v); ind[v]++; 
    }
    for (int i=1;i<=n;i++) if (!ind[i])
    {
        dfs(i); break;
    }
    printf("%d",ans);
    return 0;
}

T2

给定一个字符串S，由’I”D”?’组成，I表示当前位置应该上升，D表示下降，?任意，求满足条件的1~n的排列数

f[i][j]表示填了1~i,最后一位为j的方案数
case ‘I’:i-1位比j小，那么由f[i-1][1~j-1]转移过来
case ‘D’i-1位比j大，哪么由f[i-1][j~i-1]转移过来
case ‘?” 两种方案相加
这里解释一下，实际上要填j的时候，我们是把前面所有大于等于j的数都加一，这样既保证总共i个数，又给给j腾了位置出来，这也是我一开始我没有想到的，所以考试的时候我直接认为这个方程是错误的，会选重
前缀和记录一下即可O($n^2$),本题不需要滚动数组

#include <cstdio>
#include<cstring>
using namespace std;
const int mod=1e9+7,maxn=1e3+5;
int cur,dp[2][maxn],ans;
char S[maxn];
int main() 
{
    freopen("B.in","r",stdin);
    freopen("B.out","w",stdout);
    dp[0][1] = 1;
    scanf("%s",S); int len=strlen(S); len++;
    for (int i=2;i<=len;i++)
    {
        cur^=1;
        for (int j=1;j<i;j++) dp[cur^1][j]+=dp[cur^1][j-1],dp[cur^1][j]%=mod,dp[cur][j]=0;
        switch (S[i-2])
        {
            case 'I':for (int j=2;j<=i;j++) dp[cur][j]=dp[cur^1][j-1],dp[cur][j]%=mod;break;
            case 'D':for(int j=1;j<i;j++) dp[cur][j]=dp[cur^1][i-1]-dp[cur^1][j-1]+mod,dp[cur][j]%=mod;break;
            case '?':
                {
                  for(int j=2;j<=i;j++) dp[cur][j]=dp[cur^1][j-1],dp[cur][j]%=mod;
                  for(int j=1;j<i;j++) dp[cur][j]+=dp[cur^1][i-1]-dp[cur^1][j-1]+mod,dp[cur][j]%=mod;
                }
        }
    }
    for(int i=1;i<=len;i++) ans=(ans+dp[cur][i])%mod;
    printf("%d",ans);
    return 0;
} 

T3

给定两个字符串A,B，定义L为A,B最长公共子序列长度，求所有A中长为L的子序列是B的子序列的情况

我之前还以为最长公共子序列是连续的，所以根本没有想过用LCS来乱搞

正解，首先dp[i][j]表示A,B最长公共子序列长度，O(lenA*lenB)预处理出
接下来，f[i][j]表示A串i位置以前，长度为dp[i][j]的子序列，在B串j位置以前的总数，很明显答案即为f[lenA][lenB]
考虑如何转移
首先如果dp[i-1][j]=dp[i][j]，那么f[i][j]可以直接由f[i-1][j]转移过来，这种情况即为不选A[i]
再考虑选A[i]，那我们应该找到B串最靠近j位置的A[i]的位置，因为这样子选了A[i]之后才能再B中匹配，假设这个位置为pos，如果满足dp[i][j]=dp[i-1][pos-1]+1的话，那么状态就可以转移过来了，因为这样才确保是i和p导致最长公共子序列的产生

#include<cstdio> 
#include<cstring> 
#include<algorithm>
using namespace std;
const int maxn=1e3+5,mod=1e9+7;
int lenA,lenB,f[maxn][maxn],dp[maxn][maxn],pre[maxn][26],pos[26];
char A[maxn],B[maxn];
void init()
{
    for (int i=0;i<=lenA;i++) f[i][0]=1;
    for (int i=0;i<=lenB;i++) f[0][i]=1;
}
int main()
{
    freopen("C.in","r",stdin);
    freopen("C.out","w",stdout);
    scanf("%s %s",A+1,B+1);
    lenA=strlen(A+1); lenB=strlen(B+1);
    for (int i=1;i<=lenA;i++)
      for (int j=1;j<=lenB;j++)
        if (A[i]==B[j]) dp[i][j]=dp[i-1][j-1]+1;
        else dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
    for (int i=1;i<=lenB;i++)
    {
        pos[B[i]-'a']=i;
        for (int j=0;j<26;j++) pre[i][j]=pos[j];
    }
    init();
    for (int i=1;i<=lenA;i++)
      for (int j=1;j<=lenB;j++)
      {
        if (dp[i][j]==dp[i-1][j]) f[i][j]=f[i-1][j];
        int p=pre[j][A[i]-'a'];
        if (p&&dp[i][j]==dp[i-1][p-1]+1) f[i][j]=(f[i][j]+f[i-1][p-1])%mod;
      }
    printf("%d",f[lenA][lenB]);
    return 0;
}