Problem:
Score : 500 points

Problem Statement

Ken loves ken-ken-pa (Japanese version of hopscotch). Today, he will play it on a directed graph G.
G consists of N vertices numbered 1 to N, and M edges. The i-th edge points from Vertex u_i to Vertex v_i.

First, Ken stands on Vertex S. He wants to reach Vertex T by repeating ken-ken-pa. In one ken-ken-pa, he does the following exactly three times: follow an edge pointing from the vertex on which he is standing.

Determine if he can reach Vertex T by repeating ken-ken-pa. If the answer is yes, find the minimum number of ken-ken-pa needed to reach Vertex T. Note that visiting Vertex T in the middle of a ken-ken-pa does not count as reaching Vertex T by repeating ken-ken-pa.

Constraints

2 \leq N \leq 10^5

0 \leq M \leq \min(10^5, N (N-1))

1 \leq u_i, v_i \leq N(1 \leq i \leq M)

u_i \neq v_i (1 \leq i \leq M)

If i \neq j, (u_i, v_i) \neq (u_j, v_j).

1 \leq S, T \leq N

S \neq T

Input

Input is given from Standard Input in the following format:

N M
u_1 v_1
:
u_M v_M
S T

Output

If Ken cannot reach Vertex T from Vertex S by repeating ken-ken-pa, print -1.
If he can, print the minimum number of ken-ken-pa needed to reach vertex T.

Sample Input 1

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

Sample Output 1

2

Ken can reach Vertex 3 from Vertex 1 in two ken-ken-pa, as follows: 1 \rightarrow 2 \rightarrow 3 \rightarrow 4 in the first ken-ken-pa, then 4 \rightarrow 1 \rightarrow 2 \rightarrow 3 in the second ken-ken-pa. This is the minimum number of ken-ken-pa needed.

Sample Input 2

3 3
1 2
2 3
3 1
1 2

Sample Output 2

-1

Any number of ken-ken-pa will bring Ken back to Vertex 1, so he cannot reach Vertex 2, though he can pass through it in the middle of a ken-ken-pa.

Sample Input 3

2 0
1 2

Sample Output 3

-1

Vertex S and Vertex T may be disconnected.

Sample Input 4

6 8
1 2
2 3
3 4
4 5
5 1
1 4
1 5
4 6
1 6

Sample Output 4

2

Solution in C# (Mono 4.6.2.0) (judge verdict: Time Limit Exceeded)

using System;
using System.Collections.Generic;

public class Node {
    public int count;
    public List<int> toOnce;
    public List<int> toThree;
    public List<int> fromThree;
}

public class ABC132E {
    public static void Main() {
        int N, M, S, T, ans = 0;
        List<Node> nodes = new List<Node>();
        string[] str = Console.ReadLine().Split(' ');
        N = int.Parse(str[0]);
        M = int.Parse(str[1]);
        for (int i = 0; i < N; i++) {
            Node node = new Node();
            node.count = -1;
            node.toOnce = new List<int>();
            node.toThree = new List<int>();
            node.fromThree = new List<int>();
            nodes.Add(node);
        }

        for (int i = 0; i < M; i++) {
            str = Console.ReadLine().Split(' ');
            nodes[int.Parse(str[0]) - 1].toOnce.Add(int.Parse(str[1]) - 1);
        }
        for (int i = 0; i < N; i++) {
            ThreeTimes(nodes[i], nodes, i);
        }

        str = Console.ReadLine().Split(' ');
        S = int.Parse(str[0]) - 1;
        T = int.Parse(str[1]) - 1;

        List<bool> canPass = new List<bool>();
        for (int i = 0; i< N; i++) {
            canPass.Add(false);
        }
        CheckPath(S, nodes, canPass);
        if (!canPass[T]) {
            Console.WriteLine(-1);
            return;
        }

        List<bool> found = new List<bool>();
        for (int i = 0; i< N; i++) {
            found.Add(false);
        }
        found[T] = true;
        nodes[T].count = 0;
        FindPath(T, nodes, found);

        //for (int i = 0; i < N; i++) {
            //Console.WriteLine(nodes[i].count);
        //}

        Console.WriteLine(nodes[S].count);
    }

    private static void ThreeTimes(Node node, List<Node> nodes, int nodeNum) {
        for (int i = 0; i < node.toOnce.Count; i++) {
            for (int j = 0; j < nodes[node.toOnce[i]].toOnce.Count; j++) {
                for (int k = 0; k < nodes[nodes[node.toOnce[i]].toOnce[j]].toOnce.Count; k++) {
                    node.toThree.Add(nodes[nodes[node.toOnce[i]].toOnce[j]].toOnce[k]);
                    nodes[nodes[nodes[node.toOnce[i]].toOnce[j]].toOnce[k]].fromThree.Add(nodeNum);
                }
            }
        }
    }

    private static void CheckPath(int s, List<Node> nodes, List<bool> canPass) {
        for (int i = 0; i < nodes[s].toThree.Count; i++) {
            if (!canPass[nodes[s].toThree[i]]) {
                canPass[nodes[s].toThree[i]] = true;
                CheckPath(nodes[s].toThree[i], nodes, canPass);
            }
        }
    }

    private static void FindPath(int T, List<Node> nodes, List<bool> found) {
        for (int i = 0; i < nodes[T].fromThree.Count; i++) {
            if (nodes[nodes[T].fromThree[i]].count > nodes[T].count + 1) {
                nodes[nodes[T].fromThree[i]].count = nodes[T].count + 1;
                FindPath(nodes[T].fromThree[i], nodes, found);
            }
            if (nodes[nodes[T].fromThree[i]].count == -1) {
                nodes[nodes[T].fromThree[i]].count = nodes[T].count + 1;
                FindPath(nodes[T].fromThree[i], nodes, found);
            }
        }
    }

}