[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^'0';
    while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
    return x;
}
const int N=100001,M=100001;
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[0];
    for(unsigned i=0;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[0]++;
        int y=0;
        while(y!=x) {
            y=s.top();
            s.pop();
            ins[y]=false;
            bcc[y]=bcc[0];
        }
    }
}
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]=1;
    ::par[x]=par;
    dep[x]=dep[par]+1;
    for(unsigned i=0;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[0];
        dfs2(son[x]);
    }
    for(unsigned i=0;i<e[x].size();i++) {
        const int &y=e[x][i].to;
        if(y!=par[x]&&y!=son[x]) {
            id[y]=++id[0];
            dfs2(y);
        }
        ori[id[y]]=e[x][i].id;
    }
}
class SegmentTree {
    #define _left <<1
    #define _right <<1|1
    private:
        char val[N<<2];
        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)>>1;
            if(l<=mid) modify(p _left,b,mid,l,std::min(mid,r),c);
            if(r>mid) modify(p _right,mid+1,e,std::max(mid+1,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)>>1;
            stat(p _left,b,mid);
            stat(p _right,mid+1,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(1,1,bcc[0],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(1,1,bcc[0],id[son[y]],id[x],c);
}
int main() {
    const int n=getint(),m=getint();
    for(register int i=1;i<=m;i++) {
        edge[i]=(Edge2){getint(),getint()};
        add_edge(edge[i].u,edge[i].v,i);
    }
    for(register int i=1;i<=n;i++) {
        if(!dfn[i]) tarjan(i);
        e[i].clear();
    }
    for(register int i=1;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=1;i<=bcc[0];i++) {
        if(!size[i]) {
            dfs1(i,0);
            id[i]=++id[0];
            dfs2(i);
        }
    }
    for(register int q=getint();q;q--) {
        const int x=bcc[getint()],y=bcc[getint()];
        modify(x,y);
    }
    t.stat(1,1,bcc[0]);
    for(register int i=1;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[1]);
    return 0;
}