介紹

網上的24點演算法基本上都專注於4張牌湊24點，有的演算法甚至枚舉了所有括號的組合，讓人看得頭暈眼花。這些演算法若是推廣到n個數湊n點，基本都歇菜了。

本演算法採用暴力列舉法，能處理任意個數湊任意值。以24點為例，本演算法會枚舉出4個數+3個運算子能組成的所有組合，每種組合當作字尾表示式構造成為表示式樹，得出結果。

列舉所有可能的字尾表示式

列舉所有排列的演算法就是套用遞迴模板。

以24點為例，4個數，必然需要3個運算子。我們的目的就是找到這4數3符的所有排列方式。

第一步：枚舉出“從加減乘除四種運算子中拿出三個運算子”的所有情況。

這可不是A43=4這樣簡單，因為每種運算子可以重複。（比如“+++”、“---”這樣）。最簡單的辦法是無腦枚舉出所有情況（4*4*4=64種）然後刪除重複的。或者如下面genOpPermute(int n)方法所做的，列舉的過程中剪掉重複的。最終會留下20種組合。

第二步：將枚舉出的20種運算子組合與4個數字整合成一個String陣列。分別找出20個String陣列的全排列。

比如四個數是8，7，4，7，那麼我就有了 {8，7，4，7，+，+，+} {8，7，4，7，-，-，-}...等20種組合。對每種組合，我們都要找到其全排列。全排列的演算法下面有，注意要避免重複的情況，如8 7 4 7 和 8 7 4 7應算是同一種情況。

package helpers;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class PermuteGen {
	
	private static char[] ops=new char[] {'+','-','*','/'};
	
	
	
	/**
	 * 加減乘除選n個 可重複選 所有選法
	 * @param n
	 * @return
	 */
	public static List<List<Character>> genOpPermute(int n){
		ArrayList<Character> tempList=new ArrayList<Character>();
		List<List<Character>> ans=new ArrayList<List<Character>>();
		opBacktrack(n,tempList,ans,new HashSet<Integer>());//用HashSet儲存運算子的乘積，已達到去除重複的目的（+*/和*/+算是一種情況，這兩種情況三個char的乘積是相同的）		return ans;
	}
	
	private static void opBacktrack(int n,ArrayList<Character> tempList,List<List<Character>> ans,HashSet<Integer> set) {
		if(tempList.size()==n) {
			int i=1;
			for(char c:tempList) {
				i*=c;
			}
			if(!set.contains(i)) {
				ans.add(new ArrayList<Character>(tempList));
				set.add(i);
			}
		}else {
			for(int i=0;i<4;i++) {
				tempList.add(ops[i]);
				opBacktrack(n,tempList,ans,set);
				tempList.remove(tempList.size()-1);
			}
		}
	}
	
	/**
	 * 輸出n個String的全排列
	 * @param n
	 * @return
	 */
	public static List<List<String>> genStrPermute(String[] strs){
		ArrayList<String> tempList=new ArrayList<String>();
		List<List<String>> ans=new ArrayList<List<String>>();
                Arrays.sort(strs);//先排序，讓相同元素相鄰
		strBacktrack(strs,tempList,ans,new boolean[strs.length]);//由於可能含有重複元素（一次抽出兩張2等） 必須有一個數組儲存各個元素的訪問狀態
		return ans;
	}
	
	private static void strBacktrack(String[] strs,ArrayList<String> tempList,List<List<String>> ans,boolean[] used) {
		if(tempList.size()==strs.length) {
			ans.add(new ArrayList<String>(tempList));
		}else {
			for(int i=0;i<strs.length;i++) {
				if(!(used[i] || i>0 && strs[i].equals(strs[i-1]) && !used[i-1])) {
//這裡的邏輯是：當這個元素已被訪問過，則這次不訪問 
//或者 
//兩個連續的相同元素 若前一個還沒被訪問過 後面的堅決不訪問！
//這就相當於給這些重複元素規定了內在的順序，避免了重複！
					tempList.add(strs[i]);
					used[i]=true;
					strBacktrack(strs,tempList,ans,used);
					tempList.remove(tempList.size()-1);
					used[i]=false;;
				}
			}
		}
	}
	
	
}
 

構建表示式樹

表示式樹沒什麼特別的，直接用以前作業改。唯一需要注意的點就是，用枚舉出的所有組合構建表示式樹的過程中一定會出現無法成功建樹的情況。比如+++1234一定無法構建表示式樹，我們需要對這種情況進行甄別。簡單的方法就是看最終構建表示式樹的棧是不是隻剩下1個結點。如果能在生成全排列的過程中剪枝掉不合格的字尾表示式，本演算法甚至不需要用表示式樹，不過本演算法突出一個簡單，最大化利用已有資源，就不考慮那些事情了。

public boolean build (List<String> expr )  // Build tree from prefix expression
    {             
    		
    		Stack<ExprTreeNode> nodeStack=new Stack<ExprTreeNode>();
    		
    		for(int i=0;i<expr.size();i++) {
    			String c=expr.get(i);

    				
				if(isDigit(c)) {
					nodeStack.push(new ExprTreeNode(c,null,null));
    			}

    			else {
    				ExprTreeNode left=null;
    				ExprTreeNode right=null;
    				try {
    					left=nodeStack.pop();
    					right=nodeStack.pop();
    				}catch(Exception e) {
    					
    				}
    				
    				ExprTreeNode opNode=new ExprTreeNode(c,left,right);
    				nodeStack.push(opNode);
    			}
    		}
    		if(nodeStack.size()==1) {//僅當棧內只有1個節點的時候，表示式樹才算構造成功
    			this.root=nodeStack.pop();
    			return true;
    		}
    		return false;
    	
    	
    }
 

當然，表示式樹裡還封裝了計算出字尾表示式結果的方法。算一下看看是否等於24就可以了！

圖形介面

筆者亦製作了配套的圖形介面。

不足之處

由於本演算法是枚舉出所有情況，複雜度相對較高，並且對交換律未作優化，會產生冗餘答案，忘讀者批評指正！