力扣刷题小记3

最新推荐文章于 2024-10-31 16:16:13 发布

九天漩女

最新推荐文章于 2024-10-31 16:16:13 发布

阅读量324

点赞数

分类专栏：力扣刷题小记文章标签： leetcode 深度优先算法

本文链接：https://blog.csdn.net/qq_35754976/article/details/124551040

版权

力扣刷题小记专栏收录该内容

9 篇文章 0 订阅

订阅专栏

本文是博主在力扣刷题的小结，涵盖了剑指Offer中的几道经典题目，包括矩阵中的路径、机器人的运动范围、剪绳子、二进制中1的个数和数值的整数次方等问题。通过深度优先搜索（DFS）和回溯法，解析解题思路和方法，旨在帮助读者理解算法的应用。

摘要由CSDN通过智能技术生成

博主个人博客网站：文客
这个系列主要记录在力扣刷题的总结和问题
如果你想每天和我一起刷题，可以关注一下我的个人博客网站：文客，我会每天在这里更新技术文章和面试题，也会及时收到大家的评论与留言，欢迎各位大佬来交流！

今天刷了几道剑指Offer的题，虽然说不难但是都蛮有代表性的，所以拿出来总结记录一下吧！

剑指 Offer 12. 矩阵中的路径

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

例如，在下面的 3×4 的矩阵中包含单词 “ABCCED”（单词中的字母已标出）。

示例 1：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true

示例 2：

输入：board = [["a","b"],["c","d"]], word = "abcd"
输出：false

思路：

这题是很标准的dfs+回溯。根据题目要求，以矩阵中的每个点为起点去搜索，直至找出包含单词的路径，如果找不到则返回false。

题解：

class Solution {
    public boolean exist(char[][] board, String word) {
        boolean[][] visited = new boolean[board.length][board[0].length];
        for(int i = 0; i < board.length; i++){
            for(int j = 0; j < board[i].length; j++){
                if(dfs(board,word,visited,0,i,j) == true){
                    return true;
                }
            }
        }
        return false;
    }

    public boolean dfs(char[][] board, String word, boolean[][] visited
            , int start, int i, int j){
        
        if(i < 0 || i >= board.length || j < 0 || j >= board[0].length 
            || visited[i][j] == true || board[i][j] != word.charAt(start)){
            return false;
        }
        if(start == word.length() - 1){
            return true;
        }
        visited[i][j] = true;
        boolean ans = dfs(board,word,visited,start+1,i-1,j)||
                      dfs(board,word,visited,start+1,i+1,j)||
                      dfs(board,word,visited,start+1,i,j-1)||
                      dfs(board,word,visited,start+1,i,j+1);
        visited[i][j] = false;
        return ans;
    }
}

剑指 Offer 13. 机器人的运动范围

地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？

示例 1：

输入：m = 2, n = 3, k = 1
输出：3

示例 2：

输入：m = 3, n = 1, k = 0
输出：1

思路：

本题和上题类似，依旧是使用深度优先搜索，不过本题只需要从（0，0）开始搜索即可，并使用visited数组进行剪枝。

题解：

class Solution {
    public int movingCount(int m, int n, int k) {
        boolean[][] visited = new boolean[m][n];
        return dfs(m,n,0,0,k,visited);
    }

    public int dfs(int m, int n, int i, int j, int k, boolean[][] visited){
        if(i < 0 || i >= m || j < 0 || j >= n ||
           getDigitSum(i) + getDigitSum(j) > k || visited[i][j] == true){
            return 0;
        }
        visited[i][j] = true;
        return dfs(m,n,i-1,j,k,visited) + dfs(m,n,i+1,j,k,visited)
               +dfs(m,n,i,j-1,k,visited) + dfs(m,n,i,j+1,k,visited) + 1;
    }

    public int getDigitSum(int num){
        int sum = 0;
        while(num > 0){
            sum += num % 10;
            num /= 10;
        }
        return sum;
    }
}

剑指 Offer 14- I. 剪绳子

给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]...k[m-1] 。请问 k[0]*k[1]*...*k[m-1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

示例 1：

输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1

示例 2:

输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36

思路：

动态规划，首先n如果小于2是无意义的，所以n从2开始。

当n=2时，可以将绳子分成2段长度为1的绳子，所以乘积为1，顺着下去[3 -> 2]，[4 -> 4]，[5 -> 6]，[6 -> 8]，…，[10 -> 36]

根据规律得出递推公式即可

题解：

class Solution {
    public int cuttingRope(int n) {
        int[] dp = new int[n + 1];
        dp[2] = 1;
        for(int i = 3; i <= n; i++){
            for(int j = 1; j < i; j++){
                dp[i] = Math.max(dp[i],Math.max(j * (i - j),dp[i - j]*j));
            }
        }
        return dp[n];
    }
}

剑指 Offer 15. 二进制中1的个数

编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量).）。

提示：

请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 3 中，输入表示有符号整数 -3。

示例 1：

输入：n = 11 (控制台输入 00000000000000000000000000001011)
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。

示例 2：

输入：n = 128 (控制台输入 00000000000000000000000010000000)
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。

示例 3：

输入：n = 4294967293 (控制台输入 11111111111111111111111111111101，部分语言中 n = -3）
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 '1'。

思路：

这道题是很简单的位运算，可以有三种方式：

使用Integer提供了bitCount方法
循环右移，通过奇偶来判断最低为是否为1
使用num & (num - 1)，这可以使最低为的1变为0

题解：

public class Solution {
    // you need to treat n as an unsigned value
    public int hammingWeight(int n) {
        int count = 0;
        while(n != 0){
            n &= n - 1;
            count++;
        }
        return count;
    }
}

剑指 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

思路：

快速幂，记下来就好了，说实话的写的时候也忘记了。

题解：

class Solution {
    public double myPow(double x, int n) {
        long N = n;
        return (N > 0) ? quickMul(x,N) : 1/quickMul(x,-N);
    }

    public double quickMul(double x, long N){
        if(N == 0){
            return 1;
        }
        double y = quickMul(x,N/2);
        return (N % 2 == 0) ? y * y : y * y * x;
    }
}