codeforces 730K

题目大意

给你一个无向图和其中两个点 s , t . 要求你将这个无向图定向成一个从 s 到 t 的格(定义: s 是唯一的入度为0的点, t 是唯一的出度为0的点, 且整个图无环).

解题思路

首先我们有一个无视时限的做法. 先把 s 到 t 连起来, 这条链从 s 到 t 定向.
然后每次找从链上出去再回来的一条路径, 按照出去和回来的点在链上的先后给他们定向.
但是为了不超时, 需要实现这个做法.
方法是从 s 开始做个dfs树. 这棵树上有一些返祖边, 还有点 t .
首先置 t 于队列中, 并标记 t 为”沿树向上”.
每次取队列中任意元素 v , 如果 v 到 v 的父亲之间的边没有定向, 就照 v 上面的标记来定向, 同时把 v 赋值为 v 的父亲, 标记不变.
在这个过程中, 如果对一条边 (father[v],v) 定向, 并且存在一条以 father[v] 为祖先, 以 v 的某个后代 u 为后代的返祖边 (father[v],u) , 就将这条边按照 (father[v],v) 的相同方向定向, 同时将 u 标记为 v 相反标记(沿树向上<->沿树向下), 将 u 插入队列中. 这个过程能正确的定向所有边(当有解的时候. 无解的判断法是, 有条边在递推过程结束后还没有被染色. 这说明有无法走到 t 的死路.).
因为在这个过程中, 如果 (father[v],v) 被定向为 father[v]→v , 那么从 v 的任意子孙无法走到 father[v] , 对称地, 如果 (father[v],v) 被定向为 v→father[v] , 那么 v 无法走到 v 的任意子孙(除了 v 自己). 这个可以循环不变式证明.

参考程序

#include
#include
#include
#include
#include
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)
#define maxn 400005
#define maxm 1000005
#define mem(a,b) memset(a,b,sizeof(a))
#define fi first
#define se second
#define mp(a,b) make_pair(a,b)
#define pi pair
#define pb(x) push_back(x)
#define mo 4000000
using namespace std;

vector vc[maxn];

struct note{
    int x,y;
}a[maxm];

int head[maxn],t[maxm * 2],next[maxm * 2],sum;

int dir[maxm],deep[maxn],fa[maxn],now[maxn],pfa[maxn];

bool bz[maxn];

int Test,n,m,S,T;

pi d[maxn * 10];

int Read(){
    int ret=0,ff=1;
    char c=getchar();
    while (c<'0' || c>'9') {
        if (c=='-') ff=-1;
        c=getchar();
    }
    while (c>='0' && c<='9') {
        ret=ret*10+c-'0';
        c=getchar();
    }
    return ret*ff;
}

void insert(int x,int y){
    t[++sum]=y;
    next[sum]=head[x];
    head[x]=sum;
}

void dfs(int x,int father) {
    deep[x]=deep[father]+1;
    for(int tmp=head[x];tmp;tmp=next[tmp]) {
        if (t[tmp]==father) continue;
        if (!bz[t[tmp]]) {
            bz[t[tmp]]=1;
            fa[t[tmp]]=x;
            now[x]=t[tmp];
            pfa[t[tmp]]=tmp / 2;
            dfs(t[tmp],x);
        }
        else if (deep[t[tmp]]2));
        }
    }
}

int main(){
    Test=Read() ;
    while (Test--) {
        sum=1;
        ///
        n=Read();
        fo(i,1,n) vc[i].clear(),head[i]=fa[i]=bz[i]=0;
        m=Read();
        S=Read();
        T=Read();
        fo(i,1,m) {
            dir[i]=-1;
            int x=Read(),y=Read();
            a[i].x=x;
            a[i].y=y;
            insert(x,y);
            insert(y,x);
        }
        bz[S]=1;
        dfs(S,0);
        fa[S]=S;
        if (!bz[T]) {
            puts("No");
            continue;
        }
        int l=0,r=1;
        d[1]=mp(T,1);
        while (l!=r) {
            l=(l+1) % mo;
            int nowdir=d[l].se,w=d[l].fi;
            while (fa[w]!=w && dir[pfa[w]]==-1) {
                dir[pfa[w]]=nowdir;
                if (!vc[w].empty())
                fo(i,0,vc[w].size()-1){
                    dir[vc[w][i].se]=nowdir;
                    r=(r+1) % mo;
                    d[r]=mp(vc[w][i].fi,nowdir ^ 1);
                }
                w=fa[w];
            }
        }
        bool ans=1;
        fo(i,1,m) 
            if (dir[i]==-1) 
                ans=0;
        if (!ans) {
            puts("No");
            continue;
        }
        puts("Yes");
        fo(i,1,m) {
            int x=a[i].x,y=a[i].y;
            if (dir[i]) {
                if (deep[x]printf("%d %d\n",x,y);
                else printf("%d %d\n",y,x);
            }
            else {
                if (deep[x]printf("%d %d\n",y,x);
                else printf("%d %d\n",x,y);
            }
        }
    }
    return 0;
}