Competencia de práctica del campo de entrenamiento de vacaciones de invierno del algoritmo multi-escolar de Niuke 2018 (primera ronda)
Descripción del título
En el juego PlayerUnknown's Battlegrounds (comer pollo), diferentes armas tienen diferentes poderes y se pueden combinar con diferentes accesorios para mejorar el rendimiento de las armas.
Cada arma tiene su poder y los tipos de accesorios que puede equipar. Cada accesorio tiene su propio tipo, que puede proporcionar una bonificación porcentual a la potencia del arma. Cada arma solo puede equiparse con un accesorio del mismo tipo. Darle n pistolas y m accesorios. La potencia de la pistola es p, y la cantidad de accesorios que se pueden equipar es k. Hay k diferentes tipos de accesorios, y solo se puede equipar uno del mismo tipo de accesorios. El tipo de accesorios está representado por el número q, y la bonificación de potencia de los accesorios está representada por un decimal b. Eliges un arma y la equipas con accesorios para que sea más poderosa.
Suponiendo que la potencia de un arma es p, y la bonificación de potencia de los k accesorios ensamblados es bi, entonces la potencia final del arma es w=p*(1+b1+b2+...+bk).
Descripción de entrada:
hay múltiples conjuntos de datos, procesados hasta el final del archivo.
Los dos números enteros n y m en la primera línea representan el número de armas y accesorios.
Las siguientes n líneas describen las propiedades de n pistolas: el primer número entero es p, que representa la potencia de la pistola; el segundo número entero es k, que representa el número de accesorios que se pueden equipar con la pistola; los siguientes k enteros representan el número de accesorios que se pueden equipar tipo.
Las siguientes m líneas describen los atributos de m accesorios: el primer número entero es q, que representa el tipo de accesorio, y el segundo número de coma flotante es b, que representa la bonificación de potencia que el accesorio puede proporcionar al arma.
Descripción de salida:
cada conjunto de datos se emite como una línea y se emite un número de coma flotante, que representa la potencia máxima de la pistola después de equiparla correctamente con los accesorios. Precisión de 4 decimales.
Ejemplo 1
entrada
3 6
120 3 1 2 3
100 4 1 2 3 4
110 3 2 3 4
1 0.12
2 0.23
2 0.26
4 0.57
3 0.35
5 0.41
producción
239.8000
Instrucciones
Para el ejemplo anterior, la respuesta correcta sería usar la tercera pistola con los accesorios tercero, cuarto y quinto.
El poder máximo del arma es 110*(1+0.26+0.57+0.35)=239.8
Nota:
Para el 100 % de los datos,
1 <= n,m,k,q <= 1000;
0 <= p <= 1000;
0 <= b <= 1.
respuesta
Simulacro: usando una matriz de objetos
import java.util.Scanner;
class Gun {
//枪支威力
public int p;
//枪支可装配的配件数量
public int k;
//可装配配件的种类
public int[] kind = new int[1002];
}
public class Solution {
public static void main(String[] args) {
//声明对象数组
Gun[] g = new Gun[1002];
//记录配件不重复的最大加成系数
double[] pei = new double[1002]; //如果是声明为Double[]，则需实例化每一个数组元素
//实例化对象数组，不然不能使用
for (int i = 0; i < 1002; i++) {
g[i] = new Gun();
}
int n, m;
Scanner in = new Scanner(System.in);
//EOF结束
while (in.hasNext()) {
//枪支数量和配件数量
n = in.nextInt();
m = in.nextInt();
//输入枪的信息
for (int i = 0; i < n; i++) {
g[i].p = in.nextInt();
g[i].k = in.nextInt();
for (int j = 0; j < g[i].k; j++) {
g[i].kind[j] = in.nextInt();
}
}
//输入配件的信息
for (int i = 0; i < m; i++) {
//配件的种类
int q = in.nextInt();
double b = in.nextDouble();
//更新配件的最大威力加成
if (pei[q] < b) {
pei[q] = b;
}
}
//计算最大威力
double max = 0.0;
for (int i = 0; i < n; i++) {
//每把枪乘以括号中的值
double tmp = 1.0;
//遍历每把枪的可装备的配件，计算每把枪乘以括号中的值
for (int j = 0; j < g[i].k; j++) {
tmp += pei[g[i].kind[j]];
}
//比较每把枪的威力，更新最大威力的一把
if (g[i].p * tmp > max) {
max = g[i].p * tmp;
}
}
System.out.printf("%.4f\n", max);
}
}
}