[HNOI2019]校园旅行

题意

https://www.luogu.org/problemnew/show/P5292

---

思考

最朴素的想法，从可行的二元组(u,v)向外拓展，及u的出边所指的颜色与v的出边所指的颜色若相同，继续更新二元组(u',v')，复杂度约为O(m²)。

我们发现，很多时候边上的转移其实是没有必要的，因为有很多情况能转移到相同的字符串，因此我们要删去一些边，并且使得不改变原图的性质。

先考虑原图中边的两端颜色相同的边构成的连通块，若为二分图，则取其任意生成树；若不为二分图，则取其任意生成树，并添加一个自环。

二分图的意思，就是相同颜色段的长度只与奇偶性有关，当字符串另一端不断添加相同字符的同时，二分图中的字符可以不断地在A集合与B集合中转换。

两端颜色不同的边构成的连通块，也是取其任意生成树。

这样边数为O(n)级别，复杂度为O(n²)。

---

代码

// luogu-judger-enable-o2
#include<bits/stdc++.h>
using namespace std;
const int maxn=5E5+5;
int head[maxn*2],size,n,m,x,y,color[maxn],flag,q;
char c[maxn];
bool f[5005][5005],can[maxn];
struct edge{int from,to,next;};
struct pt{int x,y;};
queue<pt>Q;
struct graph
{
    edge E[maxn*2];
    int head[maxn*2],size;
    void add(int u,int v)
    {
        E[++size].to=v;
        E[size].next=head[u];
        E[size].from=u;
        head[u]=size;
    }
}A,B,G;
void dfs1(int u,int now)
{
    color[u]=now;
    for(int i=A.head[u];i;i=A.E[i].next)
    {
        int v=A.E[i].to;
        if(now==color[v])flag=1;
        if(color[v])continue;
        G.add(u,v);
        G.add(v,u);
        if(now==1)dfs1(v,2);
        else dfs1(v,1);
    }
}
void dfs2(int u)
{
    color[u]=1;
    for(int i=B.head[u];i;i=B.E[i].next)
    {
        int v=B.E[i].to;
        if(color[v])continue;
        G.add(u,v);
        G.add(v,u);
        dfs2(v);
    }
}
void init1()
{
    for(int i=1;i<=A.size;++i)
        can[A.E[i].from]=can[A.E[i].to]=1;
    for(int u=1;u<=n;++u)
    {
        if(color[u]||!can[u])continue;
        flag=0;
        dfs1(u,1);
        if(flag)G.add(u,u);
    }
}
void init2()
{
    memset(color,0,sizeof(color));
    memset(can,0,sizeof(can));
    for(int i=1;i<=B.size;++i)
        can[B.E[i].from]=can[B.E[i].to]=1;
    for(int u=1;u<=n;++u)
    {
        if(color[u]||!can[u])continue;
        dfs2(u);
    }
}
void work()
{
    while(!Q.empty())
    {
        pt u=Q.front();
        Q.pop();
        for(int i=G.head[u.x];i;i=G.E[i].next)
        {
            for(int j=G.head[u.y];j;j=G.E[j].next)
            {
                int u=G.E[i].to,v=G.E[j].to;
                if(c[u]==c[v])
                {
                    if(!f[u][v])Q.push((pt){u,v});
                    f[u][v]=f[v][u]=1;
                }
            }
        }
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>m>>q;
    for(int i=1;i<=n;++i)
    {
        cin>>c[i];
        f[i][i]=1;
        Q.push((pt){i,i});
    }
    for(int i=1;i<=m;++i)
    {
        cin>>x>>y;
        if(c[x]==c[y])
        {
            A.add(x,y),A.add(y,x);
            f[x][y]=f[y][x]=1;
            Q.push((pt){x,y});
        }
        else B.add(x,y),B.add(y,x);
    }
    init1();
    init2();
    work();
    for(int i=1;i<=q;++i)
    {
        cin>>x>>y;
        if(f[x][y])cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
    }
    return 0;
}