凡是递归的过程，都可以化成树的过程。递归就是问题变成子问题求解的过程。动态规划暂时没明白，好像是需要一张动态规划表，是根据递归搞出来的。

问题1：开始有一头母牛，母牛每年会生一只母牛，新出生的母牛成长三年后也能每年生一只母牛，假设牛都不会死。 求N年后，母牛的数量。

public class cow {

    public int cowNum(int n){
        if(n <= 0)
            return 0;
        if(n == 1 || n == 2 || n == 3)
            return n;
        return cowNum(n - 1) + cowNum(n - 3);
    }

    public static void main(String[] args) {
        System.out.println(new cow().cowNum( 4));;
    }
}

问题2：打印一个字符串的全部子序列，包括空字符串

public class printAllSubsequence {

    public void printAll(char[] arr, int i, String res){
        if(i == arr.length){
            System.out.println(res);
            return;
        }

        printAll(arr, i + 1, res + arr[i]);
        printAll(arr, i + 1, res);
    }

    public static void main(String[] args) {
        String res = "abc";
        new printAllSubsequence().printAll(res.toCharArray(), 0, "");
    }
}

问题3：给你一个二维数组，二维数组中的每个数都是正数，要求从左上角走到右下角，每一步只能向右或者向下。沿途经过的数字要累加起来。返回最小的路径和。

public class minPath {

    public int minPath(int[][] matrix, int i, int j){
        int res = matrix[i][j];
        if(i == matrix.length - 1 && j == matrix[0].length - 1)
            return res;
        if(i == matrix.length - 1)
            return res + minPath(matrix, i, j + 1);
        if(j == matrix[0].length - 1)
            return res + minPath(matrix, i + 1, j);
        int right = minPath(matrix, i, j + 1);
        int down = minPath(matrix, i + 1, j);
        return res + Math.min(right, down);
    }

    public static void main(String[] args) {
        int[][] m = { { 1, 3, 5, 9 }, { 8, 1, 3, 4 }, { 5, 0, 6, 1 }, { 8, 8, 4, 0 } };
        System.out.println(new minPath().minPath(m, 0, 0));
    }
}

问题4：给你一个数组arr，和一个整数aim。如果可以任意选择arr中的数字，能不能累加得到aim。能返回true，否则为false。

public class isSum {

    public boolean isSum(int[] arr, int i, int sum, int aim){
        if(i == arr.length)
            return sum == aim;
        return isSum(arr, i + 1, sum, aim) || isSum(arr, i + 1, sum + arr[i], aim);
    }

    public static void main(String[] args) {
        int[] arr = {1, 4, 8};
        System.out.println(new isSum().isSum(arr, 0, 0, 12));
    }
}