leetcode刷题记录22（2023-09-11）【两数相除(二分、翻倍的思想) | 有效的数独(遍历) | 通配符匹配(动态规划、贪心) | 加一(进位、模拟)】

已于 2024-01-17 06:17:49 修改
阅读量922 收藏 26
点赞数 22
分类专栏： 刷题笔记 文章标签： leetcode 动态规划 算法
于 2024-01-17 06:14:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/myf_666/article/details/132812064
版权

29. 两数相除

给你两个整数，被除数 dividend 和除数 divisor。将两数相除，要求 不使用 乘法、除法和取余运算。

整数除法应该向零截断，也就是截去（truncate）其小数部分。例如，8.345 将被截断为 8 ，-2.7335 将被截断至 -2 。

返回被除数 dividend 除以除数 divisor 得到的 商 。

注意：假设我们的环境只能存储 32 位 有符号整数，其数值范围是 [ − 2 31 , 2 31 − 1 ] [−2^{31}, 2^{31} − 1] [−231,231−1] 。本题中，如果商 严格大于 2 31 − 1 2^{31} − 1 231−1 ，则返回 2 31 − 1 2^{31} − 1 231−1 ；如果商 严格小于 − 2 31 -2^{31} −231 ，则返回 − 2 31 -2^{31} −231 。

示例 1:

输入: dividend = 10, divisor = 3
输出: 3
解释: 10/3 = 3.33333… ，向零截断后得到 3 。

示例 2:

输入: dividend = 7, divisor = -3
输出: -2
解释: 7/-3 = -2.33333… ，向零截断后得到 -2 。

提示：

− 2 31 < = d i v i d e n d , d i v i s o r < = 2 31 − 1 -2^{31} <= dividend, divisor <= 2^{31} - 1 −231<=dividend,divisor<=231−1
d i v i s o r ! = 0 divisor != 0 divisor!=0

除数的本质就是减法，但是，我们不能每次都减去 divisor，会超时，需要利用二分的思想，将 divisor 不断地增大。

#include <vector>
#include <climits>
#include <iostream>
using namespace std;

class Solution
{
public:
    int divide(int dividend, int divisor)
    {
        if (dividend == INT_MIN)
        {
            if (divisor == 1)
                return INT_MIN;
            if (divisor == -1)
                return INT_MAX;
        }
        if (divisor == INT_MIN)
        {
            return dividend == INT_MIN ? 1 : 0;
        }

        if (dividend == 0)
            return 0;

        bool rev = false;
        if (dividend > 0)
        {
            dividend = -dividend;
            rev = !rev;
        }
        if (divisor > 0)
        {
            divisor = -divisor;
            rev = !rev;
        }

        vector<int> candidates = {divisor};
        while (candidates.back() >= dividend - candidates.back())
        {
            // 主要通过翻倍的操作来降低复杂度
            candidates.push_back(candidates.back() + candidates.back());
        }
        int res = 0;
        for (int i = candidates.size() - 1; i >= 0; i--)
        {
            if (candidates[i] >= dividend)
            {
                res += (1 << i);
                dividend -= candidates[i];
            }
        }
        return rev ? -res : res;
    }
};

int main()
{
    Solution sol;
    int res = sol.divide(5, 2);
    cout<<res;
    return 0;
}

36. 有效的数独

请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

注意：

一个有效的数独（部分已被填充）不一定是可解的。
只需要根据以上规则，验证已经填入的数字是否有效即可。
空白格用 ‘.’ 表示。

示例 1：

在这里插入图片描述

输入：board =
[[“5”,“3”,“.”,“.”,“7”,“.”,“.”,“.”,“.”]
,[“6”,“.”,“.”,“1”,“9”,“5”,“.”,“.”,“.”]
,[“.”,“9”,“8”,“.”,“.”,“.”,“.”,“6”,“.”]
,[“8”,“.”,“.”,“.”,“6”,“.”,“.”,“.”,“3”]
,[“4”,“.”,“.”,“8”,“.”,“3”,“.”,“.”,“1”]
,[“7”,“.”,“.”,“.”,“2”,“.”,“.”,“.”,“6”]
,[“.”,“6”,“.”,“.”,“.”,“.”,“2”,“8”,“.”]
,[“.”,“.”,“.”,“4”,“1”,“9”,“.”,“.”,“5”]
,[“.”,“.”,“.”,“.”,“8”,“.”,“.”,“7”,“9”]]
输出：true

示例 2：

输入：board =
[[“8”,“3”,“.”,“.”,“7”,“.”,“.”,“.”,“.”]
,[“6”,“.”,“.”,“1”,“9”,“5”,“.”,“.”,“.”]
,[“.”,“9”,“8”,“.”,“.”,“.”,“.”,“6”,“.”]
,[“8”,“.”,“.”,“.”,“6”,“.”,“.”,“.”,“3”]
,[“4”,“.”,“.”,“8”,“.”,“3”,“.”,“.”,“1”]
,[“7”,“.”,“.”,“.”,“2”,“.”,“.”,“.”,“6”]
,[“.”,“6”,“.”,“.”,“.”,“.”,“2”,“8”,“.”]
,[“.”,“.”,“.”,“4”,“1”,“9”,“.”,“.”,“5”]
,[“.”,“.”,“.”,“.”,“8”,“.”,“.”,“7”,“9”]]
输出：false
解释：除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。 但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。

提示：

board.length == 9
board[i].length == 9
board[i][j] 是一位数字（1-9）或者 ‘.’

三次遍历，第一次是判断每一行，第二次是判断每一列，第三次是判断每一个box。

#include <vector>
#include <iostream>

using namespace std;

class Solution
{
public:
    bool isValidSudoku(vector<vector<char>> &board)
    {
        for (int i = 0; i < 9; i++)
        {
            vector<bool> vec(9);
            for (int j = 0; j < 9; j++)
            {
                if (board[i][j] == '.')
                    continue;
                else if (vec[board[i][j] - '0' - 1] == true)
                {
                    return false;
                }
                else
                {
                    vec[board[i][j] - '0' - 1] = true;
                }
            }
        }

        for (int j = 0; j < 9; j++)
        {
            vector<bool> vec(9);
            for (int i = 0; i < 9; i++)
            {
                if (board[i][j] == '.')
                    continue;
                else if (vec[board[i][j] - '0' - 1] == true)
                {
                    return false;
                }
                else
                {
                    vec[board[i][j] - '0' - 1] = true;
                }
            }
        }

        for (int i = 0; i < 3; i++)
        {
            for (int j = 0; j < 3; j++)
            {
                vector<bool> vec(9);
                for (int m = i * 3; m < i * 3 + 3; m++)
                {
                    for (int n = j * 3; n < j * 3 + 3; n++)
                    {
                        if (board[m][n] == '.')
                            continue;
                        else if (vec[board[m][n] - '0' - 1] == true)
                        {
                            return false;
                        }
                        else
                        {
                            vec[board[m][n] - '0' - 1] = true;
                        }
                    }
                }
            }
        }

        return true;
    }
};

int main()
{
    vector<vector<char>> board = {
        {'5', '3', '.', '.', '7', '.', '.', '.', '.'},
        {'6', '.', '.', '1', '9', '5', '.', '.', '.'},
        {'.', '9', '8', '.', '.', '.', '.', '6', '.'},
        {'8', '.', '.', '.', '6', '.', '.', '.', '3'},
        {'4', '.', '.', '8', '.', '3', '.', '.', '1'},
        {'7', '.', '.', '.', '2', '.', '.', '.', '6'},
        {'.', '6', '.', '.', '.', '.', '2', '8', '.'},
        {'.', '.', '.', '4', '1', '9', '.', '.', '5'},
        {'.', '.', '.', '.', '8', '.', '.', '7', '9'}};

    Solution sol;
    bool res = sol.isValidSudoku(board);

    cout << res;
}

44. 通配符匹配

给你一个输入字符串 (s) 和一个字符模式 § ，请你实现一个支持 ‘?’ 和 ‘*’ 匹配规则的通配符匹配：
‘?’ 可以匹配任何单个字符。
‘*’ 可以匹配任意字符序列（包括空字符序列）。
判定匹配成功的充要条件是：字符模式必须能够 完全匹配 输入字符串（而不是部分匹配）。

示例 1：

输入：s = “aa”, p = “a”
输出：false
解释：“a” 无法匹配 “aa” 整个字符串。

示例 2：

输入：s = “aa”, p = “*”
输出：true
解释：‘*’ 可以匹配任意字符串。

示例 3：

输入：s = “cb”, p = “?a”
输出：false
解释：‘?’ 可以匹配 ‘c’, 但第二个 ‘a’ 无法匹配 ‘b’。

提示：

0 <= s.length, p.length <= 2000
s 仅由小写英文字母组成
p 仅由小写英文字母、‘?’ 或 ‘*’ 组成

参考题解：https://leetcode.cn/problems/wildcard-matching/

动态规划：dp[i][j]表示，s中的前i个是否和p中的前j个匹配

class Solution
{
public:
    bool isMatch(string s, string p)
    {
        int m = s.size();
        int n = p.size();
        vector<vector<bool>> dp(m + 1, vector<bool>(n + 1));
		
		// p为空，只有党s也为空的情况才能满足
        dp[0][0] = true;
        // p为空的其它情况全为 false
        // s为空，只有p前几个全为'*'的字符才能满足
        for (int j = 1; j <= n; j++)
        {
            if (p[j - 1] == '*')
            {
                dp[0][j] = true;
            }
            else
            {
                break;
            }
        }

        for (int i = 1; i <= m; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                if (p[j - 1] == '*')
                {
                    dp[i][j] = dp[i][j - 1] | dp[i - 1][j];
                }
                else if (p[j - 1] == '?' || s[i - 1] == p[j - 1])
                {
                    dp[i][j] = dp[i - 1][j - 1];
                }
            }
        }

        return dp[m][n];
    }
};

贪心：相当于在s中找到所有’*'划分的p的子串

class Solution
{
    bool charMatch(char u, char v)
    {
        return u == v || v == '?';
    }

public:
    bool isMatch(string s, string p)
    {
        while (s.size() && p.size() && p.back() != '*')
        {
            if (charMatch(s.back(), p.back()))
            {
                s.pop_back();
                p.pop_back();
            }
            else
            {
                return false;
            }
        }
        if (p.empty())
        {
            return s.empty();
        }
        int sIndex = 0, pIndex = 0;
        // 两个字符串 匹配 开始的地方
        int sRecord = -1, pRecord = -1;
        // p 中的所有子串都要在 s 中出现
        while (sIndex < s.size() && pIndex < p.size())
        {
            if (p[pIndex] == '*')
            {
                pIndex++;
                sRecord = sIndex;
                pRecord = pIndex;
            }
            else if (charMatch(s[sIndex], p[pIndex]))
            {
                sIndex++;
                pIndex++;
            }
            // 如果出现不匹配，sRecord向后移，然后继续匹配
            else if (sRecord != -1 && sRecord + 1 < s.size())
            {
                sRecord++;
                sIndex = sRecord;
                pIndex = pRecord;
            }
            else
            {
                return false;
            }
        }
        for (int i = pIndex; i < p.size(); i++)
        {
            if (p[i] != '*')
            {
                return false;
            }
        }
        return true;
    }
};

66. 加一

给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1：

输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。

示例 2：

输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。

示例 3：

输入：digits = [0]
输出：[1]

提示：

1 <= digits.length <= 100
0 <= digits[i] <= 9

主要采用了模拟的思想，记录每一位 +1 后的进位

#include <vector>

using namespace std;

class Solution
{
public:
    vector<int> plusOne(vector<int> &digits)
    {
        int plus = 1;
        for (auto it = digits.rbegin(); it != digits.rend(); it++)
        {
            *it += plus;
            if (*it >= 10)
            {
                plus = 1;
                *it = *it % 10;
                if (it == digits.rend() - 1)
                {
                    digits.insert(digits.cbegin(), 0);
                    digits[0] += plus;
                    plus = 0;
                    break;
                }
            }
            else
            {
                break;
            }
        }
        return digits;
    }
};

答案的做法，更加简洁：

class Solution
{
public:
    vector<int> plusOne(vector<int> &digits)
    {
        for (int i = digits.size() - 1; i >= 0; i--)
        {
            digits[i]++;
            digits[i] = digits[i] % 10;
            if (digits[i] != 0)
                return digits;
        }
        digits = vector<int>(digits.size() + 1);
        // 999 + 1 必然是 1000，所以只需要考虑第一位
        digits[0] = 1;
        return digits;
    }
};
Cherries Man
关注
专栏目录
LeetCode刷题总结（二）4-6
weixin_45704555的博客
08-03 96
（1）LeetCode1：寻找两个正序数组的中位数 两个有序数组，要求这两个数组合并之后（也是排好序的）的中位数（如果总个数为偶数，则去中间两个数的平均值；为奇数则取中间的数）。 对这个问题的解决，最简单的做法就是把两个数组合并后排序，但这样的时间复杂度较高，所以不采用！ 我们可以在不对其进行排序的状态下找到中位数，首先将问题转化为这两个数组合并后从小到大排，求第k个数等于多少？ 到时候要求中位数时，只需令 K = (m+n)/2即可，m，n分别为两个数组的元素个数。 求第k个数的基本思路是： ...
Leetcode刷题记录22-37，python语言
yuyu12prince的博客
03-21 189
22-40
leetcode刷题记录1-50-基于python
码python的Vinsmoke
05-06 559
1.两数之和-Easy class Solution(): def twoSum(self, nums, target): # nums: list->int # target: 两数之和 # 遍历数组每一个元素 for i in nums: # 计算另一个数 j = target - i # 记录下开始索引 start_index = nums.index(i) # 将i后面的数存放在一个临时list,防止出现6 = 3+3 temp = nu
Leetcode刷题-(26~35)-Java
最新发布
nuist_NJUPT的博客
04-20 1025
算法是码农的基本功，也是各个大厂必考察的重点，让我们一起坚持写算法题吧。遇事不决，可问春风，春风不语，即是本心。我们在我们能力范围内，做好我们该做的事，然后相信一切都事最好的安排就可以啦，慢慢来，会很快，向前走，别回头。
LeetCode刷题记录
qq_45808952的博客
04-12 726
首先从后向前查找第一个顺序对 (i,i+1)(i,i+1)(i,i+1)，满足 a[i]
求中位数中回文数之和C语言,leetcode刷题总结1-50
weixin_28020031的博客
05-21 535
1. 两数之和描述：nums = [2, 7, 11, 15], target = 9 返回[0, 1]思路：双指针，一个从前，一个从后。(数组必须排序)2. 两数相加描述：输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)输出：7 -> 0 -> 8原因：342 + 465 = 807思路：通过最低位开始和进位(init:0)相加。时...
LeetCode刷题小技巧（Python版）
tereaslle的博客
12-14 2110
写给刚开始刷LeetCode的小白，其中包含了我一开始见到没看懂的代码与力扣平台的代码规范。
Leetcode刷题系列（一）——巧解数学问题
Ratib的博客
03-23 636
在Leetcode上刷题时，会遇到一些用数据结构和常用算法无法解决的数学问题，巧妙地运用一些数学知识可以很快地解决这些问题。下面我们将介绍一些常用的解决数学问题的技巧，包括但不限于：最大公约数与最小公倍数、筛法和打表、同余定理、容斥原理、中位数定理等。
LeetCode刷题笔记（Java）---第221-240题
gongsenlin341的博客
07-18 583
文章目录221. 最大正方形222. 完全二叉树的节点个数223. 矩形面积224. 基本计算器225. 用队列实现栈226. 翻转二叉树227. 基本计算器 II228. 汇总区间229. 求众数 II230. 二叉搜索树中第K小的元素231. 2的幂232. 用栈实现队列233. 数字 1 的个数234. 回文链表235. 二叉搜索树的最近公共祖先236. 二叉树的最近公共祖先 221. 最大正方形 在一个由 0 和 1 组成的二维矩阵内，找到只包含 1 的最大正方形，并返回其面积。 解答
LeetCode刷题汇总
热门推荐
weixin_44171872的博客
09-19 2万+
剑指offer 剑指 Offer 03 数组中重复的数字 剑指 Offer 04 二维数组中的查找 剑指 Offer 05 替换空格 剑指 Offer 06 从尾到头打印链表 剑指 Offer 07 重建二叉树 剑指 Offer 09 用两个栈实现队列 剑指 Offer 10- I 斐波那契数列 剑指 Offer 10- II 青蛙跳台阶问题 剑指 Offer 11 旋转数组的最小数字 剑指 Offer 12 矩阵中的路径 剑指 Offer 13 机器人的运动范围 剑指 Offer 14- I 剪绳子 剑指
LeetCode刷题总结（九）29 - 31 -- 二进制倍增，位运算，滑动窗口
weixin_45704555的博客
10-16 273
（一）LeetCode29：两数相除 暴力做法是循环 x -= y，x为被除数，y为除数，减到 x 小于 y 为止，每减一次计数变量 ++，最后输出计数变量。 然而以上这种做法显然是会超时的！！！ 高级解法是二进制移位倍增，其实这也是计算机实现乘除法的本质。 ...
【原创】LeetCode刷题-Python版
qq_39492842的博客
05-21 1847
LeetCode刷题-Python版 分类专栏： LeetCode-python 版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://editor.csdn.net/md?articleId=106267675 文章目录LeetCode刷题-Python版 ...
Leetcode-How-What 力扣Leetcode刷题指南
edwardwjz的博客
03-05 2715
Leetcode-How-What 力扣Leetcode刷题指南 About the way how to use Leetcode wisely for preparing the interview and the solutions to some Leetcode problems’. 怎样为准备面试机智聪明的刷题（高效刷题）以及一些题目的题解。 同 github 链接： https:/...
Leetcode刷题笔记之 数学
weixin_43540151的博客
07-28 263
7. 整数反转 难度简单2038 给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。 方法一： 先尝试计算下一步，如果得到的值/10和上一步的值不等，说明已经越界，返回0 public c.
利用剪枝降低bfs算法的时空复杂度（一道OJ题目）
你的问题在于，读书太少而想得太多。
02-02 5716
终于学会了如何通过剪枝降低bfs算法的时空复杂度（附示例OJ题目及源码）
经典动态规划OJ题目：接雨水or接青豆(多种方法，附详详细思维过程、解析及源码)
你的问题在于，读书太少而想得太多。
01-31 2136
彻底搞懂接雨水or接青豆or动态规划……
OJ常用函数/机试常用STL模板
你的问题在于，读书太少而想得太多。
01-20 1357
OJ常用函数/机试常用STL模板
leetcode刷题记录09（2023-05-19）【乘积最大子数组(动态规划，最大最小值转换) | 最小栈(用vector进行模拟) | 相交链表(hash) | 打家劫舍(一维动态规划)】
你的问题在于，读书太少而想得太多。
12-31 1246
【乘积最大子数组(动态规划，最大最小值转换) | 最小栈(用vector进行模拟) | 相交链表(hash) | 打家劫舍(一维动态规划)】
Java版LeetCode刷题笔记：51-100题解析
“LeetCode 刷题笔记 with Java 51-100（暗黑版）.pdf 是一本关于使用Java解决LeetCode算法题目的详细笔记，由沉默王二创作。该笔记涵盖51至100号题目，包含题解预览链接、LeetCode官方题目链接以及GitHub项目地址。...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Cherries Man

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值