常见的一道算法题：
一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
解法我想很多人一想应该就知道，可以递归的思路，动态规划的思路等，代码如下，重点不在这里，不在详述：
//递归
public static int frogJumps_1(int n) {
if(n==0) return 1;
if(n==1) return 1;
return frogJumps_1(n-1) + frogJumps_1(n-2);
}
//带备忘录的递归
public static int frogJumps_2(int n) {
int[] memo = new int[n+1];
return helper(n, memo);
}
private static int helper(int n, int[] memo) {
if(n==0) return 1;
if(n==1) return 1;
if(memo[n]!=0)
return memo[n];
memo[n] = frogJumps_2(n-1) + frogJumps_2(n-2);
return memo[n];
}
//dp,貌似也算不上dp问题，没有求最值
public static int frogJumps_3(int n) {
int[] dp = new int[n+1];
dp[0] = 1;
dp[1] = 1;
for(int i=2; i<dp.length; i++) {
dp[i] = dp[i-1] + dp[i-2];
}
return dp[n];
}
但是前几天遇到一个问题，要打印出青蛙跳台所有的可能路径，例如：
输入 ：n = 3
输出 ：
111
12
21
网上没有找到相关解法，目前想了个算法打印出所有路径，不一定是最好的，有更好的欢迎指正。思路如下：
若求f(n)，画出递归树的时候，这就是一个二叉树，而二叉树的从下到上的所有路径就是青蛙跳台的所有可能路径，并且如果左子树是f(n-1)，右子树是f(n-2)，那么从左子树走到顶点就是走一步，从右子树走到顶点就是走两步。
所以算法步骤如下，通过dp数组构造一个二叉树，然后打印二叉树的所有路径即可输出青蛙跳台的所有可能路径。
代码如下：
public static int frogJumps_4(int n) {
Node[] dp = new Node[n+1];
dp[0] = new Node(1, null, null);
dp[1] = new Node(1, dp[0], null);
for(int i=2; i<dp.length; i++) {
dp[i] = new Node(dp[i-1].val + dp[i-2].val, dp[i-1], dp[i-2]);
}
//打印出二叉数所有路径
printTree(dp[n], n);
return dp[n].val;
}
private static void printTree(Node root, int n) {
int[] path = new int[n+1];
printPath(root, path, 0, 0);
}
private static void printPath(Node node, int[] path, int n, int pos) {
if(node==null) return;
path[n++] = pos;
if(node.left==null && node.right==null) {
for (int i = 1; i < n; i++)
System.out.print(path[i]);
System.out.println();
} else {
printPath(node.left, path, n, 1);
printPath(node.right, path, n, 2);
}
}
private static class Node {
int val;
Node left;
Node right;
public Node(int val, Node left, Node right) {
this.val = val;
this.left = left;
this.right = right;
}
}
还有个青蛙跳台变形的题，说青蛙不是只可以跳一步和两步，可以跳任意步到达终点，如果问有多少种方式，其实推导出来就是f(n)=2f(n-1)，照着上面代码写就好了，很简单。
如果也让打印出所有路径，例如：
输入 ：n = 3
输出 ：
111
12
21
3
按目前思路可能就处理更复杂了，要用到多叉树，然后打印出多叉树的所有路径，代码如下：
public static int frogJumps_5(int n) {
Node1[] dp = new Node1[n+1];
dp[0] = new Node1(1, 0);
dp[1] = new Node1(1, 1);
dp[1].add(dp[0], 0);
for(int i=2; i<dp.length; i++) {
dp[i] = new Node1( 2 * dp[i-1].val, i);
for(int j=i-1; j>=0; j--) {
dp[i].add(dp[j], i-1-j);
}
}
//打印出二叉数所有路径
printMultiTree(dp[n], n);
return dp[n].val;
}
private static void printMultiTree(Node1 root, int n) {
int[] path = new int[n+1];
printMultiPath(root, path, 0, 0);
}
private static void printMultiPath(Node1 node, int[] path, int n, int pos) {
if(node==null) return;
path[n++] = pos;
if(node.nodes.length==0) {
for (int i = 1; i < n; i++)
System.out.print(path[i]);
System.out.println();
} else {
for(int i=0; i<node.nodes.length; i++) {
printMultiPath(node.nodes[i], path, n, i+1);
}
}
}
private static class Node1 {
int val;
Node1[] nodes;
public Node1(int val, int n) {
this.val = val;
nodes = new Node1[n];
}
public void add(Node1 node, int index) {
nodes[index] = node;
}
}
全部代码如下：
public class MaximumFrogJumps {
public static void maximumFrogJumps(int n) {
//暴力解法
System.out.println(frogJumps_1(n));
//添加备忘录
System.out.println(frogJumps_2(n));
//dp
System.out.println(frogJumps_3(n));
//打印路路径
System.out.println(frogJumps_4(n));
//打印路路径
System.out.println(frogJumps_5(n));
}
public static int frogJumps_1(int n) {
if(n==0) return 1;
if(n==1) return 1;
return frogJumps_1(n-1) + frogJumps_1(n-2);
}
public static int frogJumps_2(int n) {
int[] memo = new int[n+1];
return helper(n, memo);
}
private static int helper(int n, int[] memo) {
if(n==0) return 1;
if(n==1) return 1;
if(memo[n]!=0)
return memo[n];
memo[n] = frogJumps_2(n-1) + frogJumps_2(n-2);
return memo[n];
}
public static int frogJumps_3(int n) {
int[] dp = new int[n+1];
dp[0] = 1;
dp[1] = 1;
for(int i=2; i<dp.length; i++) {
dp[i] = dp[i-1] + dp[i-2];
}
return dp[n];
}
public static int frogJumps_4(int n) {
Node[] dp = new Node[n+1];
dp[0] = new Node(1, null, null);
dp[1] = new Node(1, dp[0], null);
for(int i=2; i<dp.length; i++) {
dp[i] = new Node(dp[i-1].val + dp[i-2].val, dp[i-1], dp[i-2]);
}
//打印出二叉数所有路径
printTree(dp[n], n);
return dp[n].val;
}
private static void printTree(Node root, int n) {
int[] path = new int[n+1];
printPath(root, path, 0, 0);
}
private static void printPath(Node node, int[] path, int n, int pos) {
if(node==null) return;
path[n++] = pos;
if(node.left==null && node.right==null) {
for (int i = 1; i < n; i++)
System.out.print(path[i]);
System.out.println();
} else {
printPath(node.left, path, n, 1);
printPath(node.right, path, n, 2);
}
}
private static class Node {
int val;
Node left;
Node right;
public Node(int val, Node left, Node right) {
this.val = val;
this.left = left;
this.right = right;
}
}
public static int frogJumps_5(int n) {
Node1[] dp = new Node1[n+1];
dp[0] = new Node1(1, 0);
dp[1] = new Node1(1, 1);
dp[1].add(dp[0], 0);
for(int i=2; i<dp.length; i++) {
dp[i] = new Node1( 2 * dp[i-1].val, i);
for(int j=i-1; j>=0; j--) {
dp[i].add(dp[j], i-1-j);
}
}
//打印出二叉数所有路径
printMultiTree(dp[n], n);
return dp[n].val;
}
private static void printMultiTree(Node1 root, int n) {
int[] path = new int[n+1];
printMultiPath(root, path, 0, 0);
}
private static void printMultiPath(Node1 node, int[] path, int n, int pos) {
if(node==null) return;
path[n++] = pos;
if(node.nodes.length==0) {
for (int i = 1; i < n; i++)
System.out.print(path[i]);
System.out.println();
} else {
for(int i=0; i<node.nodes.length; i++) {
printMultiPath(node.nodes[i], path, n, i+1);
}
}
}
private static class Node1 {
int val;
Node1[] nodes;
public Node1(int val, int n) {
this.val = val;
nodes = new Node1[n];
}
public void add(Node1 node, int index) {
nodes[index] = node;
}
}
}
输入3运行结果如下：
3
3
3
111
12
21
3
111
12
21
3
4
============================================
2020.05.14 更新
今天学习了回溯算法，发现这个题回溯算法解也太简单了，唉…
//跳一步或者两步
private static void frogJumps_6(int n) {
LinkedList<Integer> res = new LinkedList<Integer>();
int[] nums = new int[]{1, 2};
backtrack(nums, n, res);
}
//跳任意步
private static void frogJumps_7(int n) {
LinkedList<Integer> res = new LinkedList<Integer>();
int[] nums = new int[n];
for(int i=0; i<nums.length; i++) {
nums[i] = i+1;
}
backtrack(nums, n, res);
}
private static void backtrack(int[] nums, int n, LinkedList<Integer> res) {
if(n==0) {
System.out.println(res);
return;
}
if(n<0)
return;
for(int i=0; i<nums.length; i++) {
res.add(nums[i]);
backtrack(nums, n-nums[i], res);
res.removeLast();
}
}
243
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
