HDU5469(树的dfs)

Antonidas

Time Limit: 8000/4000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 1066    Accepted Submission(s): 303

Problem Description

Given a tree with N vertices and N−1 edges. Each vertex has a single letter Ci. Given a string S, you are to choose two vertices A and B, and make sure the letters catenated on the shortest path from A to B is exactly S. Now, would you mind telling me whether the path exists?

 

Input

The first line is an integer T, the number of test cases.
For each case, the first line is an integer N. Following N−1 lines contains two integers a and b, meaning there is an edge connect vertex a and vertex b.
Next line contains a string C, the length of C is exactly N. String C represents the letter on each vertex.
Next line contains a string S.
1≤T≤200, 1≤N≤104, 1≤a,b≤N, a≠b, |C|=N, 1≤|S|≤104. String C and S both only contain lower case letters.

 

Output

First, please output "Case #k: ", k is the number of test case. See sample output for more detail.
If the path exists, please output “Find”. Otherwise, please output “Impossible”.

 

Sample Input

2

7

1 2

2 3

2 4

1 5

5 6

6 7

abcdefg

dbaefg

5

1 2

2 3

2 4

4 5

abcxy

yxbac

 

Sample Output

Case #1: Find

Case #2: Impossible

 

思路：从树上结点的值为字符串开始字母的结点开始遍历。分从儿子结点和父结点两个方向遍历下一个结点。遍历子结点时加一个剪枝，即向下的延伸长度不不小于剩下字母的长度。

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN=;
vector<int> arc[MAXN];
int n;
int par[MAXN];
int dist[MAXN];
char value[MAXN],s[MAXN];
int len,vis[MAXN];
void dfs1(int u,int fa)
{
    par[u]=fa;
    int mx=;
    for(int i=;i<arc[u].size();i++)
    {
        int to=arc[u][i];
        if(to!=fa)
        {
            dfs1(to,u);
            mx=max(dist[to],mx);
        }
    }
    dist[u]=mx+;
}
bool dfs2(int u,int net)
{
    if(net==len)    return true;
    vis[u]=;
    for(int i=;i<arc[u].size();i++)
    {
        int to=arc[u][i];
        if(!vis[to]&&par[u]!=to&&value[to]==s[net]&&(len-net)<=dist[to])
        {
            if(dfs2(to,net+))
            {
                return true;
            }
        }
    }
    int fa=par[u];
    if(!vis[fa]&&value[fa]==s[net])
    {
        if(dfs2(fa,net+))
        {
            return true;
        }
    }
    return false;
}
int main()
{
    int T;
    scanf("%d",&T);
    for(int cas=;cas<=T;cas++)
    {
        scanf("%d",&n);
        for(int i=;i<=n;i++)    arc[i].clear();
        for(int i=;i<n-;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            arc[u].push_back(v);
            arc[v].push_back(u);
        }
        scanf("%s",value+);
        scanf("%s",s);
        dfs1(,);
        len=strlen(s);
        bool tag=false;
        for(int i=;i<=n;i++)
        {
            if(value[i]==s[])
            {
                memset(vis,,sizeof(vis));
                if(dfs2(i,))
                {
                    tag=true;
                    break;
                }
            }
        }
        printf("Case #%d: ",cas);
        if(tag)    printf("Find\n");
        else    printf("Impossible\n");
    }
    return ;
}