剑指offer刷题笔记--Num41-50

已于 2023-07-15 20:06:15 修改
阅读量375 收藏
点赞数
分类专栏： 数据结构&LeetCode 文章标签： leetcode
于 2023-07-10 01:45:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43863869/article/details/131630355
版权

目录

1--数据流中的中位数（41）

2--连续子数组的最大和（42）

3--1~n中整数中 1 出现的次数（43）

4--数字序列中某一位的数字（44）

5--把数组排成最小的数（45）

6--把数字翻译成字符串（46）

7--礼物的最大价值（47）

8--最长不含重复字符的子字符串（48）

9--丑数（49）

10--第一个只出现一次的字符（50）

1--数据流中的中位数（41）

 主要思路：

      维护两个优先队列，Q1大数优先，存储比中位数小的数；Q2小数优先，存储比中位数大的数；

       当存储的数为偶数时，Q1.size() == Q2.size(), 中位数为：(Q1.top() + Q2.top()) / 2.0

       当存储的数为奇数时，Q2.size() = Q1.size() + 1, 中位数为 Q2 的队头元素

       因此插入元素，要确保Q2.size() >= Q1.size();

       同时插入新元素时，要先插入到另一个队列中，确保有序，取队头元素再插入到目的元素中；

#include <iostream>
#include <queue>   
#include <algorithm>

class MedianFinder {
public:
    MedianFinder() {}
    
    void addNum(int num) {
        // Q1大数优先，存储比中位数小的数
        // Q2小数优先，存储比中位数大的数
        // 当存储的数为偶数时，Q1.size() == Q2.size(), 中位数为：(Q1.top() + Q2.top()) / 2.0
        // 当存储的数为奇数时，Q2.size() = Q1.size() + 1, 中位数为 Q2 的队头元素
        // 因此插入元素，要确保Q2.size() >= Q1.size(); 
        // 同时插入新元素时，要先插入到另一个队列中，确保有序，取队头元素再插入到目的元素中
        if(Q1.size() == Q2.size()){
            Q1.push(num);
            int top = Q1.top();
            Q1.pop();
            Q2.push(top);
        }
        else{
            Q2.push(num);
            int top = Q2.top();
            Q2.pop();
            Q1.push(top);
        }
    }
    
    double findMedian() {
        if(Q1.size() == Q2.size()){
            return (Q1.top() + Q2.top()) / 2.0;
        }
        else{
            return Q2.top()*1.0;
        }
        
    }
private:
    std::priority_queue<int, std::vector<int>, std::less<int>> Q1; // 大数优先级高，队头
    std::priority_queue<int, std::vector<int>, std::greater<int>> Q2; // 小数优先级高，队头
};


int main(int argc, char *argv[]){
    MedianFinder S1;
    S1.addNum(1);
    S1.addNum(4);
    S1.addNum(2);
    S1.addNum(3);
    double Res = S1.findMedian();
    std::cout << Res << std::endl;
    return 0;
}

2--连续子数组的最大和（42）

主要思路：

        使用动态规划解决： 

#include <iostream>
#include <vector>

class Solution {
public:
    int maxSubArray(std::vector<int>& nums) {
        int len = nums.size();
        if(len == 0) return 0;

        std::vector<int> dp;
        dp.push_back(nums[0]);
        int max = nums[0];
        for(int i = 1; i < len; i++){
            if(dp[i - 1] >= 0){
                dp.push_back(dp[i-1] + nums[i]);
            }
            else{
                dp.push_back(nums[i]);
            }
            if (dp[i] > max) max = dp[i];
        }
        return max;
    }
};

int main(int argc, char *argv[]){
    Solution S1;
    std::vector<int> test = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
    int Res = S1.maxSubArray(test);
    std::cout << Res << std::endl;
    return 0;
}

3--1~n中整数中 1 出现的次数（43）

主要思路：视频讲解和题解

        规律题，当固定住其中 1 位时，计算其出现1的次数，分别统计个位、百位、千位等数字出现1的个数并求和相加即可；

#include <iostream>
#include <vector>

class Solution {
public:
    int countDigitOne(int n) {
        long long bit = 1;
        long long sum = 0;
        while(bit <= n){
            long long cur = n / bit % 10;
            long long low = n % bit;
            long long high = n / bit / 10;
            if(cur == 0){
                sum += high * bit;
            }
            else if(cur == 1){
                sum += high*bit + low + 1;
            }
            else{
                sum += (high+1)*bit;
            }
            bit = bit*10;
        }
        return (int)sum;
    }
};

int main(int argc, char *argv[]){
    Solution S1;
    int test = 12;
    int sum = S1.countDigitOne(test);
    std::cout << sum << std::endl;
    return 0;
}

4--数字序列中某一位的数字（44）

主要思路：视频讲解

        规律题，先判断 n 属于哪个范围的数（个位、百位、千位等），再计算 n 具体属于哪一个数，最后计算 n 属于某一个数的具体哪一位，返回即可；

#include <iostream>
#include <vector>
#include <cmath>

class Solution {
public:
    int findNthDigit(int n) {
        if(n == 0) return 0;
        long bit = 1; // 1 10 100
        int i = 1; // 1 2 3
        long count = 9; // 9 180 2700 // 范围内字符的个数 
        // 确定属于哪一个范围
        while(count < n){
            n = n - count;
            i = i + 1;
            bit = bit * 10;
            count = bit * i * 9;
        }
        // 确定属于哪一个数
        long num = bit + (n-1) / i;
        // 确定具体哪一位
        int index = (n - 1) % i + 1;
        int res = (int)(num / pow(10, i - index)) % 10;
        return res;
    }
};

int main(int argc, char *argv[]){
    Solution S1;
    int test = 19;
    int res = S1.findNthDigit(test);
    std::cout << res << std::endl;
    return 0;
}

5--把数组排成最小的数（45）

主要思路：

        拼接字符串 x+y > y+x, 则 x>y；

        拼接字符串 x+y < y+x, 则 x<y；

         使用快排对字符串数组进行排序，要确保由字符串数组组成的数最小，即strs[0]strs[1]strs[2]...最小，必须连续满足strs[0] < strs[1], strs[1] < strs[2];

#include <iostream>
#include <vector>
#include <string>

class Solution {
public:
    std::string minNumber(std::vector<int>& nums) {
        std::string Res;
        if (nums.size() == 0) return Res; 

        std::vector<std::string> strs;
        // 数字 -> string
        for(int item : nums){
            strs.push_back(std::to_string(item));
        }

        quickSort(strs, 0, nums.size()-1);
        for(std::string str : strs){
            Res.append(str);
        }
        return Res;
    }
    
    void quickSort(std::vector<std::string>& strs, int left, int right){
        if (left >= right) return;
        std::string pivot = strs[left];
        int i = left, j = right;
        while(i < j){
            while(i < j && strs[j] + pivot >= pivot + strs[j]) j--; // 拼接字符串 x+y > y+x, 则 x>y
            strs[i] = strs[j];
            while(i < j && strs[i] + pivot <= pivot + strs[i]) i++; // 拼接字符串 x+y < y+x, 则 x<y
            strs[j] = strs[i]; 
        }
        strs[i] = pivot;
        quickSort(strs, left, i-1);
        quickSort(strs, i+1, right);
    }
};
 
int main(int argc, char *argv[]){
    Solution S1;
    std::vector<int> test = {3, 30, 34, 5, 9};
    std::string Res = S1.minNumber(test);
    std::cout << Res << std::endl;
    return 0;
}

6--把数字翻译成字符串（46）

主要思路：

        基于动态规划定义状态和转移方程：dp[i] 代表以 x_i​ 为结尾的数字的翻译方案数量；

#include <iostream>
 
class Solution {
public:
    int translateNum(int num) {
        if(num < 10) return 1;
        int dp_1 = 1;
        int dp_2 = 1;
        int dp;
        while(num != 0){
            int tmp = ((num/10) % 10) * 10 + (num % 10);
            if(9 < tmp && tmp < 26){
                dp = dp_1 + dp_2;
            }
            else{
                dp = dp_1;
            }
            dp_2 = dp_1;
            dp_1 = dp;
            num = num / 10;
        }
        return dp;
    }
};

int main(int argc, char *argv[]){
    Solution S1;
    int num = 12258;
    int Res = S1.translateNum(num);
    std::cout << Res << std::endl;

    return 0;
}

7--礼物的最大价值（47）

用递归深搜会超时，改用动态规划：

       状态：dp[i][j] 表示走到当前位置(i, j)的累计礼物最大值；

       转移方程：dp[i][j] = grid[i][j] + max(dp[i-1][j], dp[i][j-1]);

#include <iostream>
#include <vector>

class Solution {
public:
    int maxValue(std::vector<std::vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                // 原地修改，不额外创建dp数组
                if(i == 0 && j == 0) continue; // 跳过起点
                else if(i == 0) grid[i][j] += grid[i][j-1];
                else if(j == 0) grid[i][j] += grid[i-1][j];
                else{
                    grid[i][j] += std::max(grid[i-1][j], grid[i][j-1]); 
                }
            }
        }
        return grid[m-1][n-1];
    }
};

int main(int argc, char *argv[]){
    std::vector<std::vector<int>> test = {{1, 3, 1}, {1, 5, 1}, {4, 2, 1}};
    
    Solution S1;
    int Res = S1.maxValue(test);
    std::cout << Res << std::endl;

    return 0;
}

8--最长不含重复字符的子字符串（48）

主要思路：

        基于双指针滑动窗口，当滑动窗口不出现重复元素时，右指针右移不断纳入新的元素；当滑动窗口出现重复元素时，左指针右移来移除元素；记录滑动窗口的最大长度即可；

        判断滑动窗口是否出现重复元素可以采用哈希表，key 为字符，当出现重复字符时，只需判断字符是否已出现在哈希表中；

#include <iostream>
#include <string>
#include <map>

class Solution {
public:
    int lengthOfLongestSubstring(std::string s) {
        int len = s.length();
        int j = 0;
        int max_len = 0;
        std::map<char, int> M;
        for(int i = 0; i < len; i++){     
            while(j < len && !M.count(s[j])){
                M.insert(std::pair<char, int>(s[j], 1)); // 右指针右移，把右指针指向的值纳入滑动窗口
                j++;
            }
            max_len = std::max(max_len, j - i);
            M.erase(s[i]); // 左指针右移前，需要把当前左指针指向的值移出滑动窗口
        }
        return max_len;
    }
};

int main(int argc, char *argv[]){
    std::string test = "abcabcbb";
    Solution S1;
    int res = S1.lengthOfLongestSubstring(test);
    std::cout << res << std::endl;
    return 0;
}

9--丑数（49）

主要思路：

#include <iostream>
#include <vector>

class Solution {
public:
    int nthUglyNumber(int n) {
        std::vector<int> dp(n + 1);
        dp[1] = 1;
        int p2 = 1, p3 = 1, p5 = 1; // 初始都从 1 开始
        for (int i = 2; i <= n; i++) {
            int num2 = dp[p2] * 2, num3 = dp[p3] * 3, num5 = dp[p5] * 5;
            dp[i] = std::min(std::min(num2, num3), num5); // 取较小的那个
            if (dp[i] == num2) p2++;
            if (dp[i] == num3) p3++;
            if (dp[i] == num5) p5++;
        }
        return dp[n];
    }
};

int main(int argc, char *argv[]){
    int n = 10;
    Solution S1;
    int res = S1.nthUglyNumber(n);
    std::cout << res << std::endl;
    return 0;
}

10--第一个只出现一次的字符（50）

主要思路：

        基于无序哈希表，key为字符，value 为该字符是否唯一，遍历字符串，当字符唯一时，value 设为 true，否则设为 false；

#include <iostream>
#include <string>
#include <unordered_map>

class Solution {
public:
    char firstUniqChar(std::string s) {
        int len = s.size();
        std::unordered_map<char, bool> M;
        for(int i = 0; i < len; i++){
            if(M.find(s[i]) == M.end()){ // 没找到
                M[s[i]] = true;
            }
            else{
               M[s[i]] = false; // 找到了，表明重复置为false 
            } 
        }

        for(int i = 0; i < len; i++){
            if(M[s[i]] == true){ // 找到第一个值为 true 的字符
                return s[i];
            }
        }
        return ' ';
    }
};

int main(int argc, char *argv[]){
    std::string test = "abaccdeff";
    Solution S1;
    char res = S1.firstUniqChar(test);
    std::cout << res << std::endl;
    return 0;
}

晓晓纳兰容若
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指offer刷题日记-链表
01-20
链表03-从尾到头打印链表（python） #采用insert方法 class Solution: def printlist(self,listNode): if not listNode: return [] result=[] while listNode: result.insert(0,listNode.val) ...
剑指offer刷题笔记.zip
05-13
这个压缩包“剑指offer刷题笔记.zip”显然包含了作者对这些面试题的解题思路、算法分析以及相关知识点的详细笔记。以下是对这些知识点的详细阐述： 1. **数据结构与算法** - **数组**：在《剑指Offer》中，数组是...
剑指offer刷题笔记--Num51-60
牵一只蜗牛去散步
07-19 975
考虑到题目给定的数组是递增有序的，因此可以考虑使用双指针法，分别指向数组的左右两端，并计算双指针指向值的和，当和小于 target 时，左指针右移，当和大于 target 时，右指针左移，当和等于 target 时，返回结果；出现三次的数字，在二进制位中其对应位肯定是 3 的倍数，因此只需统计 32 位整型中 1 出现的次数，并将其整除 3，就可以得到只出现1次的数字在该位的数值；相同的两个数进行异或，其结果为零（与顺序无关），因此在题目的数组中，遍历所有元素进行异或，得到的最终结果为。
剑指offer刷题笔记--Num61-68
牵一只蜗牛去散步
08-02 234
1--扑克牌中的顺子（61）1--扑克牌中的顺子（61）
剑指offer刷题笔记--Num31-40
牵一只蜗牛去散步
07-04 304
直观思路：用两个指针 i 和 j 指向压入和弹出的 vector，终止条件是：所有元素都压入了辅助栈（i > len），且辅助栈当前的栈顶元素与弹出的元素 popped[j] 不相等；模拟栈的压入顺序，依次压入 pushed 里的所有元素，用一个指针 j 指向需要弹出的元素，当符合弹出要求时就弹出对应的元素；二叉搜索树的定义：左子树的结点均小于根节点，右子树的结点均大于根结点；，不同的是为了打印每一层的结点，需要循环当前层的结点数次，每一次。，因此只需要循环队列的长度次，并记录对应的结点值即可；
剑指offer刷题笔记--Num11-20
牵一只蜗牛去散步
05-29 386
对于一段长度为 n 的绳子，将其最大乘积定义为 dp[n]，当裁剪出一段长度为 2 或 3 的绳子后，有两种情况：继续裁剪，则 dp[n] = 2 * dp[n - 2] 或 3 * dp[n - 3]；基于动态规划，则状态转移方程为：dp[n] = max(max(2 * dp[n-2], 2 * (n -2)), max(3*dp[n - 3], 3 * (n - 3)))；每段绳子的长度 k 必须是 2 或 3，因为当 k>= 4时，可以进一步裁剪，例如长度 5 可以拆分为 2*3 大于 5；
剑指offer:17-20
12-22
【知识点详解】 1. **树的子结构** (第17题) - 在这个问题中，我们需要判断一棵二叉树B是否是另一棵二叉树A的子结构。首先，我们要遍历树A，寻找与树B根节点值相同的节点R。如果找到，我们将以R为根的子树与树B...
leetcode答案-OfferCodingPractice:剑指OFFER刷题记录
06-30
剑指Offer leetcode刷题代码 为本人练习记录学习所作 com.hackhu 原本 包下为2014版 剑指Offer 刷题代码 ： 数据结构篇 数据结构系列包括：数组、字符串、链表、栈&队列、Hash、树、堆以及位运算。 数据结构篇的主要...
leetcode日记（51）不同路径Ⅱ
s478527548的博客
07-25 728
琢磨了一下代码，原理是将上面的二维数组优化成了一维，记录开始位置到达每一行末尾的路径数。没有障碍物就将数目设为上一行路径数加上这一行路径数。需要注意的是遍历方向，按照上面这种思路需要先遍历列再遍历行，如果先遍历行，如果上一行末尾有障碍物那么下一行就通过不了。根据上一题改的代码如下，添加了对障碍物的判定，如果有障碍物则将数组值设为0。然后看了答案，答案说可以使用滚动数组优化，就又去搜了一下滚动数组的使用方法。和上一道题（无障碍物的最短路径）很像，但事实上比上一题多了优化方法。
【力扣练习题】C语言答案
m0_65146517的博客
07-24 611
4、判断两数大小，p小于等于q返回p，p->next递归调用函数。2、遍历判断两个链表的单个值，用尾插法将小的值代入链表。1、如果q为NULL，p为NULL；3、如果遇到大于100000的数则返回true;5、否则返回q，q->next递归调用函数。1、将所有遍历过的值全部替换为100001。2、判断如果遇到NULL则返回false。3、如果p为NULL,返回 q;2、如果q为NULL，返回p；
LeetCode 2766.重新放置石块：哈希表
<font color="Pink">Tisfy的博客</font>
07-25 846
LeetCode 2766.重新放置石块：哈希表 给你一个下标从 0 开始的整数数组 nums ，表示一些石块的初始位置。再给你两个长度 相等 下标从 0 开始的整数数组 moveFrom 和 moveTo 。 在 moveFrom.length 次操作内，你可以改变石块的位置。在第 i 次操作中，你将位置在 moveFrom[i] 的所有石块移到位置 moveTo[i] 。 完成这些操作后，请你按升序返回所有 有 石块的位置。 注意： 如果一个位置至少有一个石块，我们称这个位置 有 石块。 一个位
【动态规划】力扣.213. 打家劫舍 II
sjsjs11的博客
07-25 460
同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。具体步骤和思路跟打家劫舍1的相同（主页有打家劫舍1的三种算法的详细思路），唯一区别是增加了首尾房子不能同时被偷的限制，所以可以分类讨论，然后返回出能偷到最大的金额即可。解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。输入：nums = [1,2,3,1]
力扣621.任务调度器
最新发布
Pisasama的博客
07-25 307
【代码】力扣621.任务调度器。
C++ | Leetcode C++题解之第284题窥视迭代器
Ddddddd_158的博客
07-25 426
C++ | Leetcode C++题解之第284题窥视迭代器
LeetCode 2844.生成特殊数字的最少操作（哈希表 + 贪心）
AuRoRamth的博客
07-25 864
在来观察，被25整除，思考思考，你会发现25 * （1 ~ n）中的数他的后两位尾数是{25，50，75，00}，只要能发现这个规律，那这道题也就结束了，当然想不到也没关系，慢慢积累。那接下来就是两个指针i和j去遍历就行了，把{25，50，75，00}存到哈希表里面，如果key = num[i] + num[j]在哈希表里面找到了，就去更新一次ans的值。删除 num[3]、num[4] 和 num[6] ，得到数字 "2900" ，可以被 25 整除。在一次操作中，您可以选择。，表示一个非负整数。
力扣69题 x的平方根 二分查找法（简单易懂）
xiaoye7288的博客
07-25 327
一种人一种写法 建议大家用自己的二分做来题 不要一味去模仿他人的二分 加油！
力扣1405.最长快乐字符串
Pisasama的博客
07-25 359
【代码】力扣1405.最长快乐字符串。
"剑指Offer刷题：二维数组中查找问题解析
剑指offer是一本非常经典的面试书籍，其中的编程题目常常被用于各种面试中。而在剑指offer中的第一道题目就是关于在二维数组中查找某个整数的问题。 题目要求我们从一个二维数组中查找是否存在某个整数。这个二维...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值