[LeetCode] Can I Win

In the "100 game," two players take turns adding, to a running total, any integer from 1..10. The player who first causes the running total to reach or exceed 100 wins.

What if we change the game so that players cannot re-use integers?

For example, two players might take turns drawing from a common pool of numbers of 1..15 without replacement until they reach a total >= 100.

Given an integer maxChoosableInteger and another integer desiredTotal, determine if the first player to move can force a win, assuming both players play optimally.

You can always assume that maxChoosableInteger will not be larger than 20 and desiredTotal will not be larger than 300.

Example

Input:
maxChoosableInteger = 10
desiredTotal = 11

Output:
false

Explanation:
No matter which integer the first player choose, the first player will lose.
The first player can choose an integer from 1 up to 10.
If the first player choose 1, the second player can only choose integers from 2 up to 10.
The second player will win by choosing 10 and get a total = 11, which is >= desiredTotal.
Same with other integers chosen by the first player, the second player will always win.

很有代表性的最大值最小值算法（Minimax）（有兴趣可以看一下Minimax以及阿尔法贝特剪枝的相关技巧），本题还需要做记忆化搜索，不然会超时：

超时代码：

public class Solution {
	public boolean canIWin(int maxChoosableInteger, int desiredTotal) {
		 if(desiredTotal==0) return true;
		 flag=new boolean[maxChoosableInteger+1];
		 return minimax(desiredTotal, 1);
	}
	
	boolean[] flag;
	public boolean minimax(int target,int player){
		if(target<=0){
			return player==2;
		}	
		if(player==1){
			boolean re=false;
			for(int i=1;i<flag.length;i++){
				if(!flag[i]){
					flag[i]=true;
					re=minimax(target-i, 2);
					flag[i]=false;
					if(re) return true;
				}
			}
			return re;
		}else{
			boolean re=false;
			for(int i=1;i<flag.length;i++){
				if(!flag[i]){
					flag[i]=true;
					re=minimax(target-i, 1);
					flag[i]=false;
					if(!re) return false;
				}
			}
			return re;
		}
	}  
}

ac代码：

public class Solution2 {
	//备注：对于dp(map) 它只需要在意有哪些元素是已经被选择了的，而不需要在意选择顺序和每个选择是被哪一个player选择
	public boolean canIWin(int maxChoosableInteger, int desiredTotal) {
		 if(desiredTotal==0) return true;
		 flag=new boolean[maxChoosableInteger+1];
		 return minimax(desiredTotal, 1);
	}
	boolean[] flag;
	HashMap<Integer,Boolean> dp=new HashMap<Integer, Boolean>();
	public boolean minimax(int target,int player){
		if(target<=0){
			return player==2;
		}	
		int key=format(flag);
		if(dp.containsKey(key)) return dp.get(key);
		if(player==1){
		    boolean re=false;
			for(int i=1;i<flag.length;i++){
				if(!flag[i]){
					flag[i]=true;
					re=minimax(target-i, 2);
					flag[i]=false;
					if(re) return true;
				}
			}
			dp.put(key,re);
			return re;
		}else{
		    boolean re=false;//注意 如果他已经不能选择了 那么直接返回true 这里是一个小trick 所以re初始值赋为false
			for(int i=1;i<flag.length;i++){
				if(!flag[i]){
					flag[i]=true;
					re=minimax(target-i, 1); 
					flag[i]=false;
					if(!re) return false;
				}
			}
			dp.put(key, re);
			return re;
		}
	}  
	public int format(boolean[] used){
		int re=0;
		for(int i=0;i<used.length;i++){
			if(used[i]) re+=1;
			re<<=1;
		}
		return re;
	}
}