花了一天半的时间，才把这道题ac= =
确实是道好题，好久没敲这么长的code了，尤其是最后的判定，各种销魂啊~
题目中给出的条件最值得关注的就是：每个点最多只能在一个环内->原图是由一个个边连通分量以树形连接组成的->做无向图缩点后，得到的是一个树形结构。
题目要求：u->v，必须经过p，且不能重复经过同一个点，即在树上从u到v做一笔画。
开始先想到汉密尔顿迹，不过那是走全部点的。利用已获得的树形结构，通过lca来判断p，这就是一个合理的作法。
注意：由于是任意建树，p不一定是u，v的lca，纠结了好久才想出了一个方法:x=lca(u,v)，然后遍历v->x，u->x两条路径，找p——会超时的，太繁琐了。朋友提出了，找u，v，p中两两的lca：if(lca(u,v)==lca(u,p)&&lca(v,p)==p)就可以判断缩点后的p在u，v路径上。为什么是缩点后的呢？自己想吧，后面判断要用到的。
缩点和倍增lca自己学吧，我也是为了做这道题才学了lca T^T 之前连“爬楼梯”都不会。
这道题的精彩之处就在于最后的判定。
从u==v&&v==p 三点共点->两点共点，再到缩点后三点共点，两点共点要一一讨论。
其中容易忽视的：1、u，p缩点后cu，cp共点，点u在向cv出发的方向的出口上。（若要经过p，u点必然要重复经过）
2、环cp在u->v的路径上，但进出在同一点，并且不是点p。（若要经过p，该出入点必然要重复经过）
其他一些容易犯的错误我都在code中注明。不过这道题的价值也就体现于此，自己做吧。再次膜拜现场出题的大牛。
注：TLE了好久，后来就wa，为了调程序，编了一组七个点的数据，从111->777共344组测试，code中附上了数据以及自己代码中找到的三组错误测试，修正后就ac了。
#pragma comment(linker,"/STACK:1024000000,1024000000")
#include<cstdio>
#include<cstring>
#include<stack>
#include<queue>
#include<algorithm>
using namespace std; const int MAXN=;
const int MAXM=;
const int POW=; struct Edge{
int v,next;
int vis,bridge;
Edge(){}
Edge(int _v,int _next):v(_v),next(_next),vis(){}
}edge[MAXM<<]; int head[MAXN],tol;
int stk[MAXN],top;
int pre[MAXN],low[MAXN],bccno[MAXN],bcc_cnt,dfs_clock;
vector<int>G[MAXN];
int d[MAXN],p[MAXN][POW]; void init()
{
tol=;
memset(head,-,sizeof(head));
} void add(int u,int v)
{
edge[tol]=Edge(v,head[u]);
head[u]=tol++;
} void build(int m)
{
int u,v;
init();
for(int i=;i<=m;i++)
{
scanf("%d%d",&u,&v);
add(u,v);
add(v,u);
}
} void dfs(int u)
{
int v;
pre[u]=low[u]=++dfs_clock;
stk[top++]=u;
for(int i=head[u];i!=-;i=edge[i].next)
{
if(edge[i].vis)
continue ;
edge[i].vis=edge[i^].vis=;
v=edge[i].v; if(!pre[v]){
dfs(v);
low[u]=min(low[u],low[v]);
}else if(!bccno[v])
low[u]=min(low[u],pre[v]);
} if(low[u]==pre[u]){
bcc_cnt++;
do{
v=stk[--top];
bccno[v]=bcc_cnt;
}while(v!=u);
}
} void tarjin(int n)
{
bcc_cnt=dfs_clock=;
memset(pre,,sizeof(pre));
memset(bccno,,sizeof(bccno)); top=;
for(int i=;i<=n;i++)
if(!pre[i])
dfs(i);
} void rebuild(int n)
{
for(int i=;i<=bcc_cnt;i++) //!!把bcc_cnt写成n = =
G[i].clear();
for(int i=;i<=n;i++)
{ for(int j=head[i];j!=-;j=edge[j].next)
{
int v=edge[j].v;
if(bccno[i]!=bccno[v])
G[bccno[i]].push_back(v); //!!桥，这里写v而不是bccno[v],是为了后面judge()判断环的出入口
}
}
} void DFS(int u,int fa)
{
d[u]=d[fa]+;
p[u][]=fa;
for(int i=;i<POW;i++)
p[u][i]=p[p[u][i-]][i-];
int sz=G[u].size();
for(int i=;i<sz;i++)
{
int v=bccno[G[u][i]];
if(v==fa)
continue;
DFS(v,u);
}
} int lca( int a, int b ){
if( d[a] > d[b] ) a ^= b, b ^= a, a ^= b;
if( d[a] < d[b] ){
int del = d[b] - d[a];
for( int i = ; i < POW; i++ ) if(del&(<<i)) b=p[b][i];
}
if( a != b ){
for( int i = POW-; i >= ; i-- )
if( p[a][i] != p[b][i] )
a = p[a][i] , b = p[b][i];
a = p[a][], b = p[b][];
}
return a;
} void LCA(int n)//这里只是处理了一下新图中各个点的深度
{
d[]=;
DFS(,);
} int Double(int a,int b)//倍增
{
int del=d[a]-d[b]-;
for(int i=;i<POW;i++)
if(del&(<<i))
a=p[a][i];
return a;
} int judge(int u,int v)//返回值是该方向上环的出入口
{
int sz=G[u].size();
for(int i=;i<sz;i++)
if(bccno[G[u][i]]==bccno[v])
return G[u][i];
} void solve()
{
int k;
int u,v,w;
scanf("%d",&k);
for(int i=;i<=k;i++)
{
scanf("%d%d%d",&u,&v,&w);
int a=bccno[u],b=bccno[v],c=bccno[w];
if(u==v&&v==w)
printf("Yes\n");
else if(u==w||v==w)//!!注意：即使考虑了两点uw（或vw）缩点后重合，目标点u（或v）不能作为出口，但u，w共点是可行的
printf("Yes\n");
else if(u==v)
printf("No\n");
else if(bccno[u]==bccno[v]&&bccno[u]==bccno[w])
printf("Yes\n");
else if(bccno[u]==bccno[v])
printf("No\n");
else if(bccno[u]==bccno[w]){
int flog;
int pp=lca(a,b);//!!注意：当两点缩点后重合，无法直接判定第三点在上方还是下方，需要利用lca
if(pp==a){
b=Double(b,c);//由b向c做倍增
flog=judge(b,u);
}else
flog=judge(p[a][],u);
if(flog!=u)
printf("Yes\n");
else
printf("No\n");
}else if(bccno[v]==bccno[w]){
int flog;
int pp=lca(a,b);//!!同上
if(pp==b){
a=Double(a,c);//由a向c做倍增
flog=judge(a,v);
}else
flog=judge(p[b][],v);
if(flog!=v)
printf("Yes\n");
else
printf("No\n");
}else {
int p1,p2,p3; p1=lca(a,b);
p2=lca(a,c);
p3=lca(b,c);
if(p1==p2&&p3==c){//判定点p是否能经过：求出两两lca
int flog1,flog2;
b=Double(b,c);
flog1=judge(b,w); if(p1==c){//!!注意：当点p即为lca(u,v)时，p的另一个入口就不能从其父亲查找了，要在另一支路上做倍增
a=Double(a,c);
flog2=judge(a,w);
}else
flog2=judge(p[c][],w); if(flog1!=w&&flog2!=w&&flog1==flog2)
printf("No\n");
else
printf("Yes\n");
}
else if(p1==p3&&p2==c){//这里上下两步其实是重复处理：p3==c表示p点在v支路上;反之在u支路上
int flog1,flog2;
a=Double(a,c);
flog1=judge(a,w); if(p1==c){
b=Double(b,c);
flog2=judge(b,w);
}else
flog2=judge(p[c][],w); if(flog1!=w&&flog2!=w&&flog1==flog2)
printf("No\n");
else
printf("Yes\n");
}else
printf("No\n");
}
}
} int main()
{
int n,m;
while(~scanf("%d%d",&n,&m))
{
build(m);
tarjin(n);
rebuild(n);
LCA(n);
solve();
}
return ;
}
/*
7 7
1 2
2 3
2 4
3 4
3 5
4 6
4 7
3
1 2 3
1 6 2
1 2 1
*/