[NOIP 2014] 寻找道路

[题目链接]

http://uoj.ac/problem/19

[算法]

首先，在反向图上从终点广搜，求出每个点是否可以在答案路径中

然后在正向图中求出源点至终点的最短路，同样可以使用广搜

时间复杂度 : O(N)

[代码]

#include<bits/stdc++.h>
using namespace std;
#define MAXN 10010
#define MAXM 200010

struct edge
{
        int to,nxt;
} e[MAXM << ];

int i,n,m,u,v,s,t,tot;
int head[MAXN],rhead[MAXN],deg[MAXN];
bool flag[MAXN];

namespace IO
{
    template <typename T> inline void read(T &x)
    {
        int f = ; x = ;
        char c = getchar();
        for (; !isdigit(c); c = getchar())
        {
            if (c == '-') f = -f;
        }
        for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';
        x *= f;
    }
    template <typename T> inline void write(T x)
    {
        if (x < )
        {
            putchar('-');
            x = -x;
        }
        if (x > ) write(x / );
        putchar(x %  + '');
    }
    template <typename T> inline void writeln(T x)
    {
        write(x);
        puts("");
    }
} ;
inline void addedge(int u,int v)
{
        tot++;
        e[tot] = (edge){v,head[u]};
        head[u] = tot;
}
inline void addredge(int u,int v)
{
        tot++;
        e[tot] = (edge){v,rhead[u]};
        rhead[u] = tot;
}
inline void bfs1(int s)
{
        int i,u,v,l,r;
        static int q[MAXN],cnt[MAXN];
        static bool visited[MAXN];
        for (i = ; i <= n; i++) cnt[i] = ;
        q[l = r = ] = s;
        flag[s] = true;
        while (l <= r)
        {
                u = q[l];
                l++;
                for (i = rhead[u]; i; i = e[i].nxt)
                {
                        v = e[i].to;
                        if (!visited[v])
                        {
                                visited[v] = true;
                                q[++r] = v;
                        }
                        cnt[v]++;
                }
        }
        for (i = ; i <= n; i++) flag[i] = (cnt[i] == deg[i]);
}
inline int bfs2(int s)
{
        int i,u,v,l,r;
        static int q[MAXN],dist[MAXN];
        static bool visited[MAXN];
        if (!flag[s]) return -;
        for (i = ; i <= n; i++) visited[i] = false;
        q[l = r = ] = s;
        dist[s] = ;
        visited[s] = true;
        while (l <= r)
        {
                u = q[l];
                l++;
                for (i = head[u]; i; i = e[i].nxt)
                {
                        v = e[i].to;
                        if (!visited[v] && flag[v])
                        {
                                visited[v] = true;
                                dist[v] = dist[u] + ;
                                q[++r] = v;
                        }
                }
        }
        return dist[t] >  ? dist[t] : -;
}

int main()
{

        IO :: read(n); IO :: read(m);
        for (i = ; i <= m; i++)
        {
                IO :: read(u); IO :: read(v);
                addedge(u,v);
                addredge(v,u);
                deg[u]++;
        }
        IO :: read(s); IO :: read(t);
        bfs1(t);
        IO :: writeln(bfs2(s));

        return ;

}