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 Java7 (OpenJDK 1.7.0) (judge verdict: Wrong Answer)

import java.util.*;

public class Main {
	
	int numArrays;
	int upperLimit;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		int numArrays = sc.nextInt();
		int upperLimit = sc.nextInt();
		int[][] arr = new int[numArrays][upperLimit];

		for (int i = 0; i < numArrays; i++) {
			for (int j = 0; j < upperLimit; j++) {
				arr[i][j] = j+1;	
			}
		}

		int numOps = sc.nextInt();
		int[] ops = new int[numOps];
		for (int i = 0; i < numOps; i++) {
			ops[i] = sc.nextInt();
		}

		if (possible(arr, numArrays, upperLimit, ops)) 
			System.out.println("Yes");
		else
			System.out.println("No");

		// moveFront(ops, arr);
		// print(arr, numArrays, upperLimit); // for checking
	}

	public static boolean possible(int[][] arr, int numArrays, int upperLimit, int[] ops) {
		
		
		return true;
	}

	public static void moveFront(int[] ops, int[][] arr) {
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr[i].length; j++) {
				if (arr[i][j] == ops[i]) {
					int[][] newArr = clone(arr);
					newArr[i][j] = ops[i];
				}
			}
		}	
	}
		
	public static int[][] clone(int[][] arr) {
		int[][] newArr = new int[arr.length][arr[0].length];
		// clone the arr
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr[i].length-1; j++) {
				newArr[i][j+1] = arr[i][j];		
			}
		}

		return newArr;
	}
		

	public static void print(int[][] arr, int numArrays, int upperLimit) {
		for (int i = 0; i < numArrays; i++) {
			System.out.print("(");
			for (int j = 0; j < upperLimit; j++) {
				System.out.print(arr[i][j]);
				if (j != upperLimit-1) 
					System.out.print(",");
			}
			System.out.println(")");
		} 
	}

}