Problem:
Score : 1200 points

Problem Statement

There are N arrays.
The length of each array is M and initially each array contains integers (1，2，...，M) in this order.

Mr. Takahashi has decided to perform Q operations on those N arrays.
For the i-th (1≤i≤Q) time, he performs the following operation.

Choose an arbitrary array from the N arrays and move the integer a_i (1≤a_i≤M) to the front of that array. For example, after performing the operation on a_i=2 and the array (5，4，3，2，1), this array becomes (2，5，4，3，1).

Mr. Takahashi wants to make N arrays exactly the same after performing the Q operations.
Determine if it is possible or not.

Constraints

2≤N≤10^5

2≤M≤10^5

1≤Q≤10^5

1≤a_i≤M

Input

The input is given from Standard Input in the following format:

N M
Q
a_1 a_2 ... a_Q

Output

Print Yes if it is possible to make N arrays exactly the same after performing the Q operations.
Otherwise, print No.

Sample Input 1

2 2
3
2 1 2

Sample Output 1

Yes

You can perform the operations as follows.

Sample Input 2

3 2
3
2 1 2

Sample Output 2

No

Sample Input 3

2 3
3
3 2 1

Sample Output 3

Yes

You can perform the operations as follows.

Sample Input 4

3 3
6
1 2 2 3 3 3

Sample Output 4

No

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.io.*;
import java.util.*;

public class Main {

    public void solve() {
        int n = in.nextInt(), m = in.nextInt(), q = in.nextInt();
        int[] a = new int[q];
        Map<Integer, List<Integer>> occ = new HashMap<>();
        for (int i = 0; i < q; i++) {
            a[i] = in.nextInt() - 1;
            if (!occ.containsKey(a[i])) {
                occ.put(a[i], new ArrayList<>());
            }
            occ.get(a[i]).add(i);
        }
        for (int i : occ.keySet()) {
            List<Integer> l = occ.get(i);
            Collections.reverse(l);
            if (l.size() > n) {
                l = l.subList(0, n);
            }
            occ.put(i, l);
        }
        List<Integer> order = new ArrayList<>();
        List<List<Integer>> toCompare = new ArrayList<>();

        Set<Integer> removed = new HashSet<>();
        for (int i = q - 1; i >= 0; i--) {
            if (!removed.contains(a[i])) {
                order.add(a[i]);
                toCompare.add(occ.get(a[i]));
                removed.add(a[i]);
            }
        }
        for (int i = 0; i < m; i++) {
            if (!removed.contains(i)) {
                order.add(i);
                toCompare.add(new ArrayList<>());
            }
        }

        for (int i = 0; i < order.size() - 1; i++) {
            List<Integer> l1 = toCompare.get(i), l2 = toCompare.get(i + 1);

            if (l2.size() > l1.size()) {
                out.println("No");
                return;
            }
            // l1.size() >= l2.size()

            for (int j = 0; j < l2.size(); j++) {
                if (l1.get(j) < l2.get(j)) {
                    out.println("No");
                    return;
                }
            }

            if (l1.size() != n && order.get(i) > order.get(i + 1)) {
                out.println("No");
                return;
            }
        }
        out.println("Yes");

    }

    public void run() {
        in = new FastScanner();
        out = new PrintWriter(System.out);
        solve();
        out.close();
    }

    FastScanner in;
    PrintWriter out;

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(String fileName) {
            try {
                br = new BufferedReader(new FileReader(fileName));
            } catch (FileNotFoundException e) {
            }
        }

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(nextToken());
        }

        long nextLong() {
            return Long.parseLong(nextToken());
        }

        double nextDouble() {
            return Double.parseDouble(nextToken());
        }
    }

    public static void main(String[] args) {
        new Main().run();
    }
}