題意：

給出一個樹，樹上邊的權值是字母。詢問一個字串，問能否在路上找到一條簡單路徑使它的子序列包含該字串。輸出任意的簡單路徑的兩個端點即可。

題解：

如果一個節點，它的一個子樹能夠從左到右匹配到第ll個字元，另外一個子樹能從右往左匹配到第rr個字元，而且ll+1>=rr那麼就代表成功匹配。

每個節點記錄四個量，從左到右最多匹配到第幾個字元，以及初始的端點。從右到左最多匹配到第幾個字元，以及初始的端點。

注意：一定是兩個不同的子樹才能做判斷。

#include<bits/stdc++.h>
using namespace std;
const int N=5e5+7;
int n,m;
struct Edge{
    int u,v,w,nxt;
    Edge(int u=0,int v=0,int w=0,int nxt=0):u(u),v(v),w(w),nxt(nxt){}
}e[N*2];
int p[N],edn;
void add(int u,int v,int w){
    e[++edn]=Edge(u,v,w,p[u]);p[u]=edn;
    e[++edn]=Edge(v,u,w,p[v]);p[v]=edn;
}
struct Node{
    int li,ri;
    int ll,rl;
}dp[N];
char s[N];
int a,b;
bool dfs(int u,int fa){
    dp[u].li=dp[u].ri=u;
    dp[u].ll=0,dp[u].rl=m+1;
    for(int i=p[u];~i;i=e[i].nxt){
        int v=e[i].v;
        if(v==fa) continue;
        if(dfs(v,u)) return true;
        
        int tl=dp[v].ll;
        if(e[i].w==s[dp[v].ll+1]) tl++;
        if(tl+1>=dp[u].rl){
            a=dp[v].li;
            b=dp[u].ri;
            return true;
        }

        int tr=dp[v].rl;
        if(e[i].w==s[dp[v].rl-1]) tr--;
        if(dp[u].ll+1>=tr){
            a=dp[u].li;
            b=dp[v].ri;
            return true;
        }

        if(tr<dp[u].rl){
            dp[u].rl=tr;
            dp[u].ri=dp[v].ri;
        }
        if(tl>dp[u].ll){
            dp[u].ll=tl;
            dp[u].li=dp[v].li;
        }
    }
    return false;
}
char w[3];
int main()
{
    scanf("%d%d",&n,&m);
    memset(p,-1,sizeof(p));edn=-1;
    for(int i=1;i<=n;i++){
        int u,v;
        scanf("%d%d%s",&u,&v,&w);
        add(u,v,w[0]);
    }
    scanf("%s",s+1);
    a=b=-1;
    dfs(1,0);
    /*for(int i=1;i<=n;i++){
        printf("%d %d\n",dp[i].ll,dp[i].rl);
    }*/
    printf("%d %d\n",a,b);
}