hdu 1425

Descripción del problema

Déle n números enteros, envíe el número con el m más alto en orden descendente.

Entrada

Cada grupo de datos de prueba tiene dos filas, la primera fila contiene dos números n, m (0 <n, m <1000000) y la segunda fila contiene n números enteros que son diferentes y están en el intervalo [-500000,500000] .

Salida

Para cada grupo de datos de prueba, envíe el número m superior en orden descendente.

Entrada de muestra

5 3 3 -35 92 213 -644

Salida de muestra

213 92 3

Esta pregunta es muy simple, la idea es ordenar la matriz y luego la salida. Aquí comparo usando el método de clasificación de la clase Arrays y haciendo una clasificación rápida aleatoria.

1. Ordenar usando Array.sort ():

package hdu;

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n, m;
		int[] a;
		while(sc.hasNextInt()) {
			n = sc.nextInt();
			m = sc.nextInt();
			a = new int[n];
			for(int i=0; i<n; i++){
				a[i] = sc.nextInt();
			}
			Arrays.sort(a);
			for(int i=n-1; i>=n-m; i--) {
				if(i==n-m) System.out.println(a[i]);
				else System.out.print(a[i]+" ");
			}
		}
	}
}

resultado:

1. Escriba su propio algoritmo de clasificación rápida aleatoria para ordenar:

package hdu;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class HDU1425 {
	private static void sort(int[] array, int p, int q) {
		int temp = array[q];
		array[q] = array[p];
		array[p] = temp;
	}

	private static int QuickSort(int[] array, int p, int q) {
		int i = p + 1, j = p, x = array[p];
		while (i <= q) {
			if (array[i] < x) {
				j++;
				sort(array, j, i);
			}
			i++;
		}
		sort(array, p, j);
		return j;
	}

	private static int randomPartition(int[] array, int p, int q) {
		int r = 0;
		Random ra = new Random();
		int i = ra.nextInt(q - p) + p;
		sort(array, p, i);
		return QuickSort(array, p, q);
	}

	private static void randomizeQuickSort(int[] array, int p, int q) {
		if (p < q) {
			int r = randomPartition(array, p, q);
			randomizeQuickSort(array, p, r);
			randomizeQuickSort(array, r + 1, q);
		} else
			return;
	}
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n, m;
		int[] a;
		while(sc.hasNextInt()) {
			n = sc.nextInt();
			m = sc.nextInt();
			a = new int[n];
			for(int i=0; i<n; i++){
				a[i] = sc.nextInt();
			}
			randomizeQuickSort(a,0,n-1);
			for(int i=n-1; i>=n-m; i--) {
				if(i==n-m) System.out.println(a[i]);
				else System.out.print(a[i]+" ");
			}
		}
	}
}

resultado:

Se puede ver en los resultados: Exe.Time y Exe.Memory son casi iguales. Después de comprender y ver el código fuente, Array.sort () también usa la clasificación rápida, que es una clasificación rápida de dos ejes.