Planteamiento del problema
Problema
Dr. Patel tiene N pilas de placas. Cada pila contiene K placas. Cada placa tiene un positivo valor de la belleza , la descripción de lo hermosa que se ve.
El Dr. Patel le gustaría tener exactamente P placas de usar para la cena de esta noche. Si le gustaría tener una placa en una pila, sino que también debe tomar todas las placas anteriores en esa pila también.
Ayuda Dr. Patel recoger los P placas que maximicen la suma total de los valores de belleza.
Entrada
La primera línea de la entrada da el número de casos de prueba, T . T casos de prueba siguen. Cada caso de prueba comienza con una línea que contiene los tres números enteros N , K y P . Luego, N líneas siguen. El i-ésima línea contiene K números enteros, que describen los valores belleza de cada pila de placas de arriba a abajo.
Salida
Para cada caso de prueba, la salida de una línea que contiene Case #x: y, en donde x es el número de casos de prueba (a partir de 1) y y es la suma total máximo de los valores de belleza que Dr. Patel podría recoger.
límites
Plazo: 20 segundos por equipo de prueba.
límite de memoria: 1 GB.
1 ≤ T ≤ 100.
1 ≤ K ≤ 30.
1 ≤ P ≤ N * K .
Los valores de belleza están entre 1 y 100, ambos inclusive.
Prueba de conjunto 1
1 ≤ N ≤ 3.
Prueba el grupo 2
1 ≤ N ≤ 50.
Muestra
|
Entrada
|
Salida
|
2 2 4 5 10 10 100 30 80 50 10 50 3 2 3 80 80 15 50 20 10 |
Caso # 1: 250 Caso # 2: 180 |
En caso de la muestra # 1, Dr. Patel necesita para recoger P = 5 placas:
- Se puede escoger el 3 placas superiores de la primera pila (10 + 10 + 100 = 120).
- Se puede escoger el 2 placas superiores de la segunda pila (80 + 50 = 130).
En total, la suma de los valores de belleza es 250.
En caso de la muestra # 2, el Dr. Patel necesita para recoger P = 3 placas:
- Se puede escoger el 2 placas superiores de la primera pila (80 + 80 = 160).
- Se puede recoger sin placas de la segunda pila.
- Se puede recoger la placa superior de la tercera pila (20).
En total, la suma de los valores de belleza es 180.
Nota: A diferencia de las ediciones anteriores, en Kick Start de 2020, todos los equipos de prueba son visibles los equipos de prueba veredicto, que significa que recibirá información instantánea sobre la sumisión.
problema enlace
Tutorial de vídeo
Usted puede encontrar el video tutorial detallado aquí
Proceso de pensamiento
El primer pensamiento es similar a la fusión de varias listas, esto no va a funcionar ya que las listas no están ordenadas y no se les permite especie debido a la restricción de orden.
En segundo pensamiento es mantener un máximo de almacenamiento dinámico, y siempre combinar el valor más grande de todos los elementos superiores en las listas. Esto es erróneo ya que la voluntad codiciosa no trabaja aquí. Por ejemplo, por debajo de si queremos recoger 3 placas, utilizando montón max recogerá 2, 2, 2, en lugar de 1, 1, 100
2, 2, 2, 2, 2
1, 1, 100, 100, 100
En tercer pensamiento parece que tenemos a la fuerza bruta, para todos los combos de P, comprobamos cuál es el valor máximo. Citar a partir del análisis, es la complejidad de tiempo exponencial
Por ejemplo, si N = 3 y para cualesquiera valores dados de K y P , generar todos los triples posibles (S 1 , S 2 , S 3 ) de tal manera que S 1 + S 2 + S 3 = P y 0 ≤ S i ≤ K . Nota: S i es el número de placas escogidas de la i-ésima pila.
Esto se puede hacer a través de la recursión y la complejidad tiempo total es O ( K N ) que se rige por los límites de tiempo.
Forth y solución final para optimizar esto está utilizando programación dinámica. Es muy común en las competiciones de codificación.
Cita del análisis
En primer lugar, vamos a considerar un estado intermedio dp [i] [j] que denota la cantidad máxima que se puede obtener usando los primeros pilas i cuando necesitamos para cortar placas j en total .
A continuación, iterar sobre las pilas y tratar de responder a la pregunta: ¿ Cuál es la suma máxima si tuviéramos que elegir placas j en total utilizando el i Las pilas que hemos visto hasta ahora? Esto nos daría dp [i] [j]. Sin embargo, también tenemos que decidir, entre esas placas j, cuántos vienen de la i-ésima pila? es decir, por ejemplo de Let que recoger x placas de la i-ésima pila, entonces dp [i] [j] = max (dp [i] [j], sum [i] [x] + dp [i-1] [JX ]) . Por lo tanto, con el fin de recoger placas j en total de i pilas, podemos recoger en cualquier lugar entre [0, 1, ..., J] platos de la i-ésima pila y [j, j-1, ..., 0 ] placas de los últimos i-1 pilas respectivamente. Además, tenemos que hacer esto para todos los valores de 1 ≤ j ≤ P .
El flujo se vería así:
para i [1, N ]:
para j [0, P ]:
dp [i] [j]: = 0
para x [0, min (J, K )]:
dp [i] [j] = max (dp [i] [j], sum [i] [x] + dp [i-1] [j x])
Si observamos de cerca, esto es similar a la de 0-1 mochila problema con alguna complejidad añadida. Para concluir, la complejidad global tiempo sería O ( N * P * K ).
soluciones
1 público estáticas void principales (args String []) { 2 escáner s = nuevo escáner ( nuevo BufferedReader ( nuevo InputStreamReader (System.in))); 3 4 int casos de prueba = s.nextInt (); 5 int caseNum = 1 ; 6 placas de planchas = nuevas placas (); 7 8 mientras que (caseNum <= casos de prueba) { 9 int n = s.nextInt (); 10 int k = s.nextInt (); 11 int p =s.nextInt (); 12 13 int [] [] valores = nuevo int [n] [k]; 14 para ( int i = 0; i <n; i ++ ) { 15 para ( int j = 0; j <k; j ++ ) { 16 valores [i] [j] = s.nextInt (); 17 } 18 } 19 20 System.out.println (String.Format ( "Caso #% d:% d" , caseNum, plates.maxPlatesBeautyValue (valores, p))); 21 caseNum ++ ; 22 } 23 } 24 25 privado int maxPlatesBeautyValue ( int [] [] valores, int numberOfPlates) { 26 int n = values.length; 27 int k = valores [0 ] .length; 28 int p = numberOfPlates; 29 30 31 // podría utilizar una dimensión de matriz 32 int [] [] prefixSum = nuevo int [n + 1] [k + 1 ]; 33 int [] [] de búsqueda = nuevo int [n + 1] [p + 1 ]; 34 35 para ( inti = 1; i <= n; i ++ ) { 36 para ( int j = 1; j <= k; j ++ ) { 37 prefixSum [i] [j] = prefixSum [i] [j - 1] + valores [i - 1] [j - 1 ]; 38 } 39 } 40 41 para ( int i = 1; i <= n; i ++ ) { 42 para ( int j = 1; j <= p; j ++ ) { 43 lookup [i] [j] = 0 ; 44 45 para ( int x = 0; x <= Math.min (j, k); x ++ ) { 46 lookup [i] [j] = Math.max (lookup [i] [j], prefixSum [i] [x] + lookup [i - 1] [j - x]); 47 } 48 } 49 } 50 51 de retorno de búsqueda [n] [p]; 52 }
solución de DP
Tiempo Complejidad: O (N * P * K)
Espacio Complejidad: O (N * max (P, K))