Problem:
Score : 600 points

Problem Statement

Given is a directed graph G with N vertices and M edges.

The vertices are numbered 1 to N, and the i-th edge is directed from Vertex A_i to Vertex B_i.

It is guaranteed that the graph contains no self-loops or multiple edges.

Determine whether there exists an induced subgraph (see Notes) of G such that the in-degree and out-degree of every vertex are both 1. If the answer is yes, show one such subgraph.

Here the null graph is not considered as a subgraph.

Notes

For a directed graph G = (V, E), we call a directed graph G' = (V', E') satisfying the following conditions an induced subgraph of G:

V' is a (non-empty) subset of V.

E' is the set of all the edges in E that have both endpoints in V'.

Constraints

1 \leq N \leq 1000

0 \leq M \leq 2000

1 \leq A_i,B_i \leq N

A_i \neq B_i

All pairs (A_i, B_i) are distinct.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N M
A_1 B_1
A_2 B_2
:
A_M B_M

Output

If there is no induced subgraph of G that satisfies the condition, print -1.
Otherwise, print an induced subgraph of G that satisfies the condition, in the following format:

K
v_1
v_2
:
v_K

This represents the induced subgraph of G with K vertices whose vertex set is \{v_1, v_2, \ldots, v_K\}. (The order of v_1, v_2, \ldots, v_K does not matter.)
If there are multiple subgraphs of G that satisfy the condition, printing any of them is accepted.

Sample Input 1

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

Sample Output 1

3
1
2
4

The induced subgraph of G whose vertex set is \{1, 2, 4\} has the edge set \{(1, 2), (2, 4), (4, 1)\}. The in-degree and out-degree of every vertex in this graph are both 1.

Sample Input 2

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

Sample Output 2

-1

There is no induced subgraph of G that satisfies the condition.

Sample Input 3

6 9
1 2
2 3
3 4
4 5
5 6
5 1
5 2
6 1
6 2

Sample Output 3

4
2
3
4
5

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;
using static AtCoderProject.Utility;
using BigInteger = System.Numerics.BigInteger;
using BitArray = System.Collections.BitArray;
using IEnumerable = System.Collections.IEnumerable;
using IEnumerator = System.Collections.IEnumerator;
using TextReader = System.IO.TextReader;

namespace AtCoderProject
{
    public class Program
    {
        public object Calc()
        {
            var N = consoleReader.Int;
            var M = consoleReader.Int;
            var gb = new GraphBuilder(N);
            foreach (var cr in consoleReader.Repeat(M))
                gb.Add(cr.Int - 1, cr.Int - 1);
            var graph = gb.ToArray();
            var cycle = new GraphSearch(graph).GetCycle();

            if (cycle == null) return -1;

            var cycleIndex = Enumerable.Repeat(-1, graph.Length).ToArray();
            for (int i = 0; i < cycle.Length - 1; i++)
            {
                cycleIndex[cycle[i]] = i;
            }

            int[] result = null;
            var next = new List<int>(cycle.Length);
            for (int i = 0; i < cycle.Length - 1; i++)
            {
                next.Add(cycle[i]);

                var children = new List<int>();
                foreach (var c in graph[cycle[i]].children)
                {
                    var nextIndex = cycleIndex[c];
                    if (nextIndex >= 0 && i + 1 != nextIndex && !(i + 2 == cycle.Length && nextIndex == 0))
                    {
                        children.Add(c);
                    }
                }
                children.Sort();
                if (children.Count > 0)
                {
                    if (children[0] < i)
                    {
                        int end = i + 1;
                        for (int j = 0; j < children.Count && children[j] < i; j++)
                        {
                            end = children[j];
                        }

                        result = next.SkipWhile(n => n != end).Select(n => n + 1).ToArray();
                        break;
                    }
                    else
                    {
                        for (; i < children[children.Count - 1]; i++)
                        {
                            cycleIndex[i] = -1;
                        }
                        --i;
                    }
                }
            }

            if (result == null)
            {
                result = next.Select(n => n + 1).ToArray();
            }
            Console.WriteLine(result.Length);
            return AllLines(result);
        }

        class GraphSearch
        {
            enum Status
            {
                None,
                Active,
                Done
            }
            Node[] graph;
            Status[] statuses;
            public GraphSearch(Node[] graph)
            {
                this.graph = graph;
                this.statuses = new Status[graph.Length];
            }
            public int[] GetCycle()
            {
                for (int i = 0; i < graph.Length; i++)
                {
                    if (statuses[i] == Status.None)
                    {
                        var res = GetCycle(i);
                        if (res != null)
                        {
                            res.Reverse();
                            return res.ToArray();
                        }
                    }
                }
                return null;
            }
            List<int> GetCycle(int v)
            {
                statuses[v] = Status.Active;

                foreach (var child in graph[v].children)
                {
                    switch (statuses[child])
                    {
                        case Status.None:
                            var list = GetCycle(child);
                            if (list != null)
                            {
                                if (list.Count < 2 || list[0] != list[list.Count - 1])
                                    list.Add(v);
                                return list;
                            }
                            break;
                        case Status.Active:
                            return new List<int> { child, v };
                    }
                }

                statuses[v] = Status.Done;
                return null;
            }
        }
        class GraphBuilder
        {
            private List<int>[] roots;
            private List<int>[] children;
            public GraphBuilder(int count)
            {
                this.roots = new List<int>[count];
                this.children = new List<int>[count];
                for (int i = 0; i < count; i++)
                {
                    this.roots[i] = new List<int>();
                    this.children[i] = new List<int>();
                }
            }
            public GraphBuilder(int count, IEnumerable<int[]> arrays) : this(count)
            {
                foreach (var item in arrays)
                    this.Add(item[0], item[1]);
            }
            public void Add(int from, int to)
            {
                children[from].Add(to);
                roots[to].Add(from);
            }
            public Node[] ToArray() =>
                Enumerable
                .Zip(roots, children, (r, c) => Tuple.Create(r, c))
                .Select((t, i) => new Node(i, t.Item1.ToArray(), t.Item2.ToArray()))
                .ToArray();
        }
        public class Node : IEquatable<Node>
        {
            public Node(int i, int[] roots, int[] children)
            {
                this.index = i;
                this.roots = roots;
                this.children = children;
            }
            public int index;
            public int[] roots;
            public int[] children;

            public override bool Equals(object obj)
            {
                if (obj is Node)
                    return this.Equals((Node)obj);
                else
                    return false;
            }
            public bool Equals(Node other) => this.index == other.index;
            public override int GetHashCode() => this.index;
        }

        #region いつもの
        private readonly ConsoleReader consoleReader;
        public Program(ConsoleReader consoleReader) { this.consoleReader = consoleReader; }
        static void Main() => Console.WriteLine(new Program(new ConsoleReader(Console.In)).Calc()); static string AllLines<T>(IEnumerable<T> source) => string.Join("\n", source);
    }

    public class ConsoleReader
    {
        private string[] ReadLineSplit() => textReader.ReadLine().Split(Array.Empty<char>(), StringSplitOptions.RemoveEmptyEntries);
        private string[] line = Array.Empty<string>();
        private int linePosition;
        private TextReader textReader;
        public ConsoleReader(TextReader tr) { textReader = tr; }
        public int Int => int.Parse(String);
        public long Long => long.Parse(String);
        public double Double => double.Parse(String);
        public string String
        {
            get
            {
                if (linePosition >= line.Length)
                {
                    linePosition = 0;
                    line = ReadLineSplit();
                }
                return line[linePosition++];
            }
        }
        public class SplitLine
        {
            public SplitLine(ConsoleReader cr) { String = cr.ReadLineSplit(); cr.line = Array.Empty<string>(); }
            public int[] Int => String.Select(x => int.Parse(x)).ToArray();
            public int[] Int0 => String.Select(x => int.Parse(x) - 1).ToArray();
            public long[] Long => String.Select(x => long.Parse(x)).ToArray();
            public double[] Double => String.Select(x => double.Parse(x)).ToArray();
            public string[] String { get; }
        }
        public SplitLine Split => new SplitLine(this);
        public class RepeatReader : IEnumerable<ConsoleReader>
        {
            ConsoleReader cr; int count;
            public RepeatReader(ConsoleReader cr, int count) { this.cr = cr; this.count = count; }
            public IEnumerator<ConsoleReader> GetEnumerator() => Enumerable.Repeat(cr, count).GetEnumerator();
            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();

            public IEnumerable<string> String => this.Select(cr => cr.String);
            public IEnumerable<int> Int => this.Select(cr => cr.Int);
            public IEnumerable<int> Int0 => this.Select(cr => cr.Int - 1);
            public IEnumerable<long> Long => this.Select(cr => cr.Long);
            public IEnumerable<double> Double => this.Select(cr => cr.Double);
        }
        public RepeatReader Repeat(int count) => new RepeatReader(this, count);
    }
    public static class Utility
    {
        public static IComparer<T> ReverseComparer<T>() where T : IComparable<T>
            => Comparer<T>.Create((x, y) => y.CompareTo(x));
    }
    #endregion

}