Blue Bridge Cup Sprint veintitrés de 31 días [java]

Embalar

Enlace del tema: http://lx.lanqiao.cn/problem.page?gpid=T2978

Esta es una pregunta de dos puntos. El peso máximo requerido por la pregunta debe estar entre [el peso máximo de un solo artículo y la masa total de todos los artículos], esto definitivamente no es problema, y ​​luego necesitamos buscar en este intervalo .La respuesta que cumple las condiciones es suficiente.Para la checkfunción, solo necesitamos verificar cuántos paquetes se pueden empacar cuando el peso máximo de cada paquete no excede el peso entrante.Cuando targetWeightla cantidad de paquetes que se pueden empacar es menor mayor o igual a la cantidad requerida de paquetes, se indica el peso, se puede satisfacer, se puede ir a averiguar si la calidad menor también se cumple

¿Por qué 当可以打包的包裹数小于等于需要的包裹数时，说明这个重量是可以满足的?

Porque cuando puedes usar menos paquetes para completar este requisito de peso, también es posible tomar algunas piezas de un paquete y hacer otro paquete, es decir, el paquete puede usarse menos de lo requerido, pero no puede Más

package daily;

import java.util.Scanner;

/**
 * http://lx.lanqiao.cn/problem.page?gpid=T2978
 * 
 * @author Jia
 *
 */
public class day3_30_1 {
    
    
	public static void main(String[] args) {
    
    
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int M = sc.nextInt();

		int[] weights = new int[N];
		int maxWeight = 0;// 所有物品的最大重量
		int sumWeight = 0;// 所有物品的总重量
		for (int i = 0; i < weights.length; i++) {
    
    
			weights[i] = sc.nextInt();
			maxWeight = Math.max(maxWeight, weights[i]);
			sumWeight += weights[i];
		}
		sc.close();

		// 二分寻找满足条件的最小重量
		int left = maxWeight;
		int right = sumWeight;
		while (left <= right) {
    
    
			int mid = (right - left) / 2 + left;
			if (check(weights, mid, M)) {
    
    
				// 当这个重量可以满足的时候继续往左边查找
				right = mid - 1;
			} else {
    
    
				// 这个重量不能拼出来的时候向右边查找
				left = mid + 1;
			}
		}
		System.out.println(left);
	}

	/**
	 * 判断当前是否可以满足打包成packNum个包裹，且每个质量均不超过`targetWeight`
	 * 
	 * @param weights
	 * @param targetWeight
	 * @param packNum
	 * @return 如果可以则返回true，否则返回false
	 */
	private static boolean check(int[] weights, int targetWeight, int packNum) {
    
    
		int curWeight = 0;
		int curPackNum = 0;

		for (int i = 0; i < weights.length; i++) {
    
    
			if (curWeight + weights[i] > targetWeight) {
    
    
				curPackNum++;
				curWeight = 0;
			}
			curWeight += weights[i];
		}
		curPackNum++;
		return curPackNum <= packNum;
	}
}

numero aproximado

Enlace del tema: http://lx.lanqiao.cn/problem.page?gpid=T2606

No se me ocurrió un buen método y fui directo a la violencia.Después de ver la escala de los datos, estimé que debería poder pasar la mitad, y finalmente tomé el 60%, que no está mal.

El método es similar al método de detección de números primos, pasando de pequeño a grande, pasando por un número y sumando directamente uno a su factor, mientras se suma el número de factores numéricos actuales a ans y se toma el resto hasta el final.

De hecho, todavía quiero hacerlo con una tabla, poner 10 000 000 de datos directamente en la matriz y enviarlos, pero cuando la salida se atasca durante mucho tiempo, me doy por vencido (tal vez también se pueda enviar directamente al archivo, ver su El límite de memoria es de 512 MB, y 10 ^ 7 números enteros ocuparán alrededor de 50 MB. Siento que el método aún es factible hhh)

package daily;

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

/**
 * http://lx.lanqiao.cn/problem.page?gpid=T2606
 * 
 * @author Jia
 *
 */
public class day3_30_2 {
    
    
	public static void main(String[] args) {
    
    
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		sc.close();

		int[] arr = new int[n + 1];
		int ans = 1;
		int[] ansArr = new int[n + 1];
		Arrays.fill(arr, 1);// 使用1填充数组

		// 统计约数的数量
		for (int i = 2; i < arr.length; i++) {
    
    
			int j = i;
			while (j < arr.length) {
    
    
				arr[j] = (arr[j] + 1) % (1000000007);
				j += i;
			}
			ans = (ans + arr[i]) % (1000000007);
			ansArr[i] = ans;
		}
		System.out.println(ans);
	}
}

buscando tres dígitos

Enlace del tema: http://lx.lanqiao.cn/problem.page?gpid=T2038

Esta pregunta es una pregunta regular, directamente dfs obtiene todas las permutaciones y luego juzga si cada permutación cumple con las condiciones y está bien.

Se recomienda anotar esta pregunta directamente como plantilla para obtener el número de permutaciones, en otras preguntas solo se necesita cambiar checkel contenido en la función.

package daily;

/**
 * http://lx.lanqiao.cn/problem.page?gpid=T2038
 * 
 * @author Jia
 *
 */
public class day3_31_3 {
    
    
	static int[] arr = {
    
     1, 2, 3, 4, 5, 6, 7, 8, 9 };

	public static void main(String[] args) {
    
    
		dfs(0);// 深度有限遍历所有排列数
	}

	/**
	 * dfs获得所有排列数
	 * 
	 * @param index
	 */
	private static void dfs(int index) {
    
    
		if (index == arr.length) {
    
    
			check();
		} else {
    
    
			for (int i = index; i < arr.length; i++) {
    
    
				swap(i, index);
				dfs(index + 1);
				swap(i, index);
			}
		}
	}

	/**
	 * 检查当前排列是否满足条件
	 */
	private static void check() {
    
    
		int num1 = getVal(0, 3);
		int num2 = getVal(3, 6);
		int num3 = getVal(6, 9);
		if (num1 * 2 == num2 && num1 * 3 == num3) {
    
    
			System.out.println(num1 + " " + num2 + " " + num3);
		}
	};

	/**
	 * 将arr在区间[begin,end)中的值转换为int返回
	 * 
	 * @param begin
	 * @param end
	 * @return
	 */
	private static int getVal(int begin, int end) {
    
    
		int ret = 0;
		for (int i = begin; i < end; i++) {
    
    
			ret = ret * 10 + arr[i];
		}
		return ret;
	}

	/**
	 * 交换数组两个位置的元素
	 * 
	 * @param i
	 * @param j
	 */
	private static void swap(int i, int j) {
    
    
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

2.5 Xiaoming infeliz

Enlace del tema: http://lx.lanqiao.cn/problem.page?gpid=T770

Este problema debe resolverse mediante programación dinámica, pero la limitación más difícil es que requiere t veces para llegar al punto final, que es un poco más difícil que el paso convencional.

Aún así, defina una matriz dp con t+1 filas y n+2 columnas, donde $dp\left[i\right]\left[j\right]$ significa laiipasoa$jj$Peso máximo cuando hay$rejillas\; j$

Por lo tanto, la ecuación recursiva se puede escribir como:
$$repag\left[yo\right]\left[j\right]=max\left(repags\right[yo\left]\right[j],\_\_dp[yo-1\left]\right[j-m]+peso[j\_\_\_\_\_-1\left]\right),(dondem\in [1,p\left]\right)$$
y luego todos los elementos de la matriz deben inicializarse primeroIntger.MIN_VALUE, para garantizar que el peso se actualice más de 0 horas, y luego el valor del primer paso también debe actualizarse por adelantado.