算法刷题打卡（九）

50 Pow(x,n)

50. Pow(x, n) - 力扣（LeetCode） (leetcode-cn.com)

实现 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

快速幂，考虑 系统最小值 ，1

// Integer.MIN_VALUE 0.9999999999 
	public double myPow(double x, int n) {
        if (n == 0) {
            return 1D;
        }
        // 当 n 等于系统最小值的时候 先+1 计算 最后在*一个
        int pow = Math.abs(n == Integer.MIN_VALUE ? n + 1 : n);
        //快速幂
        double count = x;
        double res = 1D;
        while (pow != 0) {
            if ((pow & 1) != 0) {
                res *= count;
            }
            pow >>= 1;
            count = count * count;
        }
        if (n == Integer.MIN_VALUE) {
            res *= x;
        }
        return n < 0 ? (1D / res) : res;
    }

53 最大子序和

53. 最大子序和 - 力扣（LeetCode） (leetcode-cn.com)

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
示例 2：

输入：nums = [1]
输出：1
示例 3：

输入：nums = [0]
输出：0
示例 4：

输入：nums = [-1]
输出：-1
示例 5：

输入：nums = [-100000]
输出：-100000

动态规划

    public int maxSubArray(int[] nums) {
        int N = nums.length;
        int max = nums[0];
        int t = 0;
        //以 i 位置的最大 ，包含i-1  和不包含i-1位置，
        //当前位置 需不需要 前边的累加和
        for (int i = 0; i < N; i++) {
            t = Math.max(nums[i],t+nums[i]);
            max = Math.max(max,t);
        }
        return max;      
    }

54 螺旋矩阵

54. 螺旋矩阵 - 力扣（LeetCode） (leetcode-cn.com)

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

/* 跟 48 旋转图像 比较像，但是停止点不同不是走完一圈
	在上图4*3种	从 00 -> 03 -> 23 - > 20 -> 10->...
    绕一圈停下来的是 i+1行
*/
    public static List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> res = new ArrayList<Integer>();
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return res;
        }
        int row = matrix.length, col = matrix[0].length;//行列
        // 左侧 右侧 上 下
        int left = 0, right = col - 1, top = 0, down = row - 1;
        while (left <= right && top <= down) {//左 -> 右  上-> 下   右-> 左 下 -> 上-1 ..
            for (int column = left; column <= right; column++) {
                res.add(matrix[top][column]);
            }
            for (int rows = top + 1; rows <= down; rows++) {
                res.add(matrix[rows][right]);
            }
            if (left < right && top < down) {
                for (int column = right - 1; column > left; column--) {
                    res.add(matrix[down][column]);
                }
                for (int rows = down; rows > top; rows--) {
                    res.add(matrix[rows][left]);
                }
            }
            left++;
            right--;
            top++;
            down--;
        }
        return res;
    }

55 跳跃游戏

55. 跳跃游戏 - 力扣（LeetCode） (leetcode-cn.com)

给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标。

示例 1：

输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
示例 2：

输入：nums = [3,2,1,0,4]
输出：false

 /*    max  目前位置 向右跳的 最右的位置
        如果 i > max 的 return false
        i == max 的时候 是能到的
        如果发生 i >max   就到不了 最后
        i + 往右的距离  更新max
     */
    public boolean canJump(int[] nums) {
        if (nums == null || nums.length < 2) {
            return true;
        }
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (i > max) {
                return false;
            } max = Math.max(nums[i] + i, max);

            if (max >= nums.length - 1) {
                return true;
            }
        }
        return true;
    }