luogu P2783 有机化学之神偶尔会做作弊

嘟嘟嘟

一道很水的黑题~~

边双缩点后用lca求树上两点间路径即可。

但是比较坑的是这道题是忽略重边的，结果我还特意考虑了重边，然后WA了几发。

还有两个点TLE了，原因是建新图的时候出现了重边。这个重边不是算法的问题，因为边双缩点后不可能有重边，而是写法上的问题：在建无向边的时候，习惯addEdge(x, y), addEdge(y, x)，然而边双建边的时候两个点之间实际上连了4条边。所以写的时候只用建单向边，形成的图却是无向图。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<queue>
#include<stack>
using namespace std;
#define enter puts("")
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define rg register
typedef long long ll;
typedef double db;
const db eps = 1e-8;
const int INF = 0x3f3f3f3f;
const int maxn = 1e4 + 5;
const int maxe = 5e4 + 5;
inline ll read()
{
    ll ans = 0;
    char ch = getchar(), las = ' ';
    while(!isdigit(ch)) las = ch, ch = getchar();
    while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
    if(las == '-') ans = -ans;
    return ans;
}
inline void write(ll x)
{
    if(x < 0) putchar('-'), x = -x;
    if(x >= 10) write(x / 10);
    putchar(x % 10 + '0');
}

int n, m;

struct Edge
{
    int nxt, to;
}e[maxe << 1], e2[maxe << 1];
int head[maxn], ecnt = -1;
void addEdge(int x, int y)
{
    e[++ecnt] = (Edge){head[x], y};
    head[x] = ecnt;
}

int dfn[maxn], low[maxn], cnt = 0;
bool in[maxn];
int st[maxn], top = 0;
int col[maxn], ccol = 0;
void tarjan(int now, int f)
{
    dfn[now] = low[now] = ++cnt;
    st[++top] = now; in[now] = 1;
    for(int i = head[now]; i != -1; i = e[i].nxt)
    {
        if(!dfn[e[i].to])
        {
            tarjan(e[i].to, now);
            low[now] = min(low[now], low[e[i].to]);
        }
        else if(e[i].to != f) low[now] = min(low[now], dfn[e[i].to]);
    }
    if(dfn[now] == low[now])
    {
        int x; ++ccol;
        do
        {
            x = st[top--];
            col[x] = ccol;
            in[x] = 0;
        }while(x != now);
    }
}

int head2[maxn], ecnt2 = -1;
void addEdge2(int x, int y)
{
    e2[++ecnt2] = (Edge){head2[x], y};
    head2[x] = ecnt2;
}
void newGraph(int now)
{
    int u = col[now];
    for(int i = head[now]; i != -1; i = e[i].nxt)
    {
        int v = col[e[i].to];
        if(u == v) continue;
        addEdge2(u, v); //addEdge2(v, u);
    }
}

const int N = 20;
int fa[maxn][25], dep[maxn];
void dfs(int now, int f)
{
    for(int i = 1; i <= N; ++i)
        fa[now][i] = fa[fa[now][i - 1]][i - 1];
    for(int i = head2[now]; i != -1; i = e2[i].nxt)
    {
        if(e2[i].to == f) continue;
        fa[e2[i].to][0] = now;
        dep[e2[i].to] = dep[now] + 1;
        dfs(e2[i].to, now);
    }
}
int lca(int x, int y)
{
    if(dep[x] < dep[y]) swap(x, y);
    for(int i = N; i >= 0; --i)
        if(dep[x] - (1 << i) >= dep[y]) x = fa[x][i];
    if(x == y) return x;
    for(int i = N; i >= 0; --i)
        if(fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
    return fa[x][0];
}

void print(int x)
{
    if(!x) return;
    print(x >> 1);
    write(x & 1);
}
void solve(int x, int y)
{
    int z = lca(x, y);
    print(dep[x] - dep[z] + dep[y] - dep[z] + 1);
    enter;
}

int main()
{
    Mem(head, -1);
    n = read(); m = read();
    for(int i = 1; i <= m; ++i)
    {
        int x = read(), y = read();
        addEdge(x, y); addEdge(y, x);
    }
    for(int i = 1; i <= n; ++i) if(!dfn[i]) tarjan(i, 0);
    Mem(head2, -1);
    for(int i = 1; i <= n; ++i) newGraph(i);
    dfs(col[1], 0);
    int q = read();
    for(int i = 1; i <= q; ++i)
    {
        int x = read(), y = read();
        solve(col[x], col[y]);
    }
    return 0;
}