package y2019.Algorithm.dynamicprogramming.medium;
/**
* @ProjectName: cutter-point
* @Package: y2019.Algorithm.dynamicprogramming.medium
* @ClassName: NumDecodings
* @Author: xiaof
* @Description: 91. Decode Ways
* A message containing letters from A-Z is being encoded to numbers using the following mapping:
*
* 'A' -> 1
* 'B' -> 2
* ...
* 'Z' -> 26
* Given a non-empty string containing only digits, determine the total number of ways to decode it.
*
* Example 1:
*
* Input: "12"
* Output: 2
* Explanation: It could be decoded as "AB" (1 2) or "L" (12).
* Example 2:
*
* Input: "226"
* Output: 3
* Explanation: It could be decoded as "BZ" (2 26), "VF" (22 6), or "BBF" (2 2 6).
* @Date: 2019/8/15 8:54
* @Version: 1.0
*/
public class NumDecodings {
public int solution(String s) {
if (s == null || s.equals("") || (s.length() == 1 && s.equals("0"))) {
return 0;
}
//我们发现这个串总最多一次可以使用2个字符，并且这两个字符组成的数要小于26或等于26才行
//那么我们可以发先要获取当前字符能组成的解码数可分为
//dp[n] = dp[n-1] + {if(2num <= 26}{dp[n-2} 只有满足使用最后2位数作为解码数字的时候才能加上不用这个2个字符可以组成的个数
int[] dp = new int[s.length() + 1];
dp[0] = 1;dp[1] = 1;
char[] sc = s.toCharArray();
for (int i = 2; i < dp.length; ++i) {
//i用来标识取s的前i个字符,还要判断这个字符不能是0，不然不能单个字符使用
if (sc[i - 1] != '0') {
dp[i] = dp[i - 1];
}
//判断如果去除2个数的位置
int l = i - 2;
int value = Integer.valueOf(s.substring(l, i));
if (value <= 26 && value > 0) {
dp[i] += dp[i - 2];
}
}
return dp[s.length()];
}
public static void main(String[] args) {
String s = "12";
String s2 = "226";
String s3 = "10";
NumDecodings fuc = new NumDecodings();
fuc.solution(s3);
}
}
package y2019.Algorithm.dynamicprogramming.medium;
import java.util.List;
/**
* @ProjectName: cutter-point
* @Package: y2019.Algorithm.dynamicprogramming.medium
* @ClassName: MinimumTotal
* @Author: xiaof
* @Description: 120. Triangle
* Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below.
*
* For example, given the following triangle
*
* [
* [2],
* [3,4],
* [6,5,7],
* [4,1,8,3]
* ]
* The minimum path sum from top to bottom is 11 (i.e., 2 + 3 + 5 + 1 = 11).
* @Date: 2019/8/15 8:54
* @Version: 1.0
*/
public class MinimumTotal {
public int solution(List<List<Integer>> triangle) {
//这题我们反向遍历，从底往上进行遍历最小值
//可以得知第k行第i个数的最小路径是minpath[k][i]=min{minpath[k+1][i], minpath[k+1][i+1]} + triangle[k][i]
int[][] minpath = new int[triangle.size() + 1][triangle.size() + 1];
for (int row = triangle.size() - 1; row >= 0; --row) {
//列遍历数据
for (int column = 0; column < triangle.get(row).size(); ++column) {
minpath[row][column] = Math.min(minpath[row + 1][column], minpath[row + 1][column + 1]) + triangle.get(row).get(column);
}
}
return minpath[0][0];
}
}
package y2019.Algorithm.dynamicprogramming.medium;
import y2019.Algorithm.common.TreeNode;
import java.util.ArrayList;
import java.util.List;
/**
* @ProjectName: cutter-point
* @Package: y2019.Algorithm.dynamicprogramming.medium
* @ClassName: GenerateTrees
* @Author: xiaof
* @Description: 95. Unique Binary Search Trees II
*
* Given an integer n, generate all structurally unique BST's (binary search trees) that store values 1 ... n.
*
* Example:
*
* Input: 3
* Output:
* [
* [1,null,3,2],
* [3,2,null,1],
* [3,1,null,null,2],
* [2,1,3],
* [1,null,2,null,3]
* ]
* Explanation:
* The above output corresponds to the 5 unique BST's shown below:
*
* 1 3 3 2 1
* \ / / / \ \
* 3 2 1 1 3 2
* / / \ \
* 2 1 2 3
*
* @Date: 2019/8/15 8:54
* @Version: 1.0
*/
public class GenerateTrees {
public List<TreeNode> solution(int n) {
if (n == 0) return new ArrayList<>();
return backtruack(1, n);
}
//因为要求出所有可能性，那么需要递归出所有结果
public List<TreeNode> backtruack(int l, int r) {
//我们需要进行操作的范围是l->r
List<TreeNode> res = new ArrayList<>();
//如果l>r超过了，那么直接返回一个空的集合，因为这个区间不可能组成一颗树
if (l > r) {
res.add(null);
return res;
}
//如果l == r 那么就返回以当前节点作为根的树
if (l == r) {
res.add(new TreeNode(l));
return res;
}
//其余情况把l->r的所有节点进行遍历，依次作为根节点进行组合
List<TreeNode> leftlist, rightlist;
for (int i = l; i <= r; ++i) {
//依次吧第i个数作为根的时候值
leftlist = backtruack(l, i - 1);
rightlist = backtruack(i + 1, r);
//最后吧这两个值都组合起来
for (TreeNode lefttree : leftlist) {
for (TreeNode righttree : rightlist) {
TreeNode root = new TreeNode(i); //当前根节点
root.left = lefttree;
root.right = righttree;
res.add(root);
}
}
}
return res;
}
}
