面试题目——《CC150》递归与动态规划

面试题9.1：有个小孩正在上楼梯，楼梯有n个台阶，小孩一次可以上1阶、2阶或者3阶。实现一个方法，计算小孩有多少种上楼梯的方式。

　　思路：第4个数是前三个数之和

　　注意：能不能使用递归，能不能建立一个很大的数组来存储传递的参数（因为可能有空间的限制），要%1000000007防止超出范围

package cc150.recursion_dp;

public class GoUpstairs {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		GoUpstairs gu = new GoUpstairs(); 
		System.out.println(gu.countWays(4));

	}
	
	public int countWays(int n) {
        int index1 = 1;
        int index2 = 2;
        int index3 = 4;
        int sum = 0;
        if(n == 1)
            return index1;
        else if(n == 2)
            return index2;
        else if(n == 3)
            return index3;
        else{
            while(n-- >= 4){			//规律是第4个数是前三个数之和
                sum = ((index1 + index2)%1000000007 + index3)%1000000007;	
                index1 = index2;
                index2 = index3;
                index3 = sum;
            }
            return sum;
        }
    }
	
//	public int countWays(int n) {
//        // write code here
//        if(n < 0)
//        	return 0;
//        else if(n == 0)
//        	return 1;
//        else
//        	return countWays(n-3) + countWays(n-2) + countWays(n-1);
//    }
	
//	public int countWays(int n,int[] map) {	//使用动态规划
//        // write code here
//        if(n < 0)
//        	return 0;
//        else if(n == 0)
//        	return 1;
//        else if(map[n] > 0)
//        	return map[n] % 1000000007;
//        else{
//        	map[n] = countWays(n-1,map) + countWays(n-2,map) + countWays(n-3,map);
//        	return map[n] % 1000000007;
//        }
//    }
	
//	public int[] map = new int[100000];//使用动态规划，有空间限制32768K，不能到100000
//    public int countWays(int n) {
//        // write code here
//        if(n < 0)
//        	return 0;
//        else if(n == 0)
//        	return 1;
//        else if(map[n] > 0)
//        	return map[n] % 1000000007;
//        else{
//        	map[n] = countWays(n-1) + countWays(n-2) + countWays(n-3);
//        	return map[n] % 1000000007;
//        }
//    }

}

面试题9.2：设想有个机器人坐在X×Y网格的左上角，只能向右、向下移动。机器人从（0,0）到（X，Y）有多少种走法？

package cc150.recursion_dp;

public class Robot1 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Robot1 rb = new Robot1();
		System.out.println(rb.countWays(3, 3));
	}
	
	public int countWays(int x, int y)
    {
        if(x==0||y==0)return 0;
        if(x==1||y==1)return 1;
        return countWays(x-1,y)+countWays(x,y-1);	//递归，把最后一步分解成两步
    }
	
//	public int countWays(int x, int y) {
//        // write code here
//		if(x == 1 || y ==1)
//			return 1;
//		if(x > 1&& y > 1){
//			int sum = x + y -2;
//			int sum_jiecheng = sum;
//			while(--sum >= 1){
//				sum_jiecheng *= sum;
//			}
//			x--;
//			int x_jiecheng = x;
//			while(--x >= 1){
//				x_jiecheng *= x;
//			}
//			y--;
//			int y_jiecheng = y;
//			while(--y >= 1){
//				y_jiecheng *= y;
//			}
//			return (sum_jiecheng/x_jiecheng)/y_jiecheng;
//		}
//		return 0;
//    }

}

有障碍的机器人寻路

package cc150.recursion_dp;

public class Robot2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Robot2 rb = new Robot2();
		int[][] a = {{0,1}};
		System.out.println(rb.countWays(a,2,2));
	}
	
	public int countWays(int[][] map, int x, int y) {
        // write code here
		int[][] f = new int[x][y];		//f记录的是到达这个f[x][y]的路径数量
        for(int i=0;i<x;i++){
            for(int j=0;j<y;j++){
              if(map[i][j] != 1)
            	  f[i][j] = 0; 				// 不能走，就是方法数==0
              else if(i==0 && j==0)
            	  f[i][j] = 1; // 起点，1种走法
              else if(i==0 && j!=0)
            	  f[i][j] = f[i][j-1]; // 上边沿：只能从左边来
              else if(i!=0 && j==0)
            	  f[i][j] = f[i-1][j]; // 左边沿：只能从上边来
              else 
            	  f[i][j] = (f[i-1][j]+f[i][j-1]) % 1000000007; // 其他点：左边+上边
            }
        }
        return f[x-1][y-1];
    }

}

面试题9.3：在数组A[0...n-1]中，有所谓的魔术索引，满足条件A[i]=i。给定一个有序整数数组，元素值各不相同，编写一个方法，在数组A中找出一个魔术索引，若存在的话。

package cc150.recursion_dp;

public class MagicIndex {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根

	}
	
	//二分查询法
	public boolean findMagicIndex(int[] A, int n) {	//n为数组的大小
        // write code here
		if(findMagic(A,0,n-1) == -1)		//是n-1
			return false;
		else
			return true;
    }
	
	public int findMagic(int[] A, int start,int end) {	//n为数组的大小
        // write code here
		if(start < 0 || end < start || end >= A.length)
			return -1;
		int mid = (start+end) >> 1;
		if(A[mid] == mid)
			return mid;
		else if(A[mid] > mid)	//大于说明在只能左边
			return findMagic(A,start,mid-1);
		else
			return findMagic(A,mid+1,end);
    }
	
	//暴力查询法
	public boolean findMagicIndex(int[] A, int n) {	//n为数组的大小
        // write code here
		for(int i=0;i<n;i++){
			if(A[i] == i)
				return true;
		}
		return false;
    }

}

如果数组中有重复的元素的情况

package cc150.recursion_dp;

public class MagicIndex {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根

	}
	
	//如果数组中有重复的元素的情况
	//二分查询法
	public boolean findMagicIndex(int[] A, int n) {	//n为数组的大小
        // write code here
		if(findMagic(A,0,n-1) == -1)		//是n-1
			return false;
		else
			return true;
    }
	
	//数组中有重复元素的情况
	public int findMagic(int[] A, int start,int end) {	//n为数组的大小
        // write code here
		if(start < 0 || end < start || end >= A.length)
			return -1;
		int midIndex = (start+end) >> 1;
		int midValue = A[midIndex];
		if(midValue == midIndex)
			return midIndex;
		//有可能在左边，也有可能在右边
		//搜索左半部分
		int leftIndex = Math.min(midIndex-1,midValue);	//比较下标减1和值的大小，较小的作为end，因为值和下标要相等
		int left = findMagic(A,start,leftIndex);
		if(left >= 0)
			return left;
		//搜索右半部分
		int rightIndex = Math.max(midIndex+1,midValue);	//较大的作为start，因为值和下标要相等
		int right = findMagic(A,rightIndex,end);
		return right;
    }

}

面试题9.4：编写一个方法，返回某集合的所有子集。

面试题9.5：编写一个方法，确定某字符串的所有排列组合。

package cc150.recursion_dp;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;

public class Subset {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Subset ss = new Subset();
		int[] a = {1,2,3};
		ArrayList<ArrayList<Integer>> arr = ss.getSubsets(a, 0);
		arr.remove(0);
		Iterator ire = arr.iterator();
		while(ire.hasNext())
			System.out.println(ire.next());
	}
	
	//输出的结果非字典逆序
	public ArrayList<ArrayList<Integer>> getSubsets(int[] A, int index) {	//若n表示集合的大小，有2^n个子集
        // write code here
		ArrayList<ArrayList<Integer>> allsubsets;
		if(A.length == index){	//如果index是达到length，就加上空集
			allsubsets = new ArrayList<ArrayList<Integer>>();	//空集子集
			allsubsets.add(new ArrayList<Integer>());
		}else{
			allsubsets = getSubsets(A,index + 1);		//直到等于length，加上空集后继续执行
			int item = A[index];
			ArrayList<ArrayList<Integer>> moresubsets = new ArrayList<ArrayList<Integer>>();
			for(ArrayList<Integer> subset : allsubsets){		//遍历原来的子集，一个一个加上item后放入新的子集
				ArrayList<Integer> newsubset = new ArrayList<Integer>();
				newsubset.addAll(subset);			//新的子集先放入原来的子集
				newsubset.add(item);						//新的子集放入新加入的A[index]，只有一个
				moresubsets.add(newsubset);	//把新的子集放入moresubsets中,比如空集加上3后是3，空集和3加上2后是2和3,2
			}
			allsubsets.addAll(moresubsets);		//moresubsets用于在循环中存放加上新元素的子集，allsubsets用与存放每一次的moresubsets
		}
		return allsubsets;
    }

}

面试题9.6：实现一种算法，打印n对括号的全部有效组合（即左右括号正确匹配）。（牛客网里面是判断是否正确匹配）

import java.util.*;
 
public class Parenthesis {
    public boolean chkParenthesis(String s, int n) {
        // write code here
        int stackSize = s.length();
        int count = 0;
        Stack<Character> theStack = new Stack<Character>();
        for(int i=0;i<s.length();i++){
            char ch = s.charAt(i);          //遍历每一个字符
            switch(ch){
                case '{':             
                case '[':             
                case '(':             
                    theStack.push(ch);            //遇到'{[('就入栈
                    count++;
                    break;
                      
                case '}':
                case ']':
                case ')':
                    count++;
                    if( !theStack.isEmpty()){
                         char chx = theStack.pop();       //遇到'}])'弹出堆栈
                         if(    (chx=='{' && ch!='}')   ||  (chx=='[' && ch!=']')   ||  (chx=='(' && ch!=')')){
                             return false;
                         }
                    }  
                    else{
                         return false;
                    }
                    break;
                    default:break;
            }
        }
        if(count != stackSize)
            return false;
        if( !theStack.isEmpty()){             //如果栈不为空的话，证明缺少右括号
            return false;
        }
        return true;
    }
}

面试题9.7：编写函数，实现许多图片编辑软件都支持的“填充颜色”功能。给定一个屏幕（以二维数组表示，元素为颜色值）、一个点和一个新的颜色值，将新颜色值填入这个点的周围区域，直到原来的颜色值全都改变。

package cc150.recursion_dp;

public class PaintFill {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		PaintFill pf = new PaintFill();
		Color[][] cl = {{Color.Black,Color.Black,Color.Black},{Color.Black,Color.White,Color.Black},{Color.Black,Color.Black,Color.Black}};
		pf.paintFill(cl,1,1,Color.White,Color.Green);
		for(int i=0;i<cl.length;i++){
			for(int j=0;j<cl[0].length;j++){
				System.out.print(cl[i][j]);
			}
			System.out.println();
		}
	}
	
	//枚举
	enum Color{
		Black,White,Red,Yellow,Green;
	}
	
	//x,y表示填充的坐标，ocolor表示原来的颜色，ncolor表示现在的颜色
	public boolean paintFill(Color[][] screen,int x,int y,Color ocolor,Color ncolor){//x是横坐标，screen[0].length
		if(x < 0 || x >= screen[0].length || y < 0 || y > screen.length)
			return false;
		if(screen[y][x] == ocolor){	//只有颜色等于原来的颜色的点才填充
			screen[y][x] = ncolor;
			paintFill(screen,x-1,y,ocolor,ncolor);
			paintFill(screen,x+1,y,ocolor,ncolor);
			paintFill(screen,x,y-1,ocolor,ncolor);
			paintFill(screen,x,y+1,ocolor,ncolor);
		}
		return true;
	}
	
	public boolean paintFill(Color[][] screen,int x,int y,Color ncolor){
		if(screen[y][x] == ncolor)
			return false;
		return paintFill(screen,x,y,screen[y][x],ncolor);
	}

}

面试题9.8：给定数量不限的硬币，币值为25分，10分，5分和1分，编写代码计算n分有几种表示法。

package cc150.recursion_dp;

public class MakeChange {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MakeChange mc = new MakeChange();
		System.out.println(mc.countWays(100000));
	}
	
	//二维dp
//	public int countWays(int n) {
//	    int A[] = {1, 5, 10, 25}, dp[][] = new int[A.length][n + 1];
//	    for (int j = 0; j <= n; j++) {
//	        dp[0][j] = 1;
//	    }
//	    for (int i = 1; i < A.length; i++) {
//	        for (int j = 0; j <= n; j++) {
//	            int t = j - A[i];
//	            if (t >= 0) {
//	                dp[i][j] = (dp[i - 1][j] + dp[i][t]) % 1000000007;
//	            } else {
//	                dp[i][j] = dp[i - 1][j];
//	            }
//	        }
//	    }
//	    return dp[A.length - 1][n];
//	}
	
	//一维dp，递归求每次减去1,5,10,25后剩下的次数
	public int countWays(int n) {
	    int dp[] = new int[n + 1], i, A[] = {1, 5, 10, 25};	//dp数组中存储的是组合的总数
	    for (i = 0, dp[0] = 1; i < A.length; i++) {		//在{1,5,10,25}中遍历；当j=A[1]=5的时候会计算两次，1增加到5的时候一次，5到5的时候一次
	    	for (int j = A[i]; j <= n; j++) {						//在j小于n的条件下，求1,5,10,25到n中每一个的可能性
	            dp[j] = (dp[j] + dp[j - A[i]]) % 1000000007;		//j-A[i]是在已经选择了A[i]的情况下，求剩下的可能性
	        }
	    }
	    return dp[n];
	}
	
	//很慢，会超时
	public int makeChange(int n,int denom){
		int next_denom = 0;
		switch(denom){
			case 25:
				next_denom = 10;
				break;
			case 10:
				next_denom = 5;
				break;
			case 5:
				next_denom = 1;
				break;
			case 1:				//如果到最后返回1，表示有1种方法
				return 1;
		}
		int ways = 0;
		for(int i=0;i*denom <= n;i++){
			ways += makeChange(n-i*denom,next_denom)%1000000007;		//返回的方法的总数的和
		}
		return ways%1000000007;
	}

}

面试题9.9：设计一种算法，打印八皇后在8×8棋盘上的各种摆法，其中每个皇后都不同行、不同列，也不在对角线上。这里的“对角线”指的是所有的对角线，不只是平分整个棋盘的那两条对角线。

package cc150.recursion_dp;

import java.util.ArrayList;

public class Queens {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Queens q = new Queens();
		System.out.println(q.nQueens(8));
		}

	public int nQueens(int row){
		int[] arr = new int[row];
		ArrayList<int[]> list = new ArrayList<int[]>();
		return placeQueens(0,arr,list,row);
	}
	
	int count=0;		//计数
	
	public int placeQueens(int row,int[] columns,ArrayList<int[]> results,int size){//理解的时候画一个3×3的矩阵理解
		if(row == size){
			count++;
			//results.add(columns.clone());
		}
		else{
			for(int col=0;col<size;col++){				//递归后行数递增，这里for循环检查每一列，然后再返回上一层递归中行数继续增加
				if(checkValid(columns,row,col)){		//从左向右检查每一列，检查同一列，对角线有没有其他皇后
					columns[row] = col;							//columns的下标表示行，值表示列
					placeQueens(row+1,columns,results,size);
				}
			}
		}
		return count;
	}
	
	public boolean checkValid(int[] columns,int row1,int column1){	//columns表示一列，检查有无其他皇后在同一列，columns有可能包含column1
		for(int row2 = 0;row2<row1;row2++){
			int column2 = columns[row2];	//row2,column2的元素
			//检查row2,column2是否会让row1,column1变成无效
			if(column1 == column2)
				return false;
			//检查对角线
			int columnDistance = Math.abs(column2-column1);	
			int rowDistance = row1-row2;					//row1只可能大于row2
			if(columnDistance == rowDistance)
				return false;
		}
		return true;
	}
	
}