剑指Offer---2021/7/25

最新推荐文章于 2024-08-11 21:36:15 发布
最新推荐文章于 2024-08-11 21:36:15 发布
阅读量1w 收藏 3
点赞数 2
分类专栏： LeetCode 文章标签： 动态规划 优先队列 堆 c++ 剑指Offer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cyril_KI/article/details/119080002
版权

目录

剑指 Offer 47. 礼物的最大价值

在这里插入图片描述
分析：
  动态规划：设dp[i][j]表示从(0, 0)位置开始到(i, j)位置的最大价值。边界条件：由于每次只能向右或者向下移动，所以第0列的方格只能由其上边的位置向下移动而来，同理第0行的方格只能由其左边的位置移动而来。所以有：

dp[i][0] = dp[i - 1][0] + grid[i][0], dp[0][j] = dp[0][j - 1] + grid[0][j]

  转移方程：每一个格子都能由两个方向而来，取它们的最大值即可：

dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];

代码：

class Solution {
public:
    int maxValue(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size();
        vector<vector<int>> dp(m, vector<int>(n, 0));
        dp[0][0] = grid[0][0];
        for(int j = 1; j < n; j++) {
            dp[0][j] = dp[0][j - 1] + grid[0][j];
        }
        for(int i = 1; i < m; i++) {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }
        for(int i = 1; i < m; i++) {
            for(int j = 1; j < n; j++) {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
            }
        }
        return dp[m - 1][n - 1];
    }
};

剑指 Offer 51. 数组中的逆序对

在这里插入图片描述
方法一：
  双层循环暴力求解，超时。
代码：

class Solution {
public:
    int reversePairs(vector<int>& nums) {
        //暴力求解
        if(nums.size() == 0) {
            return 0;
        }
        int n = nums.size();
        int res = 0;
        for(int i = 1; i < n; i++) {
            for(int j = i - 1; j >= 0; j--) {
                if(nums[j] > nums[i]) {
                    res++;
                }
            }
        }
        return res;
    }
};

方法二：
  官方题解：借助归并排序。
代码：

class Solution {
public:
    int mergeSort(vector<int>& nums, vector<int>& tmp, int l, int r) {
        if (l >= r) {
            return 0;
        }

        int mid = (l + r) / 2;
        int inv_count = mergeSort(nums, tmp, l, mid) + mergeSort(nums, tmp, mid + 1, r);
        int i = l, j = mid + 1, pos = l;
        while (i <= mid && j <= r) {
            if (nums[i] <= nums[j]) {
                tmp[pos] = nums[i];
                ++i;
                inv_count += (j - (mid + 1));
            }
            else {
                tmp[pos] = nums[j];
                ++j;
            }
            ++pos;
        }
        for (int k = i; k <= mid; ++k) {
            tmp[pos++] = nums[k];
            inv_count += (j - (mid + 1));
        }
        for (int k = j; k <= r; ++k) {
            tmp[pos++] = nums[k];
        }
        copy(tmp.begin() + l, tmp.begin() + r + 1, nums.begin() + l);
        return inv_count;
    }

    int reversePairs(vector<int>& nums) {
        int n = nums.size();
        vector<int> tmp(n);
        return mergeSort(nums, tmp, 0, n - 1);
    }
};

剑指 Offer 19. 正则表达式匹配

在这里插入图片描述
分析：
  动态规划：参考官方题解。
代码：

class Solution {
public:
    bool isMatch(string s, string p) {
        int m = s.size();
        int n = p.size();

        auto matches = [&](int i, int j) {
            if (i == 0) {
                return false;
            }
            if (p[j - 1] == '.') {
                return true;
            }
            return s[i - 1] == p[j - 1];
        };

        vector<vector<int>> f(m + 1, vector<int>(n + 1));
        f[0][0] = true;
        for (int i = 0; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (p[j - 1] == '*') {
                    f[i][j] |= f[i][j - 2];
                    if (matches(i, j - 1)) {
                        f[i][j] |= f[i - 1][j];
                    }
                }
                else {
                    if (matches(i, j)) {
                        f[i][j] |= f[i - 1][j - 1];
                    }
                }
            }
        }
        return f[m][n];
    }
};

剑指 Offer 35. 复杂链表的复制

在这里插入图片描述
分析：
  一开始是直接遍历原链表，然后生成新链表，但这样只是浅拷贝。解决办法：利用哈希表存储新旧结点之间的关系。
代码：

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(!head) {
            return NULL;
        }
        map<Node*, Node*> mp;
        Node* ptr = head;
        while(ptr) {
            Node* temp = new Node(ptr->val);
            mp[ptr] = temp;
            ptr = ptr->next;
        }
        ptr = head;
        while(ptr) {
            mp[ptr]->next = mp[ptr->next];
            mp[ptr]->random = mp[ptr->random];
            ptr = ptr->next;
        }
        return mp[head];
    }
};

剑指 Offer 41. 数据流中的中位数

在这里插入图片描述
分析：
  最简单的思路就是排序再计算，不过这样会超时。题目要求求出中位数，我们并不需要知道除了中位数以外其他的数，因此可以维护两个堆，左边维护一个大根堆，其最右边为最大值，右边维护一个小根堆，其最左边为最小值。需要保证最左边大根堆的堆顶元素小于等于右边小根堆的堆顶元素。这样，中位数就只与两个堆的堆顶元素有关。
  具体而言，如果当前两个堆元素个数相等，就将该数放入左边的大根堆，但是为了保证两个堆的大小关系成立，需要先将该元素放入小根堆，然后再取其堆顶元素放入到大根堆。如果当前两个堆元素个数不相等，就将该数加入到右边的小根堆。求中位数时，如果当前两个堆元素个数不相等，就取左边大根堆堆顶元素，否则取两个堆顶元素的平均值。
代码：

class MedianFinder {
public:
    /** initialize your data structure here. */
    priority_queue<int, vector<int>, less<int>> p;  //大根堆
    priority_queue<int, vector<int>, greater<int>> q;  //小根堆
    MedianFinder() {

    }
    
    void addNum(int num) {
        if(p.size() == q.size()) {
            q.push(num);
            p.push(q.top());
            q.pop();
        }else {
            p.push(num);
            q.push(p.top());
            p.pop();
        }
    }
    
    double findMedian() {
        if(p.size() == q.size()) {
            return (p.top() + q.top()) / 2.0;
        }else {
            return p.top() / 1.0;
        }
    }
};

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder* obj = new MedianFinder();
 * obj->addNum(num);
 * double param_2 = obj->findMedian();
 */

剑指 Offer 36. 二叉搜索树与双向链表

在这里插入图片描述
分析：
  二叉搜索树的中序遍历为一个升序序列。在进行二叉搜索树的中序遍历时，维护两个指针分别指向当前节点和上一个被访问到的节点，然后对两个节点进行链接。
代码：

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;

    Node() {}

    Node(int _val) {
        val = _val;
        left = NULL;
        right = NULL;
    }

    Node(int _val, Node* _left, Node* _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
class Solution {
public:
    Node *pre, *head;
    void ldr(Node* cur) {
        if(cur) {
            ldr(cur->left);
            //建立链接
            if(pre) {
                pre->right = cur;
            }else {
                head = cur;
            }
            cur->left = pre;
            pre = cur;
            ldr(cur->right);
        }
    }
    Node* treeToDoublyList(Node* root) {
        if(!root) {
            return NULL;
        }
        ldr(root);
        head->left = pre;
        pre->right= head;
        return head;
    }
};

剑指 Offer 43. 1～n 整数中 1 出现的次数

在这里插入图片描述
方法一：
  暴力求解，超时。
代码：

class Solution {
public:
    int get(int n) {
        int res = 0;
        while(n) {
            if(n % 10 == 1) {
                res++;
            }
            n /= 10;
        }
        return res;
    }
    int countDigitOne(int n) {
        int res = 0;
        for(int i = 1; i <= n; i++) {
            res += get(i);
        }
        return res;
    }
};

方法二：
  找规律：参考官方题解。
代码：

class Solution {
public:
    int countDigitOne(int n) {
        // 返回结果初始化为0
        int res = 0;
        // 先对最低位进行初始化
        int cur = n % 10, high = n / 10, low = 0;
        long digital = 1;
        while(high != 0 || cur != 0){
            if(cur == 0){
                res += int(high * digital);
            }else if(cur == 1){
                res += int(high * digital + low + 1);
            }else{
                res += int((high+1) * digital);
            }
            low = int(low + digital * cur);
            cur = high % 10;
            high = high / 10;
            digital *= 10;
        }
        return res;
    }
};

剑指 Offer 59 - I. 滑动窗口的最大值

在这里插入图片描述
分析：
  暴力求解方法：每滑动一次就对窗口求一次最大值，该方法会超时。可以维护一个大根堆，初始将窗口内的数压入大根堆，此时堆顶为最大值，每滑动一个窗口就将一个数加入到大根堆中，但加入后大根堆中的最大值可能并不是目前窗口内的最大值，此时可以进行循环出栈操作，直至当前大根堆堆顶元素在窗口内。
代码：

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> res;
        if(nums.size() == 0) {
            return res;
        }
        int n = nums.size();
        priority_queue<pair<int, int>> heap;  //大根堆
        for(int i = 0; i < k; i++) {
            heap.emplace(nums[i], i);
        }
        res.push_back(heap.top().first);
        int left = 1;
        for(int right = k; right < n; right++) {
            //最大值可能并不在窗口中
            heap.emplace(nums[right], right);
            while(heap.top().second < left) {
                heap.pop();
            }
            left++;
            res.push_back(heap.top().first);
        }
        return res;
    }
};
Cyril_KI
关注
专栏目录
剑指offer-什么是1G/2G/3G/4G/5G
01-06
什么是1G/2G/3G/4G/5G一、1G二、2G三、3G四、4G五、5G六、相关补充 参考十二五国家级规划教材计算机网络第七版 谢希仁编著 原创文章 104获赞 1012访问量 10万+ 关注 私信 展开阅读全文 ...
leetcode答案-JS-JavaScript-Straight-towards-Offer:LeetCode剑指offerjs/JS实现&
06-30
剑指offer js/JS 实现&简练思路 - 施工中 介绍 leetcode 《剑指offer》系列题解，随手记录一下自己的解题之路。 本仓库为了帮助和我一样有快速刷题需求的同学 内容简单直接，会包括《剑指offer》中所有题目的JS版本...
剑指offer
dew0927的博客
04-12 133
1 注意空指针， 2 空类型，没有任何成员变量和成员函数，对改类型求sizeof 　　结果为1，本来应该是0，但当我们声明该实例的时候，他必须在内存种占有一点空间，否则无法使用该实例。 　　（1）加上构造函数和析构函数 　　　　还是1 　　（2）弄个虚析构函数 　　　　多了指向虚函数表的指针。32位上，一个指针4字节，所以为4。 64位上，...
《剑指offer》答案整理
张维鹏的博客
01-21 2846
  第一题，二维数组中的查找：https://blog.csdn.net/a745233700/article/details/82108738 第二题，替换空格：https://blog.csdn.net/a745233700/article/details/82730804 第三题，从头到尾打印链表：https://blog.csdn.net/a745233700/article/det...
02. 剑指offer刷题-二叉树篇（第一部分）
最新发布
weixin_51952055的博客
08-11 118
【代码】02. 剑指offer刷题-二叉树篇（第一部分）
剑指offer-Java代码_java_剑指offer_
09-30
《剑指Offer》是一本备受推崇的编程面试指南，尤其对于Java开发者来说，它提供了大量精心设计的面试题目，旨在帮助求职者提升编程技能和解决问题的能力。这本书的Java代码实现和文字说明是深入理解问题解决方案的...
剑指offer--java版1--10源码及解析总结.zip
07-08
《剑指Offer——Java版1-10源码及解析总结》是一份针对《剑指Offer》这本书中前10个编程题目的Java实现及解析的资料合集。《剑指Offer》是许多程序员面试必备的参考书，它涵盖了大量经典的算法和数据结构问题，旨在...
浙江大华java笔试题目-online-judge:CSP/剑指Offer/蓝桥/LeetCode/PAT/题解
06-17
浙江大华java笔试题目 CCF 中国计算机学会 计算机软件能力认证 ...剑指 Offer / / 竞赛 周赛 探索 小米 OJ NowCoder 牛客网 PTA 计算机程序设计能力考试 团体程序设计天梯赛 浙江大学《数据结构》 License
剑指 Offer
破草的博客
08-09 435
刷题知真我
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Cyril_KI

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

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

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

打赏作者

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

抵扣说明：

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

余额充值