leetcode刷题记录01（2023-03-29）【盛最多水的容器(双指针/谁小谁移动) | 删除链表的倒数第 N 个结点 | 下一个排列(贪心/换低位不换高) | 最长有效括号(栈)】

11. 盛最多水的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
示例 2：

输入：height = [1,1]
输出：1

解题方法就是如提示所示，非常简单。

代码如下：

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

class Solution {
public:
    int maxArea(vector<int>& height) {

        int n = height.size();
        int i = 0, j = n - 1;
        int maxVal = -1;
        while (i < j) {
            maxVal = max(maxVal,
                (j - i) * min(height[i], height[j]));
            if (height[i] < height[j]) {
                i++;
            }
            else if (height[i] > height[j]) {
                j--;
            }
            else {
                i++;
                j--;
            }
        }
        return maxVal;
    }
};

int main() {
    vector<int>vec = { 1,8,6,2,5,4,8,3,7 };
    Solution sol;
    cout<<sol.maxArea(vec);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

19. 删除链表的倒数第 N 个结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：

输入：head = [1], n = 1
输出：[]
示例 3：

输入：head = [1,2], n = 1
输出：[1]

提示：

链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz

代码实现如下：

#include<iostream>
using namespace std;

// Definition for singly-linked list.
struct ListNode {
    int val;
    ListNode* next;
    ListNode() : val(0), next(nullptr) {}
    ListNode(int x) : val(x), next(nullptr) {}
    ListNode(int x, ListNode* next) : val(x), next(next) {}
};
 
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* first = head;
        ListNode* last = head;
        for (int i = 0; i < n - 1; i++) {
            last = last->next;
        }
        ListNode* pre = first;
        while (last->next != nullptr) {
            pre = first;
            first = first->next;
            last = last->next;
        }
        ListNode* del = first;
        if (pre == first) {
            head = pre->next;
        }
        else {
            pre->next = first->next;
        }
        delete del;
        return head;
    }
};

int main() {
    ListNode* list = new ListNode(0);
    ListNode* cur = list;
    for (int i = 0; i < 5; i++) {
        cur->next = new ListNode(i + 1);
        cur = cur->next;
    }
    Solution sol;
    ListNode* head = sol.removeNthFromEnd(list, 2);
    while (head != nullptr) {
        cout << head->val << " ";
        head = head->next;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

值得注意的是，这里需要考虑一下边界情况，当pre指针和first指针重叠的时候，证明双指针没有移动过，这时候应该直接将head移动到pre->next，而不是移动first了。

31. 下一个排列

整数数组的一个 排列 就是将其所有成员以序列或线性顺序排列。

例如，arr = [1,2,3] ，以下这些都可以视作 arr 的排列：[1,2,3]、[1,3,2]、[3,1,2]、[2,3,1] 。
整数数组的 下一个排列 是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的 下一个排列 就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。

• 例如，arr = [1,2,3] 的下一个排列是 [1,3,2] 。
• 类似地，arr = [2,3,1] 的下一个排列是 [3,1,2] 。
• 而 arr = [3,2,1] 的下一个排列是 [1,2,3] ，因为 [3,2,1] 不存在一个字典序更大的排列。

给你一个整数数组 nums ，找出 nums 的下一个排列。

必须 原地 修改，只允许使用额外常数空间。

示例 1：

输入：nums = [1,2,3]
输出：[1,3,2]
示例 2：

输入：nums = [3,2,1]
输出：[1,2,3]
示例 3：

输入：nums = [1,1,5]
输出：[1,5,1]

提示：

1 <= nums.length <= 100
0 <= nums[i] <= 100

交换一个正序数，才能使得字典序变大。怎么使得它变大的最小呢？要根据低位优先的原则，即：只要可以，就换低位的，所以就有了两层循环都是倒着写的，第一个满足条件的，一定是对整体的值增长影响最小的。

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

class Solution {
public:
    void nextPermutation(vector<int>& nums) {
        int n = nums.size();
        for (int i = n - 2; i >= 0; i--) {
            for (int j = n - 1; j > i; j--) {
                if (nums[i] < nums[j]) {
                    swap(nums[i], nums[j]);
                    sort(nums.begin() + i + 1, nums.end());
                    return;
                }
            }

        }
        sort(nums.begin(), nums.end());
    }
};

int main() {
    vector<int> vec = { 1,2,3 };
    Solution sol;
    sol.nextPermutation(vec);
    for (int i = 0; i < vec.size(); i++) {
        cout << vec[i] << " ";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

32. 最长有效括号

给你一个只包含 ‘(’ 和 ‘)’ 的字符串，找出最长有效（格式正确且连续）括号子串的长度。

示例 1：

输入：s = “(()”
输出：2
解释：最长有效括号子串是 “()”
示例 2：

输入：s = “)()())”
输出：4
解释：最长有效括号子串是 “()()”
示例 3：

输入：s = “”
输出：0

提示：

0 <= s.length <= 3 * 104
s[i] 为 ‘(’ 或 ‘)’

这道题目程序设计技巧值得学习，栈中保存的是下标索引，这样就可以很好地记录当前可行的括号数目了。

当出现不可行的时候，栈肯定是出现空的情况的，所以会弹出之前压入的-1，压入当前的下标索引。

代码如下：

#include<string>
#include<stack>
#include<iostream>
using namespace std;
class Solution {
public:
    int longestValidParentheses(string s) {
        stack<int> stk;
        stk.push(-1);
        int maxNum = 0;
        int curNum = 0;
        for (int i = 0; i < s.size(); i++) {
            if (s[i] == ')') {
                stk.pop();
                if (!stk.empty()) {                    
                    maxNum = max(maxNum, i - stk.top());
                }
                else {
                    stk.push(i); // 重新从 i 开始了
                }
            }
            else {
                stk.push(i);
            }
        }
        return maxNum;
    }
};

int main() {
    string s = "()(()";
    Solution sol;
    cout << sol.longestValidParentheses(s);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34