public List<List<Integer>> combinationSum2(int[] candidates, int target) {
    	Arrays.sort(candidates);
    	List<List<Integer>> res=new ArrayList<List<Integer>>();
    	ArrayList<Integer> r=new ArrayList<Integer>();
    	solve(res,r,candidates,target,0);
    	return res;
    }
    public void solve(List<List<Integer>> res,ArrayList<Integer> r,int[] candidates,int target,int index){
    	if(target==0){
    		ArrayList<Integer> clone=new ArrayList<Integer>(r);
    		res.add(clone);
    		return;
    	}
    	if(index>=candidates.length||target<candidates[index])return; 
    	//选择当前元素
    	r.add(candidates[index]);
    	solve(res, r, candidates, target-candidates[index], index+1);
    	r.remove(r.size()-1);
    	//不选择当前元素
    	int nextIndex=index+1;
    	while(nextIndex<candidates.length&&candidates[nextIndex]==candidates[index])nextIndex++;
    	solve(res, r, candidates, target, nextIndex);
    }

    public List<List<Integer>> combinationSum3(int k, int n) {
    	List<List<Integer>> res=new ArrayList<List<Integer>>();
    	ArrayList<Integer> sub=new ArrayList<Integer>();
        solve(res,sub,k,n,1);
        return res;
    } 
    private void solve(List<List<Integer>> res,ArrayList<Integer> sub,int k,int n,int start){
    	if(sub.size()==k&&n==0){
    		ArrayList<Integer> clone=new ArrayList<Integer>(sub);
    		res.add(clone);
    		return;
    	}
    	if(n<0||start==10||(sub.size()==k&&n!=0)){
    		return;
    	}
    	//选择当前元素
    	sub.add(start);
    	solve(res,sub,k,n-start,start+1);
    	sub.remove(sub.size()-1); 
    	//不选择当前元素
    	solve(res,sub,k,n,start+1);
    }

    public List<String> generateParenthesis(int n) {
        List<String> res=new ArrayList<String>();
        if(n==0){
        	res.add("");
        	return res;
        }
        StringBuilder r=new StringBuilder();
        solve(n,0,0,res,r);
        return res;
    }
    private void solve(int n,int left,int right,List<String> res,StringBuilder r){
    	if(r.length()==2*n){
    	    System.out.println(r.toString());
    		res.add(r.toString());
    		return;
    	} 
    	if(left<right)return;
    	if(left<n){
            //添加左边括号
            r.append("(");
            solve(n,left+1,right,res,r);
            r.setLength(r.length() - 1);
    	} 
    	//添加右边括号
    	r.append(")");
    	solve(n,left,right+1,res,r);
    	r.setLength(r.length() - 1); 
    }

    public List<List<Integer>> subsets(int[] nums) {
    	List<List<Integer>> res=new ArrayList<List<Integer>>(); 
    	res.add(new ArrayList<Integer>()); 
    	for(int i=0;i<nums.length;i++){
    		List<List<Integer>> t=new ArrayList<List<Integer>>(); 
    		for(List<Integer> r:res){ 
    			t.add(r);
    			ArrayList<Integer> clone=new ArrayList<Integer>(r);
    			clone.add(nums[i]);
    			t.add(clone);
    		}
    		res=t;
    	}
    	return res;
    }

    public List<List<Integer>> subsetsWithDup(int[] nums) {
    	Arrays.sort(nums);
    	boolean[] used=new boolean[nums.length];
    	List<List<Integer>> res=new ArrayList<List<Integer>>(); 
    	ArrayList<Integer> sub=new ArrayList<Integer>();
    	solve(res,0,sub,nums,used); 
     	return res;
    }
    private void solve(List<List<Integer>> res,int start,ArrayList<Integer> sub,int[] nums,boolean[] used){
    	if(start==nums.length){
    		ArrayList<Integer> clone=new ArrayList<Integer>(sub);
    		res.add(clone);
    		return;
    	}
    	//选择当前元素
    	if(start>0&&nums[start]==nums[start-1]&&!used[start-1]){
    		//do nothing
    	}else{
    		used[start]=true;
    		sub.add(nums[start]);
    		solve(res,start+1,sub,nums,used);
    		sub.remove(sub.size()-1);
    		used[start]=false;
    	}
    	//不选择当前元素
    	solve(res,start+1,sub,nums,used);
    }

    public boolean exist(char[][] board, String word) {
    	boolean used[][]=new boolean[board.length][board[0].length];
    	for(int i=0;i<board.length;i++){
    		for(int j=0;j<board[0].length;j++){
    			if(solve(board,word,i,j,used,0)) 
    			    return true;
    		}
    	}
        return false;
    }
    public boolean solve(char[][] board,String word,int row,int col,boolean[][] used,int start){
    	if(start==word.length()){
    		return true;
    	}
    	if(row<0||col<0||row==board.length||col==board[0].length){
    		return false;
    	}  
    	if(board[row][col]!=word.charAt(start)||used[row][col]){
    		return false;
    	}
    	if(used[row][col]){
    		return false;
    	}
    	used[row][col]=true;
		boolean mark=false;
		mark=mark||solve(board,word,row+1,col,used,start+1);
		mark=mark||solve(board,word,row-1,col,used,start+1);
		mark=mark||solve(board,word,row,col+1,used,start+1);
		mark=mark||solve(board,word,row,col-1,used,start+1);
		used[row][col]=false;
		return mark;
    }

    public List<List<String>> partition(String s) {
    	List<List<String>> res=new ArrayList<List<String>>();
    	List<String> sub=new ArrayList<String>();
    	solve(res,sub,s,0);
    	return res;
    }
    private void solve(List<List<String>> res,List<String> sub,String s,int start){
    	if(start==s.length()){
    		List<String> clone=new ArrayList<String>(sub);
    		res.add(clone);
    		return;
    	}
    	List<Integer> ends=new ArrayList<Integer>();
    	for(int i=start;i<s.length();i++){
    		if(isPalindrome(s,start,i)){
    			ends.add(i);
    		}
    	}
    	for(int end:ends){
    		sub.add(s.substring(start, end+1));
    		solve(res,sub,s,end+1);
    		sub.remove(sub.size()-1);
    	}
    }
    private boolean isPalindrome(String s,int start,int end){
    	while(start<=end){
    		if(s.charAt(start)!=s.charAt(end)){
    			return false;
    		} 
    		start++;end--;
    	}
    	return true;
    }

    public void solveSudoku(char[][] board) {
        ArrayList<ArrayList<Integer>> emptyLocations=
        		new ArrayList<ArrayList<Integer>>();
        for(int row=0;row<9;row++){
        	for(int col=0;col<9;col++){
        		if(board[row][col]=='.'){
        			ArrayList<Integer> location=new ArrayList<Integer>();
        			location.add(row);location.add(col);
        			emptyLocations.add(location);
        		}
        	}
        }
        solve(board,0,emptyLocations);
    }
    private boolean solve(char[][] board,int index,ArrayList<ArrayList<Integer>> emptyLocations){
    	if(index==emptyLocations.size()){
    		return true;
    	}
    	ArrayList<Integer> location=emptyLocations.get(index);
    	int row=location.get(0),col=location.get(1);
    	for(char c='1';c<='9';c++){ 
    		if(isValid(board,row,col,c)){
    			board[row][col]=c;
    			if(solve(board,index+1,emptyLocations)){
    				return true;
    			}else{
    				board[row][col]='.';
    			}
    		}
    	}
    	return false;
    }
    public boolean isValid(char[][] board,int row,int col,char c){
    	//验证行
    	for(int i=0;i<9;i++){
    		if(board[row][i]==c)
    			return false;
    	}
    	//验证列
    	for(int i=0;i<9;i++){
    		if(board[i][col]==c)
    			return false;
    	}
    	//验证3*3格子
    	for(int i=(row/3)*3;i<(row/3)*3+3;i++){
    		for(int j=(col/3)*3;j<(col/3)*3+3;j++){
    			if(board[i][j]==c)
    				return false;
    		}
    	}
    	return true;
    }

    public List<List<String>> solveNQueens(int n) { 
    	ArrayList<Integer> locations=new ArrayList<Integer>();
    	List<List<String>> res=new ArrayList<List<String>>();
    	solve(res,locations,n);
    	return res;
    }
    private void solve(List<List<String>> res,ArrayList<Integer> locations,int n){
    	if(n==locations.size()){
    		addRes(res,locations);
    		return;
    	}
    	for(int i=0;i<n;i++){
    		if(isValid(locations,i)){
    			locations.add(i);
    			solve(res,locations,n);
    			locations.remove(locations.size()-1);
    		}
    	} 
    }
    private boolean isValid(ArrayList<Integer> locations,int location){
    	for(int i=0;i<locations.size();i++){
    		if(location-locations.get(i)==locations.size()-i||
    				location-locations.get(i)==i-locations.size())
    			return false;
    		if(location==locations.get(i))
    			return false;
    	}
		return true;
    }
    private void addRes(List<List<String>> res,ArrayList<Integer> locations){
    	List<String> r=new ArrayList<String>();
    	for(int i=0;i<locations.size();i++){
    		StringBuilder builder=new StringBuilder();
    		for(int j=0;j<locations.size();j++){
    			if(locations.get(i)==j){
    				builder.append("Q");
    			}else{
    				builder.append(".");
    			}
    		}
    		r.add(builder.toString());
    	}
    	res.add(r);
    }

    public List<List<String>> solveNQueens(int n) {
    	int[] locations=new int[n+1];
    	for(int i=1;i<=n;i++){
    		locations[i]=i;
    	}
    	List<List<String>> res=new ArrayList<List<String>>();
    	solve(res,locations,1);
    	return res;
    }
    private void solve(List<List<String>> res,int[] locations,int index){
    	if(index==locations.length){
    		addRes(res,locations);
    		return;
    	}
    	for(int i=index;i<=locations.length-1;i++){
    		if(isValid(locations,index,i)){
    			int t=locations[index];locations[index]=locations[i];locations[i]=t;
    			solve(res,locations,index+1);
    			t=locations[index];locations[index]=locations[i];locations[i]=t;
    		}
    	}
    }
    private boolean isValid(int[] locations,int index,int change){
		for(int i=1;i<index;i++){
			if(locations[i]-locations[change]==index-i||
					locations[i]-locations[change]==i-index)
				return false;
		}
		return true;
    }
    private void addRes(List<List<String>> res,int[] locations){
    	List<String> r=new ArrayList<String>();
    	for(int i=1;i<=locations.length-1;i++){
    		StringBuilder builder=new StringBuilder();
    		for(int j=1;j<=locations.length-1;j++){
    			if(locations[i]==j){
    				builder.append("Q");
    			}else{
    				builder.append(".");
    			}
    		}
    		r.add(builder.toString());
    	}
    	res.add(r);
    }

注：在统计结果数量时，由于Java本身都是按值传递参数的（对于对象传递的是地址值），因此我们不用用int类型统计结果数量，同时由于Integer是不可变的，因此也不能使用Integer。这里我采用Integer容器来统计数量，此外还可以利用AtomicInteger原子整型或自定义引用类型来进行统计，也可以在方法调用中返回结果数量。如有更好的方法忘指教，谢谢！！

    public int totalNQueens(int n) { 
    	ArrayList<Integer> locations=new ArrayList<Integer>();  
    	Stack<Integer> count=new Stack<Integer>();
    	count.add(new Integer(0));
    	solve(locations,n,count);
    	return count.get(0);
    }
    private void solve(ArrayList<Integer> locations,int n,Stack<Integer> count){
    	if(n==locations.size()){
    		count.push(new Integer(count.pop()+1));
    		return;
    	}
    	for(int i=0;i<n;i++){
    		if(isValid(locations,i)){
    			locations.add(i);
    			solve(locations,n,count);
    			locations.remove(locations.size()-1);
    		}
    	} 
    }
    private boolean isValid(ArrayList<Integer> locations,int location){
    	for(int i=0;i<locations.size();i++){
    		if(location-locations.get(i)==locations.size()-i||
    				location-locations.get(i)==i-locations.size())
    			return false;
    		if(location==locations.get(i))
    			return false;
    	}
		return true;
    }