递归问题整理打印子序列，求最小路径和

打印一个字符转的子序列，包括空字符串。

获取字符串的数组结

public class Han {


    public static void pringStr(char[] str, int i, String c) {

        if (i == str.length) {
            System.out.println(c);
            return;
        } else {
            pringStr(str, i + 1, c + String.valueOf(str[i]));//要第i个
            pringStr(str, i + 1, c + "");//不要第i个

        }

    }


    public static void convChar(String str) {

        pringStr(str.toCharArray(), 0, "");
    }

    public static void main(String[] args) {
        convChar("abc");
    }
}

构，使用递归每次打印第i个元素和不打印第i个元素

在一个二维数组arr[i][j]中，要求每一步只能想左或者向下，求左上角到右下角的最小路径和

方法一：

1、如果arr[m][n](代表遍历到的位置)中，m=i-1，说明遍历到了最后一行，此处到右下角的最小路径和为最后一行的arr[m][n]位置到arr[i-1][j-1]处。

2、如果arr[m][n](代表遍历到的位置)中，n=j-1，说明遍历到了最后一列，此处到右下角的最小路径和为最后一列的arr[m][n]位置到arr[i-1][j-1]处。

3、如果不是最后一行或最后一列，则返回向左或向右路径的最小值。

public class BCJ {


    public static int creatArr() {
        int[][] arr = new int[][]{{9, 8, 7, 1, 2}, {6, 7, 0, 4, 3}, {5, 6, 7, 2, 1}, {9, 6, 5, 4, 0}};
        int min = getMin(arr, 0, 0, arr.length - 1, arr[0].length - 1);
        return min;
    }


    public static int getMin(int[][] arr, int i, int j, int h, int w) {
        if (h == i && w == j) {
            return arr[i][j];
        }
        if (i == h) {
            return arr[i][j] + getMin(arr, i, j + 1, h, w);
        }
        if (j == w) {
            return arr[i][j] + getMin(arr, i + 1, j, h, w);
        }

        int right = getMin(arr, i, j + 1, h, w);
        int down = getMin(arr, i + 1, j, h, w);
        return arr[i][j] + Math.min(right, down);
    }

    public static void main(String[] args) {
        System.out.println(creatArr());
    }
}

方法二：

建立一个与传入数组一样大的辅助数组，因为左上角到右下角的坐标已经确定，就可以将右下角左边对应的行和列求出并赋值给辅助数组相应的左标，然后再遍历其余位置，将每个位置对应的向左和向下的和分别求出，再将最小值赋值给辅助数组相应的位置，最后返回辅助数组左上角的元素即为最小路径。

public class BCJ {


    public static int creatArr() {
        int[][] arr = new int[][]{{9, 8, 7, 1, 2}, {6, 7, 0, 4, 3}, {5, 6, 7, 2, 1}, {9, 6, 5, 4, 0}};
        int[][] tmp = new int[arr.length][arr[0].length];
        int min = getMin(arr, 0, 0, tmp);
        return min;
    }


    public static int getMin(int[][] arr, int i, int j, int[][] tmp) {
        tmp[arr.length - 1][arr[0].length - 1] = arr[arr.length - 1][arr[0].length - 1];
        int dw = arr.length - 1;
        int lh = arr[0].length - 1;
        for (int k = arr[0].length - 2; k >= j; k--) {
            tmp[dw][k] = arr[dw][k] + tmp[dw][k + 1];
        }
        for (int k = arr.length - 2; k >= i; k--) {
            tmp[k][lh] = arr[k][lh] + tmp[k + 1][lh];
        }
        for (int k = arr.length - 2; k >= i; k--) {
            for (int l = arr[0].length - 2; l >= j; l--) {
                tmp[k][l] = Math.min(arr[k][l] + tmp[k][l + 1], arr[k][l] + tmp[k + 1][l]);
            }
        }
        return tmp[i][j];
    }

    public static void main(String[] args) {
        
        System.out.println(creatArr());
        
    }
}

有一个数组arr和一个整数sum，怎样从数组中选择任意元素相加得到sum