面试题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
面试题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
如果数组中有重复的元素的情况
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> arr = ss.getSubsets(a, 0);
arr.remove(0);
Iterator ire = arr.iterator();
while(ire.hasNext())
System.out.println(ire.next());
}
//输出的结果非字典逆序
public ArrayList> getSubsets(int[] A, int index) { //若n表示集合的大小，有2^n个子集
// write code here
ArrayList> allsubsets;
if(A.length == index){ //如果index是达到length，就加上空集
allsubsets = new ArrayList>(); //空集子集
allsubsets.add(new ArrayList());
}else{
allsubsets = getSubsets(A,index + 1); //直到等于length，加上空集后继续执行
int item = A[index];
ArrayList> moresubsets = new ArrayList>();
for(ArrayList subset : allsubsets){ //遍历原来的子集，一个一个加上item后放入新的子集
ArrayList newsubset = new ArrayList();
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 theStack = new Stack();
for(int i=0;i
面试题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= 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 list = new ArrayList();
return placeQueens(0,arr,list,row);
}
int count=0; //计数
public int placeQueens(int row,int[] columns,ArrayList results,int size){//理解的时候画一个3×3的矩阵理解
if(row == size){
count++;
//results.add(columns.clone());
}
else{
for(int col=0;col