[CEOI2017]One-Way Streets

题目大意：
　　给你一个无向图，现在告诉你一些点对(u,v)，
　　要你在保证从u到v的所有路径都不变的情况下，尽可能把所有的边变成单向边，
　　问你可以唯一确定哪些边的方向，以及方向是从u到v还是从v到u。

思路：
　　首先不难发现环上的边都不能确定方向，所以我们可以先缩环。
　　缩环以后剩下的图就变成了一棵树，考虑对树进行一些操作来确定边的方向。
　　我们可以树链剖分，用线段树维护边的方向，
　　但是树上边的方向不一定都是同一种，因此我们可以先不考虑从u到v还是从v到u。
　　我们只需要先维护从上到下还是从下到上。
　　如果维护时发现当前维护的边的区间已经是有向的，而且和当前方向相反，那么就是双向边。
　　最后统计答案时，只需要判一下u在上还是v在上即可。
　　小优化：当维护区间已经是双向时，不管怎样它永远都是双向了，我们可以直接在线段树上剪枝。

 #include<stack>
 #include<cstdio>
 #include<cctype>
 #include<vector>
 inline int getint() {
     register char ch;
     while(!isdigit(ch=getchar()));
     register int x=ch^'';
     while(isdigit(ch=getchar())) x=(((x<<)+x)<<)+(ch^'');
     return x;
 }
 const int N=,M=;
 struct Edge2 {
     int u,v;
 };
 Edge2 edge[M];
 struct Edge {
     int to,id;
 };
 std::vector<Edge> e[N];
 inline void add_edge(const int &u,const int &v,const int &id) {
     e[u].push_back((Edge){v,id});
     e[v].push_back((Edge){u,id});
 }
 char type[M];
 std::stack<int> s;
 bool mark[M],ins[N];
 int dfn[N],low[N],bcc[N];
 void tarjan(const int &x) {
     s.push(x);
     ins[x]=true;
     dfn[x]=low[x]=++dfn[];
     for(unsigned i=;i<e[x].size();i++) {
         const int &y=e[x][i].to,&id=e[x][i].id;
         if(mark[id]) continue;
         mark[id]=true;
         if(!dfn[y]) {
             tarjan(y);
             low[x]=std::min(low[x],low[y]);
         } else if(ins[y]) {
             low[x]=std::min(low[x],dfn[y]);
         }
     }
     if(dfn[x]==low[x]) {
         bcc[]++;
         int y=;
         while(y!=x) {
             y=s.top();
             s.pop();
             ins[y]=false;
             bcc[y]=bcc[];
         }
     }
 }
 int par[N],size[N],dep[N],son[N],top[N],id[N],ori[N];
 void dfs1(const int &x,const int &par) {
     size[x]=;
     ::par[x]=par;
     dep[x]=dep[par]+;
     for(unsigned i=;i<e[x].size();i++) {
         const int &y=e[x][i].to;
         if(y==par) continue;
         dfs1(y,x);
         size[x]+=size[y];
         if(size[y]>size[son[x]]) son[x]=y;
     }
 }
 void dfs2(const int &x) {
     if(x==son[par[x]]) {
         top[x]=top[par[x]];
     } else {
         top[x]=x;
     }
     if(son[x]) {
         id[son[x]]=++id[];
         dfs2(son[x]);
     }
     for(unsigned i=;i<e[x].size();i++) {
         const int &y=e[x][i].to;
         if(y!=par[x]&&y!=son[x]) {
             id[y]=++id[];
             dfs2(y);
         }
         ori[id[y]]=e[x][i].id;
     }
 }
 class SegmentTree {
     #define _left <<1
     #define _right <<1|1
     private:
         char val[N<<];
         void push_down(const int &p) {
             if(!val[p]) return;
             if(val[p _left]) {
                 if(val[p _left]!=val[p]) val[p]='B';
             } else {
                 val[p _left]=val[p];
             }
             if(val[p _right]) {
                 if(val[p _right]!=val[p]) val[p]='B';
             } else {
                 val[p _right]=val[p];
             }
         }
     public:
         void modify(const int &p,const int &b,const int &e,const int &l,const int &r,const char &c) {
             if(val[p]=='B') return;
             if(b==l&&e==r) {
                 if(val[p]) {
                     if(val[p]!=c) val[p]='B';
                 } else {
                     val[p]=c;
                 }
                 return;
             }
             push_down(p);
             const int mid=(b+e)>>;
             if(l<=mid) modify(p _left,b,mid,l,std::min(mid,r),c);
             if(r>mid) modify(p _right,mid+,e,std::max(mid+,l),r,c);
         }
         void stat(const int &p,const int &b,const int &e) {
             if(val[p]=='B') return;
             if(b==e) {
                 if(val[p]) {
                     type[ori[b]]=val[p];
                 } else {
                     type[ori[b]]='B';
                 }
                 return;
             }
             push_down(p);
             const int mid=(b+e)>>;
             stat(p _left,b,mid);
             stat(p _right,mid+,e);
         }
     #undef _left
     #undef _right
 };
 SegmentTree t;
 void modify(int x,int y) {
     char c='R',c0='L';
     while(top[x]!=top[y]) {
         if(dep[top[x]]<dep[top[y]]) {
             std::swap(x,y);
             std::swap(c,c0);
         }
         t.modify(,,bcc[],id[top[x]],id[x],c);
         x=par[top[x]];
     }
     if(x==y) return;
     if(dep[x]<dep[y]) {
         std::swap(x,y);
         std::swap(c,c0);
     }
     t.modify(,,bcc[],id[son[y]],id[x],c);
 }
 int main() {
     const int n=getint(),m=getint();
     for(register int i=;i<=m;i++) {
         edge[i]=(Edge2){getint(),getint()};
         add_edge(edge[i].u,edge[i].v,i);
     }
     for(register int i=;i<=n;i++) {
         if(!dfn[i]) tarjan(i);
         e[i].clear();
     }
     for(register int i=;i<=m;i++) {
         const int &u=edge[i].u,&v=edge[i].v;
         if(bcc[u]==bcc[v]) {
             type[i]='B';
             continue;
         }
         add_edge(bcc[u],bcc[v],i);
     }
     for(register int i=;i<=bcc[];i++) {
         if(!size[i]) {
             dfs1(i,);
             id[i]=++id[];
             dfs2(i);
         }
     }
     for(register int q=getint();q;q--) {
         const int x=bcc[getint()],y=bcc[getint()];
         modify(x,y);
     }
     t.stat(,,bcc[]);
     for(register int i=;i<=m;i++) {
         const int &u=bcc[edge[i].u],&v=bcc[edge[i].v];
         if(type[i]!='B'&&dep[u]<dep[v]) {
             if(type[i]=='L') {
                 type[i]='R';
             } else {
                 type[i]='L';
             }
         }
     }
     puts(&type[]);
     return ;
 }