Codeforces346D. Robot Control

D. Robot Control

time limit per test

6 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

The boss of the Company of Robot is a cruel man. His motto is "Move forward Or Die!". And that is exactly what his company's product do. Look at the behavior of the company's robot when it is walking in the directed graph. This behavior has been called "Three Laws of Robotics":

• Law 1. The Robot will destroy itself when it visits a vertex of the graph which it has already visited.
• Law 2. The Robot will destroy itself when it has no way to go (that is when it reaches a vertex whose out-degree is zero).
• Law 3. The Robot will move randomly when it has multiple ways to move (that is when it reach a vertex whose out-degree is more than one). Of course, the robot can move only along the directed edges of the graph.

Can you imagine a robot behaving like that? That's why they are sold at a very low price, just for those who are short of money, including mzry1992, of course. mzry1992 has such a robot, and she wants to move it from vertex s to vertex t in a directed graph safely without self-destruction. Luckily, she can send her robot special orders at each vertex. A special order shows the robot which way to move, if it has multiple ways to move (to prevent random moving of the robot according to Law 3). When the robot reaches vertex t, mzry1992 takes it off the graph immediately. So you can see that, as long as there exists a path from s to t, she can always find a way to reach the goal (whatever the vertex t has the outdegree of zero or not).

Sample 2

However, sending orders is expensive, so your task is to find the minimum number of orders mzry1992 needs to send in the worst case. Please note that mzry1992 can give orders to the robot while it is walking on the graph. Look at the first sample to clarify that part of the problem.

Input

The first line contains two integers n (1 ≤ n ≤ 10⁶) — the number of vertices of the graph, and m (1 ≤ m ≤ 10⁶) — the number of edges. Then m lines follow, each with two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; v_i ≠ u_i), these integers denote that there is a directed edge from vertex u_i to vertex v_i. The last line contains two integers s and t (1 ≤ s, t ≤ n).

It is guaranteed that there are no multiple edges and self-loops.

Output

If there is a way to reach a goal, print the required minimum number of orders in the worst case. Otherwise, print -1.

Examples

Input

4 6
1 2
2 1
1 3
3 1
2 4
3 4
1 4

Output

1

Input

4 5
1 2
2 1
1 3
2 4
3 4
1 4

Output

1

Note

Consider the first test sample. Initially the robot is on vertex 1. So, on the first step the robot can go to vertex 2 or 3. No matter what vertex the robot chooses, mzry1992 must give an order to the robot. This order is to go to vertex 4. If mzry1992 doesn't give an order to the robot at vertex 2 or 3, the robot can choose the "bad" outgoing edge (return to vertex 1) according Law 3. So, the answer is one.

【题解】

dp[u]表示从u这个点到终点需要的最小代价

dp[u] = min(max(dp[v]), min(dp[u]) + 1), dp[t] = 1, u - > v

可以用SPFA转移

对于点u，用u去松弛u的入边的min(dp[u]) + 1,用u的出边的点去松弛u的max(dp[v])

时间复杂度O（玄学）

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <sstream>
#include <vector>
#include <string>
#include <cmath> 
#include <queue>
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))

inline void swap(int &a, int &b)
{
    int tmp = a;a = b;b = tmp;
}

inline void read(int &x)
{
    x = 0;char ch = getchar(), c = ch;
    while(ch < '0' || ch > '9')c = ch, ch = getchar();
    while(ch <= '9' && ch >= '0')x = x * 10 + ch - '0', ch = getchar();
    if(c == '-')x = -x;
}

const int INF = 0x3f3f3f3f;
const int MAXN = 1000000 + 10;
const int MAXM = 1000000 + 10;

struct Edge
{
    int u,v,nxt;
    Edge(int _u, int _v, int _nxt){u = _u;v = _v;nxt = _nxt;}
    Edge(){}
}edge1[MAXM], edge2[MAXN];
int head1[MAXN], head2[MAXN], cnt1, cnt2;
inline void insert(int a, int b)
{
    edge1[++cnt1] = Edge(a,b,head1[a]);
    head1[a] = cnt1;
    edge2[++cnt2] = Edge(b,a,head2[b]);
    head2[b] = cnt2;
}

int n,m,s,t,dp[MAXN],b[MAXN];
std::queue<int> q;

/*
dp[u] = min(min(dp[v]) + 1, max(dp[v])) 
*/

void SPFA()
{
    b[t] = 1;memset(dp, 0x3f, sizeof(dp));dp[t] = 0;q.push(t);
    while(q.size())
    {
        int u = q.front();q.pop();b[u] = 0;
        for(register int pos = head2[u];pos;pos = edge2[pos].nxt)
        {
            int v = edge2[pos].v;
            if(dp[u] + 1 < dp[v])
            {
                dp[v] = dp[u] + 1;
                if(!b[v])
                {
                    b[v] = 1;
                    q.push(v);
                }
            }
        }
        int tmp = 0;
        for(register int pos = head1[u];pos;pos = edge1[pos].nxt) tmp = max(tmp, dp[edge1[pos].v]);
        if(tmp < dp[u])
        {
            dp[u] = tmp;
            if(!b[u])
            {
                b[u] = 1;
                q.push(u);
            }
        }
    }
}

int main()
{
    read(n), read(m);
    for(register int i = 1;i <= m;++ i)
    {
        int tmp1,tmp2;
        read(tmp1), read(tmp2);
        insert(tmp1, tmp2);
    }
    read(s), read(t);
    SPFA();
    if(dp[s] == INF)dp[s] = -1;
    printf("%d
", dp[s]);
    return 0;
}