Luogu4652 CEOI2017 One-Way Streets 树上差分

传送门

题意：给出$N$个点、$M$条无向边的图，现在你需要给它定向，并满足$Q$个条件：每个条件形如$(x_i,y_i)$，表示定向之后需要存在路径从$x_i$走向$y_i$。问每条边是否都有唯一定向方式。$N,M,Q \leq 10^5$

---

图论总是涉及的算法不难，但是就是脑子生锈想不出来

可以知道一个边双联通分量里面的所有边的方向都是一定不能确定的，因为如果存在一种方式满足所有条件，将这个边双联通分量里的所有边取反之后也一定满足条件。所以我们只需要考虑割边。

不妨在原图中找到一棵树，这棵树上必定包含所有的割边。通过差分将非割边打上标记，我们就可以通过在新的树上求$LCA$加上差分对所有边向上还是向下打好标记，最后$dfs$求出答案即可。

实际上还可以并查集，但是并查集写炸了qwq

注意重边，还要注意图不连通的情况

 #include<bits/stdc++.h>
 using namespace std;

 inline int read(){
     int a = ;
     bool f = ;
     char c = getchar();
     while(c != EOF && !isdigit(c)){
         if(c == '-')
             f = ;
         c = getchar();
     }
     while(c != EOF && isdigit(c)){
         a = (a << ) + (a << ) + (c ^ '');
         c = getchar();
     }
     return f ? -a : a;
 }

 const int MAXN = ;
 struct Edge{
     int end , upEd;
 }Ed[MAXN << ];
 int N , M , cntEd =  , head[MAXN] , dep[MAXN] , up[MAXN] , down[MAXN] , can[MAXN] , jump[MAXN][];
 char ans[MAXN];
 bool vis[MAXN];

 inline void addEd(int a , int b){
     Ed[++cntEd].end = b;
     Ed[cntEd].upEd = head[a];
     head[a] = cntEd;
 }

 void dfs(int x , int fa){
     jump[x][] = fa;
     dep[x] = dep[fa] + ;
     for(int i =  ; i <=  ; i++)
         jump[x][i] = jump[jump[x][i - ]][i - ];
     for(int i = head[x] ; i ; i = Ed[i].upEd)
         if(!dep[Ed[i].end])
             dfs(Ed[i].end , x);
         else
             if(dep[Ed[i].end] > dep[x]){
                 can[Ed[i].end]++;
                 can[x]--;
             }
 }

 void Dfs(int x){
     vis[x] = ;
     for(int i = head[x] ; i ; i = Ed[i].upEd)
         if(dep[Ed[i].end] == dep[x] +  && !vis[Ed[i].end]){//不加vis判断会炸！！！
             Dfs(Ed[i].end);
             if(can[Ed[i].end] == )
                 if((i & ) && up[Ed[i].end] || !(i & ) && down[Ed[i].end])
                     ans[i >> ] = 'R';
                 else
                     if(!(i & ) && up[Ed[i].end] || (i & ) && down[Ed[i].end])
                         ans[i >> ] = 'L';
             up[x] += up[Ed[i].end];
             down[x] += down[Ed[i].end];
             can[x] += can[Ed[i].end];
         }
 }

 inline int jumpToLCA(int x , int y){
     if(dep[x] < dep[y])
         swap(x , y);
     for(int i =  ; i >=  ; i--)
         if(dep[x] - ( << i) >= dep[y])
             x = jump[x][i];
     if(x == y)
         return x;
     for(int i =  ; i >=  ; i--)
         if(jump[x][i] != jump[y][i]){
             x = jump[x][i];
             y = jump[y][i];
         }
     return jump[x][];
 }

 int main(){
 #ifdef LG
     freopen("4652.in" , "r" , stdin);
     freopen("4652.out" , "w" , stdout);
 #endif
     N = read();
     M = read();
     for(int i =  ; i <= M ; i++){
         int a = read() , b = read();
         addEd(a , b);
         addEd(b , a);
     }
     for(int i =  ; i <= N ; i++)
         if(!dep[i])
             dfs(i , );
     for(int Q = read() ; Q ; Q--){
         int a = read() , b = read() , t = jumpToLCA(a , b);
         up[a]++;
         up[t]--;
         down[t]--;
         down[b]++;
     }
     memset(ans , 'B' , sizeof(ans));
     for(int i =  ; i <= N ; i++)
         if(!vis[i])
             Dfs(i);
     for(int i =  ; i <= M ; i++)
         cout << ans[i];
     return ;
 }