Problem:
Score : 300 points

Problem Statement

Given is a sequence of integers A_1, A_2, ..., A_N.
If its elements are pairwise distinct, print YES; otherwise, print NO.

Constraints

2 ≤ N ≤ 200000

1 ≤ A_i ≤ 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 ... A_N

Output

If the elements of the sequence are pairwise distinct, print YES; otherwise, print NO.

Sample Input 1

5
2 6 1 4 5

Sample Output 1

YES

The elements are pairwise distinct.

Sample Input 2

6
4 1 3 1 6 2

Sample Output 2

NO

The second and fourth elements are identical.

Sample Input 3

2
10000000 10000000

Sample Output 3

NO

Solution in C (GCC 5.4.1) (judge verdict: Runtime Error)

#include <stdio.h>

void swap (long int *x, long int *y);
int partition (long int array[], int left, int right);
void quick_sort (long int array[], int left, int right);

int main(void){
  int n;
  long int* a;
  
  scanf("%d", &n);
  
  a = (long int)malloc(sizeof(long int)*n);
  for(int i=0; i < n; i ++){
    scanf("%d ", &a[i]);
  }
  
  quick_sort(a, 0, n-1);
  
  for(int i=0; i < n-1; i ++){
  	if(a[i] == a[i+1]){
      printf("NO");
      return 0;
    }
  }
  printf("YES");
  return 0;
}

void swap (long int *x, long int *y) {
  long int temp; 

  temp = *x;
  *x = *y;
  *y = temp;
}

int partition (long int array[], int left, int right) {
  int i, j, pivot;
  i = left;
  j = right + 1;
  pivot = left;   // 先頭要素をpivotとする

  do {
    do { i++; } while (array[i] < array[pivot]);
    do { j--; } while (array[pivot] < array[j]);
    // pivotより小さいものを左へ、大きいものを右へ
    if (i < j) { swap(&array[i], &array[j]); }
  } while (i < j);

  swap(&array[pivot], &array[j]);   //pivotを更新

  return j;
}

/* クイックソート */
void quick_sort (long int array[], int left, int right) {
  int pivot;

  if (left < right) {
    pivot = partition(array, left, right);
    quick_sort(array, left, pivot-1);   // pivotを境に再帰的にクイックソート
    quick_sort(array, pivot+1, right);
  }
}