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 C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <cstdio>
#include <algorithm>
using namespace std;

int main() {
  int N, M, Q; scanf("%d%d%d", &N, &M, &Q);
  static pair<int,int> queries[100000];
  for(int i = 0; i < Q; ++i) {
    scanf("%d", &queries[i].first); --queries[i].first;
    queries[i].second = i;
  }
  sort(queries, queries+Q);
  // printf("queries = ");
  // for(int i = 0; i < Q; ++i) {
  //   printf("(%d, %d), ", queries[i].first, queries[i].second);
  // }
  // printf("\n");
  static int qidx[100001];
  {
    int i = 0;
    for(int j = 0; j <= M; ++j) {
      while(i < Q && queries[i].first < j) ++i;
      qidx[j] = i;
    }
  }
  // printf("qidx = ");
  // for(int i = 0; i <= M; ++i) {
  //   printf("%d, ", qidx[i]);
  // }
  // printf("\n");
  static int lru_seq[100000];
  for(int i = 0; i < M; ++i) {
    lru_seq[i] = i;
  }
  sort(lru_seq, lru_seq+M, [&](int x, int y) -> bool {
      int xx = (qidx[x] == qidx[x+1]) ? ~x : queries[qidx[x+1]-1].second;
      int yy = (qidx[y] == qidx[y+1]) ? ~y : queries[qidx[y+1]-1].second;
      return xx < yy;
  });
  // printf("lru_seq = ");
  // for(int i = 0; i < M; ++i) {
  //   printf("%d, ", lru_seq[i]);
  // }
  // printf("\n");
  int max_ign = 0;
  while(max_ign < M && lru_seq[max_ign] == lru_seq[0] - max_ign) ++max_ign;
  // printf("max_ign = %d\n", max_ign);
  static int max_times[100000];
  fill(max_times, max_times+N, Q);
  for(int i = M-1; i >= max_ign; --i) {
    int j = qidx[lru_seq[i]+1]-1;
    int min_j = qidx[lru_seq[i]];
    for(int k = 0; k < N; ++k) {
      while(j >= min_j && queries[j].second > max_times[k]) --j;
      if(j < min_j) {
        printf("No\n");
        return 0;
      }
      max_times[k] = queries[j].second;
      // printf("i=%d: max_times[%d] = %d\n", i, k, max_times[k]);
      --j;
    }
  }
  printf("Yes\n");
  return 0;
}