算法群寒假第一周题解

最新推荐文章于 2024-07-19 19:25:43 发布

会划水才能到达彼岸

最新推荐文章于 2024-07-19 19:25:43 发布

阅读量256

点赞数 3

分类专栏： LeetCode 文章标签： leetcode 算法字符串 dfs 贪心算法

本文链接：https://blog.csdn.net/m0_46272108/article/details/112976247

版权

LeetCode 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

算法群寒假第一周题解

剑指 Offer 04 搜索二维矩阵Ⅱ（二分或者思维直接解）
剑指 Offer 07. 重建二叉树
剑指 Offer 12. 单词搜索（DFS+剪枝）
剑指 Offer 13. 机器人的运动范围
剑指 Offer 14-Ⅰ剪绳子（DP或者数学（也可以说是贪心））
剑指 Offer 14- II. 剪绳子 II
剑指 Offer 15.Pow(x, n)（快速幂）

剑指 Offer 04 搜索二维矩阵Ⅱ（二分或者思维直接解）

题目描述：

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：

每行的元素从左到右升序排列。
每列的元素从上到下升序排列。

示例 1：

输入：matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5
输出：true

示例 2：

输入：matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 20
输出：false

提示：

m == matrix.length
n == matrix[i].length
1 <= n, m <= 300
-10 $^9$ <= matix[i][j] <= 10 $^9$

每行的所有元素从左到右升序排列
每列的所有元素从上到下升序排列

-10 $^9$ <= target <= 10 $^9$

题解： 如下图所示
在这里插入图片描述

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        if (matrix.empty() || matrix[0].empty()) return false;
        //n代表行数，m代表列数
        int n = matrix.size(), m = matrix[0].size();
        //i代表行数，j代表列数
        int i = 0, j = m - 1;
        //从右上角开始，如果没出界的话
        while (i < n && j >= 0) {
            int cur = matrix[i][j];
            if (cur == target) return true;
            else if (cur > target) j--;//往左一列
            else i++;//往下一行
        }
        return false;
    }
};

剑指 Offer 07. 重建二叉树

根据一棵树的前序遍历与中序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

本题思想

给出前序遍历和中序遍历
前序遍历的顺序是：根节点 —— 左子树 —— 右子树
中序遍历的顺序是：左子树 —— 根节点 —— 右子树
这道题用递归思想（代码中会有详细的解释）：

通过前序遍历得到根节点（第一个数）
在中序遍历中找到根节点
此时中序遍历的根节点左边就是左子树，右边就是右子树
继续递归寻找剩下的。

举例 + 图文详解

那么此时：9为左子树，20，15，7为右子树
右子树还需要继续找该右子树的根节点，思路跟刚开始一样，所以是一直递归。

用哈希表记录中序遍历里面每个数的位置。时间复杂度为O(1)，如果用遍历的话就是O(n)；
剩下就是递归算左右子树。

C++代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    unordered_map<int, int> pos;//用哈希表存一下，可以做到时间复杂度为O(1)，如果直接遍历的话是O(n)的。记录中序遍历里面每个数的位置。
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        //把中序遍历里面每个数做一个映射，记录每个数的下标
        for (int i = 0; i < inorder.size(); ++i) {
            pos[inorder[i]] = i;
        }
        //递归建立整棵树，把前序遍历和中序遍历传下去，最开始的区间均是，0到最大值-1，
        return build(preorder, inorder, 0, preorder.size() - 1, 0, inorder.size() - 1);
    }
    //这个函数是返回当前子树的根节点，前序遍历的左右端点pl, pr， 中序遍历的左右端点il, ir
    TreeNode* build(vector<int>&preorder, vector<int>&inorder, int pl, int pr, int il, int ir) {
        if (pl > pr) return NULL;//如果pl>pr区间没有数，所以为空，返回空
        auto root = new TreeNode(preorder[pl]);//创建一个根节点， 根节点是前序遍历的第一个点
        //k是在中序遍历中根节点的位置。
        int k = pos[root->val];
        //递归算左子树
        root->left = build(preorder, inorder, pl + 1, pl + 1 + k - 1 - il, il, k - 1);
        //递归算右子树
        root->right = build(preorder, inorder, pl + 1 + k - 1 - il + 1, pr, k + 1, ir);
        return root;
    }
};

递归的时候，这些左右子树前、中序遍历区间解释：

左子树的中序遍历区间：[il, k - 1]
右子树的中序遍历区间：[k + 1, ir]

左子树的前序遍历区间：[pl+1，pl + 1 + k - 1 - il]
右子树的前序遍历区间：[pl + 1 + k - 1 - il + 1，pr]

剑指 Offer 12. 单词搜索（DFS+剪枝）

题目描述：

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。

[[“a”,“b”,“c”,“e”],
[“s”,“f”,“c”,“s”],
[“a”,“d”,“e”,“e”]]

但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。

示例 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

提示：

1 <= board.length <= 200
1 <= board[i].length <= 200

题解：
是一个简单搜索
步骤：
① 枚举所有起点
② 枚举每一步的方向（每一步有4个方向）

相当于一个搜索树
在这里插入图片描述
大致分析一下时间复杂度： $O(n^{2}3^k)$
看数据显示，word ≥ 1，所以不用判空
这样是一个小技巧：
开一个数组来定义一下4个方向：上右下左
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

C++代码

class Solution {
public:
    bool exist(vector<vector<char>>& board, string word) {
        for (int i = 0; i < board.size(); i++) {
            for (int j = 0; j < board[i].size(); j++) {
            	//如果能搜索到就返回true;
                if (dfs(board, word, 0, i, j)) return true;
            }
        }
        return false;
    }
    //上右下左
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    //cur表示当前搜到的位置，x, y表示起点
    bool dfs(vector<vector<char>>& board, string& word, int cur, int x, int y) {
    	//如果board[x][y]不等于word[cur]说明当前位置上的字符不相等，就返回false
        if (board[x][y] != word[cur]) return false;
        //如果搜完了最后一个字符，就返回true;
        if (cur == word.size() - 1) return true;
        //搜索之前，存一下当前位置是什么，方便后面恢复现场（回溯）
        char t = board[x][y];
        //因为路径不能重复，所以这里用掉一定要记得标记一下
        board[x][y] = '#';//用随便一个字符代替代替一下就可以了，因为题目给的都是大写字母，所以这里只要换成一个不存在的字符就可以了。

		//搜索4个方向
        for (int i = 0; i < 4; i++) {
            int a = x + dx[i], b = y + dy[i];
            //判断越界或者已经搜过的点，就pass
            if (a < 0 || a >= board.size() || b < 0 || b >= board[0].size() || board[a][b] == '#') continue;
            if (dfs(board, word, cur + 1, a, b)) return true;
        }
        //如果没有找到方案的话，恢复现场（回溯），以便下次搜索
        board[x][y] = t;
        return false;
    }
};

Java代码

class Solution {
    public boolean exist(char[][] board, String word) {
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[i].length; j++) {
            	//如果能搜索到就返回true;
                if (dfs(board, word, 0, i, j)) return true;
            }
        }
        return false;
    }
    //上右下左
    int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
    //cur表示当前搜到的位置，x, y表示起点
    public boolean dfs(char[][] board, String word, int cur, int x, int y) {
        if (board[x][y] != word.charAt(cur)) return false;
        if (cur == word.length() - 1) return true;
        //搜索之前，存一下当前位置是什么，方便后面恢复现场（回溯）
        char t = board[x][y];
        //因为路径不能重复，所以这里用掉一定要记得标记一下
        board[x][y] = '#';//用随便一个字符代替代替一下就可以了，因为题目给的都是大写字母，所以这里只要换成一个不存在的字符就可以了。

		//搜索4个方向
        for (int i = 0; i < 4; i++) {
            int a = x + dx[i], b = y + dy[i];
            //判断越界或者已经搜过的点，就pass
            if (a < 0 || a >= board.length || b < 0 || b >= board[0].length || board[a][b] == '#') continue;
            if (dfs(board, word, cur + 1, a, b)) return true;
        }
        //如果没有找到方案的话，恢复现场（回溯），以便下次搜索
        board[x][y] = t;
        return false;
    }
}

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

提示：

1 <= n,m <= 100
0 <= k <= 20

class Solution {
public:
    //辅助函数：每个数字的数位和
    int getASum(int x) {
        int s = 0;
        while (x) s += x % 10, x /= 10;
        return s;
    }
    
    //辅助函数：两个坐标的数位和
    int getSum(pair<int,int> p) {
        return getASum(p.first) + getASum(p.second);
    }
    int movingCount(int m, int n, int k)
    {
        int ans = 0;
        //判空
        if (!m || !n) return 0;
        //判断走过的格子
        vector<vector<bool>> st(m, vector<bool>(n, false));//vector<bool>会默认把所有的值初始化为false
        queue<pair<int, int>> q;
        q.push({0, 0});
        
        //定义一个向量
        int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
        while(q.size()) {
            auto t = q.front();//取出队首元素
            q.pop();//取完之后要删掉
            //如果这个点的数位和大于threshod或者这个点已经走过了
            //不能进入行坐标和列坐标的数位之和大于threshod的格子
            if (getSum(t) > k || st[t.first][t.second]) continue;
            ans++;
            //走过的路记得把该点标记上，改成true
            st[t.first][t.second] = true;
            
            //枚举4个方向
            for (int i = 0; i < 4; i++) {
                int x = t.first + dx[i], y = t.second + dy[i];
                //判断不能越界，因为前面已经判断过了，这个点已经符合条件的(能进入行坐标和列坐标的数位之和小于等于threshod的格子 且 未被遍历过的格子)
                //所以如果没越界就是可以加进去
                if (x >= 0 && x < m && y >= 0 && y < n) {
                    q.push({x, y});
                }
            }
        }
        return ans;
    }
};

剑指 Offer 14-Ⅰ剪绳子（DP或者数学（也可以说是贪心））

题目描述：

给你一根长度为 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

提示：

2 <= n <= 58

题解：用数学角度来解析（也可以说成是贪心）
结论： 尽可能分成3和2，且最多只能有2个2
证明如下：
假设 $n = a_1 + a_2 + a_3 + ... + a_k$ 为最优解
我们要证明的是：最优解里面的 $a_i$ 没有一个数能 ≥ 5
反证法：
假设存在 $a_i ≥ 5$ ，那么可以把 $a_i$ 分成 $3 + (a_i - 3)$
此时的乘积为： $3 × (a_i - 3)$
而我 假设： $3 × (a_i - 3) = 3a_i - 9 > a_i$ （成立）
因为：
$3a_i - 9 > a_i$ → $2a_i - 9 > 0$ → $a_i > 4.5$ 与 $a_i ≥ 5$ 相符合
所以假设成立。
既然： $3 × (a_i - 3) > a_i$ 成立
那么 $a_i ≥ 5$ 就不成立了，因为当 $a_i ≥ 5$ 时， $3 × (a_i - 3)$ 比 $a_i$ 效果更优。（证毕）

那么为什么分解的结果2不能多于2个呢？
因为：2 + 2 + 2 == 3 + 3
但是：2 × 2 × 2 < 3 × 3

结果显而易见。

如果有4的话，4分解成 2 + 2， 2 × 2 = 4；效果相同，所以可以看成用2个2代替4。

C++代码 + Java代码
本题两个代码一样

class Solution {
public:
    int cuttingRope(int n) {
        //因为 m(最终绳子的段数) > 1 所以必须得分成 1 * (n - 1)
        if (n <= 3) return 1 * (n - 1);
        int mul = 1;//表示乘积
        while (n >= 5) {
            n -= 3;
            mul *= 3;
        }
        return mul * n;
    }
};

剑指 Offer 14- II. 剪绳子 II

原理跟剪绳子Ⅰ一样，只是数据范围变大了，C++需要开long long存，Java开long

class Solution {
public:
    int cuttingRope(int n) {
        //因为m > 1 所以必须得分成 1 * (n - 1)
        if (n <= 3) return 1 * (n - 1);
        long long mul = 1;//表示乘积
        while (n >= 5) {
            n -= 3;
            mul *= 3;
            mul = mul % 1000000007;
        }
        return (int)(mul * n % 1000000007);
    }
};

剑指 Offer 15.Pow(x, n)（快速幂）

实现 pow(x, n) ，即计算 x 的 n 次幂函数。

示例 1:

输入: 2.00000, 10
输出: 1024.00000

示例 2:

输入: 2.10000, 3
输出: 9.26100

示例 3:

输入: 2.00000, -2
输出: 0.25000

解释: $2^{-2} = \frac{1}{2^2} = \frac{1}{4} = 0.25$

说明:

-100.0 < x < 100.0
n 是 32 位有符号整数，其数值范围是 [ $2^{31}, 2^{31} − 1$ ] 。

class Solution {
public:
    double qmi(double a, long long k) {
        double res = 1;
        while (k > 0) {
            if((k & 1) == 1) res *= a;
            k >>= 1;
            a *= a; 
        }
        return res;
    }
    double myPow(double x, int n) {
        long long num = n;
        double t = qmi(x, abs(num));
        if(n < 0) return 1 / t;
        return t;
    }
};

会划水才能到达彼岸

关注

3
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
算法群寒假第一周题解

算法群寒假第一周题解剑指Offer 04 搜索二维矩阵Ⅱ（二分或者思维直接解）剑指Offer 12 单词搜索（DFS+剪枝）C++代码Java代码剑指Offer 14-Ⅰ剪绳子（DP或者数学（也可以说是贪心））C++代码 + Java代码剑指Offer 04 搜索二维矩阵Ⅱ（二分或者思维直接解）题目描述：编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：每行的元素从左到右升序排列。每列的元素从上到下升序排列。示例 1：输入：m
复制链接

扫一扫