LeetCode Week01 递归

LeetCode Week01 递归

1.剑指 Offer 16. 数值的整数次方

实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。不得使用库函数，同时不需要考虑大数问题。

示例 1：

输入：x = 2.00000, n = 10
输出：1024.00000

示例 2：

输入：x = 2.10000, n = 3
输出：9.26100

示例 3：

输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25

提示：

• -100.0 < x < 100.0
• -231 <= n <= 231-1
• -104 <= xn <= 104

题解

class Solution {
    public double myPow(double x, int n) {
        if(n == 0)
            return 1;
        if(n == 1)
            return x;
        if(n < 0)
            return 1 / x * myPow(1 / x, -n -1);
        
        if(n % 2 == 0){
            return myPow(x * x, n / 2);
        }
        else{
            return x * myPow(x * x, n / 2);
        }
    }
}

62. 不同路径

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
问总共有多少条不同的路径？

示例 1：

输入：m = 3, n = 7
输出：28

示例 2：

输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。

1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

示例 3：

输入：m = 7, n = 3
输出：28

示例 4：

输入：m = 3, n = 3
输出：6

提示：

• 1 <= m, n <= 100
• 题目数据保证答案小于等于 2 * 109

题解

class Solution {
    public int uniquePaths(int m, int n) {
        return uniquePathsHelper(0, 0, m, n, new HashMap<>());
    }

    public int uniquePathsHelper(int i, int j, int m,
        int n, Map<String, Integer> map){
        //判断是否到达边界
        if(i > m-1 || j > n-1){
            return 0;
        }
        if(i == m-1 && j == n-1){
            return 1;
        }
        //判段是否存在于 map 中
        String key = i + "*" + j;
        if(map.containsKey(key)){
            return map.get(key);
        }
        //向右走有多少条路径
        int rightPath = uniquePathsHelper(i+1, j, m, n, map);

        //向下走有多少条路径
        int downPath = uniquePathsHelper(i, j+1, m, n, map);

        //总路径
        int totalPath = rightPath + downPath;

        //添加到 map
        map.put(key,totalPath);
        return totalPath;

    }
}

104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：

给定二叉树 [3,9,20,null,null,15,7]，

返回它的最大深度 3 。

题解

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        int leftSubtree = maxDepth(root.left);
        int rightSubtree = maxDepth(root.right);
        return Math.max(leftSubtree,rightSubtree)+1;

    }
}