leetcode刷题记录09（2023-05-19）【乘积最大子数组(动态规划，最大最小值转换) | 最小栈(用vector进行模拟) | 相交链表(hash) | 打家劫舍(一维动态规划)】

Cherries Man

已于 2024-01-10 16:39:50 修改

阅读量1.2k

点赞数 37

分类专栏：刷题笔记文章标签： leetcode 动态规划链表

于 2023-12-31 09:55:50 首次发布

本文链接：https://blog.csdn.net/myf_666/article/details/130774693

版权

刷题笔记专栏收录该内容

52 篇文章 0 订阅

订阅专栏

152. 乘积最大子数组

给你一个整数数组 nums ，请你找出数组中乘积最大的非空连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。

测试用例的答案是一个 32-位整数。

子数组是数组的连续子序列。

示例 1:
输入: nums = [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。

示例 2:
输入: nums = [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。

提示:

$1 <= nums.length <= 2 * 10^4$
$- 10 <= n u m s [i] <= 10$
nums 的任何前缀或后缀的乘积都保证是一个 32-位整数

很关键的一点就是最大值和最小值的转换，如果遇到负数，那么以当前这个数结尾的解的最大值就是 $minProduct\times nums[i]$ ，否则就是 $max(maxProduct\times nums[i],nums[i])$

#include<vector>
#include<iostream>

using namespace std;

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int maxProduct = 1;
        int minProduct = 1;
        int ans = -0x3f3f3f3f;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] < 0) {
                swap(maxProduct, minProduct);
            }
            maxProduct = max(maxProduct * nums[i], nums[i]);
            minProduct = min(minProduct * nums[i], nums[i]);
            ans = max(maxProduct, ans);
        }
        return ans;
    }
};

int main() {
    vector<int> vec = { 2,3,-3,2 };
    Solution sol;
    int ans = sol.maxProduct(vec);
    cout << ans;
    return 0;
}

155. 最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现 MinStack 类:

MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。

示例 1:

输入：
[“MinStack”,“push”,“push”,“push”,“getMin”,“pop”,“top”,“getMin”]
[[],[-2],[0],[-3],[],[],[],[]]

输出：
[null,null,null,null,-3,null,0,-2]

解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.

提示：

$2^{31} <= val <= 2^{31} - 1$
pop、top 和 getMin 操作总是在非空栈上调用
push, pop, top, and getMin最多被调用 3 * 104 次

又是一道一遍就通过的题目，感觉很棒！

在这里插入图片描述

考虑到空间复杂度，因此定义了一个count数组来存储最小值的重复个数，代码如下：

#include<vector>
using namespace std;

class MinStack {
private:
    // 用来记录最小值
    vector<int> minVal;
    // 用来模拟栈的数组
    vector<int> stk;
    // 用来记录最小值的个数
    vector<int> count;
public:
    MinStack() {

    }

    void push(int val) {
        stk.push_back(val);
        // 如果minVal为空，或者当前val刷新了栈中的最小值
        if (minVal.empty() || val < *(minVal.end() - 1)) {
            minVal.push_back(val);
            count.push_back(1);
        }
        else if (val == *(minVal.end() - 1)) {
            *(count.end() - 1) += 1;
        }
        else {
            return;
        }
    }

    void pop() {
        if (*(stk.end() - 1) == *(minVal.end() - 1)) {
            *(count.end() - 1) -= 1;
            if (*(count.end() - 1) == 0) {
                minVal.pop_back();
                count.pop_back();
            }
        }
        stk.pop_back();
    }

    int top() {
        return *(stk.end() - 1);
    }

    int getMin() {
        return *(minVal.end() - 1);
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(val);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

160. 相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

图示两个链表在节点 c1 开始相交：

在这里插入图片描述

题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须保持其原始结构。

自定义评测：

评测系统的输入如下（你设计的程序不适用此输入）：

intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
listA - 第一个链表
listB - 第二个链表
skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数
评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被视作正确答案。

示例 1：

在这里插入图片描述

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

示例 2：

在这里插入图片描述

输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at ‘2’
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

在这里插入图片描述

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

提示：

listA 中节点数目为 m
listB 中节点数目为 n
$1 <= m, n <= 3 * 10^4$
$1 <= Node.val <= 10^5$
$0 <= s ki p A <= m$
$0 <= s ki pB <= n$
如果 listA 和 listB 没有交点，intersectVal 为 0
如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]

进阶：你能否设计一个时间复杂度 O(m + n) 、仅用 O(1) 内存的解决方案？

同样一次运行就通过了，感觉很棒！

在这里插入图片描述

利用一个 hash 进行查重，如果查到重复的，就是交叉节点。

#include<unordered_set>

using namespace std;

/**
 * Definition for singly-linked list.
*/
struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

class Solution {
public:
    ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
        unordered_set<ListNode*> setNodes;
        ListNode* curPtr = headA;
        while (curPtr != nullptr) {
            setNodes.insert(curPtr);
            curPtr = curPtr->next;
        }

        curPtr = headB;
        while (curPtr!=nullptr) {
            if (setNodes.find(curPtr) != setNodes.end()) {
                return curPtr;
            }
            curPtr = curPtr->next;
        }

        return nullptr;
    }
};

198. 打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下，一夜之内能够偷窃到的最高金额。

示例 1：
输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。

示例 2：
输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。

提示：
$1 <= n u m s . l e n g t h <= 100$
$0 <= n u m s [i] <= 400$

这道题目就是一道动态规划的题目，最优解只可能为2种情况：

要么当前房间的财物不要，那么最大值就是上一间房屋的最大值。
要么当前房屋的财物要，那么最大值就是上两间房屋的最大值。

#include<vector>
using namespace std;

class Solution {
public:
    int rob(vector<int>& nums) {
        int maxVal = nums[0];
        if (nums.size() == 1) {
            return maxVal;
        }
        else if (nums.size() == 2) {
            maxVal = max(nums[0], nums[1]);
        }
        else {
            vector<int> allVals(nums.size());
            allVals[0] = nums[0];
            allVals[1] = max(nums[0], nums[1]);
            for (int i = 2; i < nums.size(); i++) {
                allVals[i] = max(allVals[i - 1], allVals[i - 2] + nums[i]);
                if (allVals[i] > maxVal) {
                    maxVal = allVals[i];
                }
            }
        }
        return maxVal;
    }
};

Cherries Man

关注

37
点赞
踩
23

收藏

觉得还不错? 一键收藏
打赏
0
评论
leetcode刷题记录09（2023-05-19）【乘积最大子数组(动态规划，最大最小值转换) | 最小栈(用vector进行模拟) | 相交链表(hash) | 打家劫舍(一维动态规划)】

【乘积最大子数组(动态规划，最大最小值转换) | 最小栈(用vector进行模拟) | 相交链表(hash) | 打家劫舍(一维动态规划)】
复制链接

扫一扫