react拖拽react-beautiful-dnd，一维数组，二维数组

983. 最低票价

这道题用动态规划做其实可以用到暴力递归的关键代码，其实就是加了记录到dp数组的部分，让递归函数不再重复对子问题进行求解。                                                                                        

public static int MAXN = 366;
	public static int[] dp = new int[MAXN];
    public static int[] duration = {1, 7, 30};
	public static int mincostTickets(int[] days, int[] costs) {
		int n = days.length;
		Arrays.fill(dp, 0, n + 1, Integer.MAX_VALUE);
		dp[n] = 0;
		for(int i = n; i >= 0; i--) {
			for(int k = 0, j = i; k < 3; k++) {
				while(j < days.length && duration[k] + days[i] > days[j]) j++;
				dp[i] = Math.min(dp[i], costs[k] + dp[j]);
			}
			
		}
		return dp[0];
	}

91. 解码方法

首先使用递归的方法暴力破解（超时），设置递归函数判定字符区间[0, i]中有多少种方法，也可以理解为一串数字的合法划分有多少种方法。首先判定当前下标对应字符是否为'0'，因为题目给定解码中没有以'0'开头的解码，所以如果是'0'代表这个区间内没有任何一种方式可以解码，也就是之前的划分是有错的，所以返回方法数为0；如果不为'0'，那就要进一步判定当前字符是否能和下一个字符构成不大于26的数字，如果没有这种情况，那就返回区间[0,（i + 1）]的方法数，反之，就再加上区间[0,（i + 2）]的方法数，其实这样就相当于划分当前字符为合法数字，还是划分相邻两个字符为合法数字。

public int f(char[] s, int i) {
        if(i == s.length) return 1;
        int res;
        if(s[i] == '0') {
        	res = 0;
        }else {
        	res = f(s, i + 1);
        	if(i + 1 <s.length && (s[i] - '0') * 10 +(s[i+1] - '0') <= 26) {
        		res  += f(s, i + 2);
        	}
        }
        return res;
    }
    public int numDecodings(String s) {
        return f(s.toCharArray(),0);
    }

因为超时了，所以必须要改成动态规划的做法。会发现改动的部分很少，但是要注意，因为每次对dp数组的求解都完全依赖于它后面的值，所以必须初始化下标n的dp值为1，也可以理解能划分到下标n的字符就证明这个划分是对的，所以如果不对dp[n]初始化，就没有加上这个对的划分。

public int numDecodings(String s) {
		int n = s.length();
        char[] chs = s.toCharArray();
        int[] dp = new int[n + 1];
        dp[n] = 1;
        if(chs[n - 1] != '0') dp[n - 1] = 1;
        for(int i = n - 2; i >= 0; i--) {
        	if(chs[i] == '0') dp[i] = 0;
        	else if((chs[i] - '0') * 10 + (chs[i + 1] - '0') <= 26) {
        		dp[i] = dp[i + 1] + dp[i + 2];
        	} else dp[i] = dp[i + 1];
        }
        return dp[0];
    }