| void swap(int *arr, int i, int j) |
|
|
| { |
| int tmp = arr[i]; |
| arr[i] = arr[j]; |
| arr[j] = tmp; |
| } |
|
|
| int partition(int *arr, int n, int low, int high) |
|
|
| { |
| int pivot = arr[high]; |
| int i = low - 1; |
|
|
| for (int j = low; j < high; j++) { |
| if (arr[j] <= pivot) { |
| i++; |
| swap(arr, i, j); |
| } |
| } |
| swap(arr, i + 1, high); |
| return i + 1; |
| } |
|
|
| void quicksort_range(int *arr, int n, int left, int right) |
|
|
| { |
| if (left < right) { |
| int p = partition(arr, n, left, right); |
| if (p > left) { |
| quicksort_range(arr, n, left, p - 1); |
| } |
| if (p < right) { |
| quicksort_range(arr, n, p + 1, right); |
| } |
| } |
| } |
|
|
| void int_array_quicksort(int *arr, int n) |
|
|
| { |
| quicksort_range(arr, n, 0, n - 1); |
| } |
|
|
| int discretize(const int *src, int n, int *dest_map) |
|
|
| { |
|
|
| for (int i = 0; i < n; i++) { |
| dest_map[i] = src[i]; |
| } |
|
|
| int_array_quicksort(dest_map, n); |
| int slow = 0; |
|
|
| for (int fast = 1; fast < n; fast++) { |
| if (dest_map[fast] != dest_map[slow]) { |
| slow++; |
| dest_map[slow] = dest_map[fast]; |
| } |
| } |
| return slow + 1; |
| } |
|
|
| int query_forward(const int *map, int map_size, int target) |
|
|
| { |
| int low = 0; |
| int high = map_size - 1; |
|
|
| while (low <= high) { |
| int mid = low + (high - low) / 2; |
|
|
| if (map[mid] == target) { |
| return mid; |
| } else if (map[mid] < target) { |
| low = mid + 1; |
| } else { |
| high = mid - 1; |
| } |
| } |
| return -1; |
| } |
|
|
