Problem:
Score : 1600 points

Problem Statement

A balancing network is an abstract device built up of N wires, thought of as running from left to right,
and M balancers that connect pairs of wires. The wires are numbered from 1 to N from top to bottom,
and the balancers are numbered from 1 to M from left to right.
Balancer i connects wires x_i and y_i (x_i < y_i).

Each balancer must be in one of two states: up or down.

Consider a token that starts moving to the right along some wire at a point to the left of all balancers.
During the process, the token passes through each balancer exactly once.
Whenever the token encounters balancer i, the following happens:

If the token is moving along wire x_i and balancer i is in the down state, the token moves down to wire y_i and continues moving to the right.

If the token is moving along wire y_i and balancer i is in the up state, the token moves up to wire x_i and continues moving to the right.

Otherwise, the token doesn't change the wire it's moving along.

Let a state of the balancing network be a string of length M, describing the states of all balancers.
The i-th character is ^ if balancer i is in the up state, and v if balancer i is in the down state.

A state of the balancing network is called uniforming if a wire w exists such that, regardless of the starting wire,
the token will always end up at wire w and run to infinity along it. Any other state is called non-uniforming.

You are given an integer T (1 \le T \le 2). Answer the following question:

If T = 1, find any uniforming state of the network or determine that it doesn't exist.

If T = 2, find any non-uniforming state of the network or determine that it doesn't exist.

Note that if you answer just one kind of questions correctly, you can get partial score.

Constraints

2 \leq N \leq 50000

1 \leq M \leq 100000

1 \leq T \leq 2

1 \leq x_i < y_i \leq N

All input values are integers.

Partial Score

800 points will be awarded for passing the testset satisfying T = 1.

800 points will be awarded for passing the testset satisfying T = 2.

Input

Input is given from Standard Input in the following format:

N M T
x_1 y_1
x_2 y_2
:
x_M y_M

Output

Print any uniforming state of the given network if T = 1, or any non-uniforming state if T = 2. If the required state doesn't exist, output -1.

Sample Input 1

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

Sample Output 1

^^^^^

This state is uniforming: regardless of the starting wire, the token ends up at wire 1.

Sample Input 2

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

Sample Output 2

v^^^^

This state is non-uniforming: depending on the starting wire, the token might end up at wire 1 or wire 2.

Sample Input 3

3 1 1
1 2

Sample Output 3

-1

A uniforming state doesn't exist.

Sample Input 4

2 1 2
1 2

Sample Output 4

-1

A non-uniforming state doesn't exist.

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

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;

class Myon

{
    public Myon() { }
    public static int Main()
    {
        cin = new Scanner();
        new Myon().calc();
        return 0;
    }
    static Scanner cin;


    int N, M, T;
    int[] x, y;

    void calc()
    {
        N = cin.nextInt();
        M = cin.nextInt();
        T = cin.nextInt();
        x = new int[M];
        y = new int[M];

        Random r = new Random();

        for (int i = 0; i < M; i++)
        {
            x[i] = cin.nextInt() - 1;
            y[i] = cin.nextInt() - 1;

            //x[i] = r.Next(3);
            //y[i] = (x[i] + 1 + r.Next(2)) % 3;
        }

        if (T == 1)
        {
            int TT = (N + 61) / 62;
            bool[] ok = new bool[N];
            for (int i = 0; i < N; i++)
            {
                ok[i] = true;
            }

            for (int i = 0; i < TT; i++)
            {
                long[] bit = new long[N];
                long mask = 0;
                for (int j = 0; j < 62; j++)
                {
                    int t = i * 62 + j;
                    if (t >= N) continue;
                    mask |= 1L << j;
                    bit[t] |= 1L << j;
                }

                for (int j = 0; j < M; j++)
                {
                    bit[x[j]] |= bit[y[j]];
                    bit[y[j]] = bit[x[j]];
                }

                for (int j = 0; j < N; j++)
                {
                    if (bit[j] != mask) ok[j] = false; ;
                }
            }

            for (int i = 0; i < N; i++)
            {
                if (ok[i])
                {
                    char[] ans = new char[M];
                    bool[] reach = new bool[N];
                    reach[i] = true;

                    for (int j = M - 1; j >= 0; j--)
                    {
                        if (reach[x[i]])
                        {
                            ans[j] = '^';
                            reach[y[i]] = reach[x[i]];
                        }
                        else
                        {
                            ans[j] = 'v';
                            reach[x[i]] = reach[y[i]];
                        }
                    }

                    Console.WriteLine(ans);
                    return;
                }
            }
            Console.WriteLine("-1");
            return;

        }
        else if (T == 2)
        {
            if (N <= 2)
            {
                Console.WriteLine(-1);
            }
            else
            {
                t = new bool[M];
                dp = new bool[M, 8];
                if (dfs(0, 7))
                {
                    StringBuilder sb = new StringBuilder();
                    for (int i = 0; i < M; i++)
                    {
                        if (t[i]) sb.Append('^');
                        else sb.Append('v');
                    }
                    Console.WriteLine(sb.ToString());
                }
                else Console.WriteLine(-1);
            }
        }
    }

    bool[] t;
    bool[,] dp;
    bool dfs(int a, int flag)
    {
        if ((flag & (flag - 1)) == 0) return false;
        if (a == M)
        {
            return true;
        }
        if (dp[a, flag]) return false;
        dp[a, flag] = true;
        if (y[a] >= 3)
        {
            t[a] = true;
            return dfs(a + 1, flag);
        }
        else
        {
            t[a] = true;
            if (dfs(a + 1, (flag | (1 << x[a])) & (7 - (1 << y[a])))) return true;
            t[a] = false;
            if (dfs(a + 1, (flag | (1 << y[a])) & (7 - (1 << x[a])))) return true;
        }
        return false;
    }



}


class Scanner
{
    string[] s;
    int i;

    char[] cs = new char[] { ' ' };

    public Scanner()
    {
        s = new string[0];
        i = 0;
    }

    public string next()
    {
        if (i < s.Length) return s[i++];
        string st = Console.ReadLine();
        while (st == "") st = Console.ReadLine();
        s = st.Split(cs, StringSplitOptions.RemoveEmptyEntries);
        if (s.Length == 0) return next();
        i = 0;
        return s[i++];
    }

    public int nextInt()
    {
        return int.Parse(next());
    }
    public int[] ArrayInt(int N, int add = 0)
    {
        int[] Array = new int[N];
        for (int i = 0; i < N; i++)
        {
            Array[i] = nextInt() + add;
        }
        return Array;
    }

    public long nextLong()
    {
        return long.Parse(next());
    }

    public long[] ArrayLong(int N, long add = 0)
    {
        long[] Array = new long[N];
        for (int i = 0; i < N; i++)
        {
            Array[i] = nextLong() + add;
        }
        return Array;
    }

    public double nextDouble()
    {
        return double.Parse(next());
    }


    public double[] ArrayDouble(int N, double add = 0)
    {
        double[] Array = new double[N];
        for (int i = 0; i < N; i++)
        {
            Array[i] = nextDouble() + add;
        }
        return Array;
    }
}


class XRand
{
    uint x, y, z, w;


    public XRand()
    {
        init();
    }

    public XRand(uint s)
    {
        init();
        init_xor128(s);
    }

    void init()
    {
        x = 314159265; y = 358979323; z = 846264338; w = 327950288;

    }

    public void init_xor128(uint s)
    {
        z ^= s;
        z ^= z >> 21; z ^= z << 35; z ^= z >> 4;
        z *= 736338717;
    }

    uint next()
    {
        uint t = x ^ x << 11; x = y; y = z; z = w; return w = w ^ w >> 19 ^ t ^ t >> 8;
    }

    public long nextLong(long m)
    {
        return (long)((((ulong)next() << 32) + next()) % (ulong)m);
    }

    public int nextInt(int m)
    {
        return (int)(next() % m);
    }

    public int nextIntP(int a)
    {
        return (int)Math.Pow(a, nextDouble());
    }

    public int nextInt(int min, int max)
    {
        return min + nextInt(max - min + 1);
    }


    public double nextDouble()
    {
        return (double)next() / uint.MaxValue;
    }

    public double nextDoubleP(double a)
    {
        return Math.Pow(a, nextDouble());
    }
}