[Retour] C034_openj_ count 24 (essentiellement inchangé)

1. Problème

Étant donné 4 entiers positifs inférieurs à 10, vous pouvez utiliser l'addition, la soustraction, la multiplication et la division de 4 opérations et parenthèses pour connecter ces 4 nombres pour obtenir une expression. La question est maintenant de savoir s'il existe un moyen de rendre le résultat de l'expression égal à 24.

L'addition, la soustraction, la multiplication et la division, ainsi que les résultats de l'opération et la priorité des parenthèses sont conformes à notre définition habituelle (la définition de la division ici est la division réelle).

Par exemple, pour 5, 5, 5, 1, nous savons que 5 * (5 - 1/5) = 24, nous pouvons donc obtenir 24. Comme autre exemple, pour 1, 1, 4, 2, nous ne pouvons jamais obtenir 24.

Entrée

Les données d'entrée comprennent plusieurs lignes, chaque ligne donne un ensemble de données de test, dont 4 moins de 10 entiers positifs. Le dernier ensemble de données de test comprend 4 zéros, indiquant la fin de l'entrée, et cet ensemble de données n'a pas besoin d'être traité.

Sortie

Pour chaque ensemble de données de test, sortez une ligne, si vous pouvez en obtenir 24, sortez "OUI", sinon, sortez "NON".

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

Deuxièmement, la solution

Méthode 1: retour en arrière

• Utilisez un opérateur pour épuiser le nombre, puis revenez à l'opération précédente, sélectionnez l'opération suivante et répétez le processus.
• Lorsqu'une recherche approfondie est terminée, l'état doit être restauré.

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");
		}
    }
}

Analyse de complexité

• Complexité temporelle: $O (2 ^ 4)$，
• Complexité de l'espace: $O (n)$，