[Retroceso] C034_openj_ recuento 24 (esencialmente sin cambios)

1. problema

Dados 4 enteros positivos menores que 10, puede usar la suma, resta, multiplicación y división de 4 operaciones y paréntesis para conectar estos 4 números para obtener una expresión. La pregunta ahora es si hay una manera de hacer que el resultado de la expresión sea igual a 24.

La suma, resta, multiplicación y división, y los resultados de la operación y la prioridad de los paréntesis son consistentes con nuestra definición habitual (la definición de división aquí es división real).

Por ejemplo, para 5, 5, 5, 1, sabemos que 5 * (5 - 1/5) = 24, por lo que podemos obtener 24. Como otro ejemplo, para 1, 1, 4, 2, nunca podemos obtener 24.

De entrada

Los datos de entrada incluyen varias líneas, cada línea proporciona un conjunto de datos de prueba, incluidos 4 menos de 10 enteros positivos. El último conjunto de datos de prueba incluye 4 ceros, que indican el final de la entrada, y este conjunto de datos no necesita ser procesado.

Salida

Para cada conjunto de datos de prueba, envíe una línea, si puede obtener 24, envíe "SÍ"; de lo contrario, envíe "NO".

样例输入
5 5 5 1
1 1 4 2
0 0 0 0
样例输出
YES
NO

Segundo, solución

Método 1: retroceso

• Use un operador para agotar el número, luego regrese a la operación anterior, seleccione la siguiente operación y repita el proceso.
• Cuando se completa una búsqueda profunda, el estado necesita ser restaurado.

import java.util.*;
import java.math.*;
import java.io.*;
public class Main{
	static boolean done;
	static double[] a;
	static double INF = -1e6 * 1.0;
	final static int N = 4;
	static double ops(double a, double b, double k) {
		if (k == 0)      return a + b;
		else if (k == 1) return a - b;
		else if (k == 2) return a * b;
		else             return a / b;
	}
	static void dfs(int x) {
		if (done)
			return;
		Arrays.sort(a);
		if (x == N-1) {
		    if (Math.abs(a[N-1] - 24) < 0.00001)
			    done = true;
			return;
		}
		double[] t = Arrays.copyOf(a, a.length);
		for (int i = x; i < N; i++)
		for (int j = x; j < N; j++) {
		    if (i == j)
		        continue;
			for (int k = 0; k < N; k++) {
				a[i] = ops(a[i], a[j], k);
				a[j] = INF;
				dfs(x+1);
				a = Arrays.copyOf(t, t.length);;
			}
		}
	}
    public static void main(String[] args) throws IOException {  
        Scanner sc = new Scanner(new BufferedInputStream(System.in));
        BufferedWriter w = new BufferedWriter(new OutputStreamWriter(System.out));
        
		while (true) {
		    a = new double[N];
			for (int i = 0; i < a.length; i++) {
				a[i] = sc.nextDouble();
			}
			if (a[0] == 0 && a[1] == 0 && a[2] == 0 && a[3] == 0)
				return;
			done = false;
			dfs(0);
			if (done)System.out.println("YES");
			else 	 System.out.println("NO");
		}
    }
}

Análisis de complejidad.

• Complejidad del tiempo: $O (2 ^ 4)$，
• Complejidad espacial: $O (n)$，