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
53
54
55
56
57
58
59
60
61
62
63
64

#include <vector>
#include <algorithm> // for std::max, std::min
using namespace std;

// 二维前缀和类，用于快速计算任意矩形子矩阵的和
class SumMatrix {
public:
    // preSum[i][j] 表示原始矩阵中前 i 行、前 j 列（即区域 [0, i) × [0, j)）所有元素的和
    // 维度为 (m+1) x (n+1)，其中 m、n 为原始矩阵的行数和列数
    vector<vector<int>> preSum;

    // 构造函数：根据原始矩阵 matrix 构建前缀和数组
    SumMatrix(vector<vector<int>>& matrix) {
        int m = matrix.size();          // 原始矩阵的行数
        int n = matrix[0].size();       // 原始矩阵的列数
        // 初始化前缀和数组，多一行一列用于简化边界处理
        preSum.resize(m + 1, vector<int>(n + 1, 0));

        // 计算前缀和：preSum[i][j] = preSum[i-1][j] + preSum[i][j-1] - preSum[i-1][j-1] + matrix[i-1][j-1]
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                preSum[i][j] = preSum[i - 1][j] + preSum[i][j - 1]
                               + matrix[i - 1][j - 1] - preSum[i - 1][j - 1];
            }
        }
    }

    // 计算原始矩阵中闭区间 [x1, x2] 行、[y1, y2] 列所围成的子矩阵的和
    // 注意：x1, x2, y1, y2 都是原始矩阵的有效索引（0-based）
    int Addmatrix(int x1, int x2, int y1, int y2) {
        // 利用前缀和公式：sum = preSum[x2+1][y2+1] - preSum[x1][y2+1] - preSum[x2+1][y1] + preSum[x1][y1]
        // 因为 preSum 的行/列索引比原始矩阵大 1，所以需要 +1 转换
        return preSum[x2 + 1][y2 + 1] - preSum[x1][y2 + 1]
               - preSum[x2 + 1][y1] + preSum[x1][y1];
    }
};

class Solution {
public:
    // 计算矩阵区域和：对于每个位置 (i, j)，求以该位置为中心、边长为 2k+1 的正方形区域的和
    // （边界超出矩阵时只取有效部分）
    vector<vector<int>> matrixBlockSum(vector<vector<int>>& mat, int k) {
        int m = mat.size();      // 矩阵行数
        int n = mat[0].size();   // 矩阵列数
        // 结果矩阵，大小与原始矩阵相同
        vector<vector<int>> answer(m, vector<int>(n, 0));
        // 构建原始矩阵的前缀和对象
        SumMatrix mt = SumMatrix(mat);
        // 遍历每个位置 (i, j)
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                // 计算以 (i, j) 为中心、半径为 k 的矩形区域的边界（需限制在矩阵范围内）
                int x1 = max(i - k, 0);        // 上边界（行最小索引）
                int x2 = min(i + k, m - 1);    // 下边界（行最大索引）
                int y1 = max(j - k, 0);        // 左边界（列最小索引）
                int y2 = min(j + k, n - 1);    // 右边界（列最大索引）

                // 通过前缀和快速得到该区域的和，并填入结果矩阵
                answer[i][j] = mt.Addmatrix(x1, x2, y1, y2);
            }
        }
        return answer;
    }
};

1
2
3
4

preSum[i][j] = preSum[i-1][j]        // 上面那块
             + preSum[i][j-1]        // 左边那块
             + matrix[i-1][j-1]      // 当前这个数
             - preSum[i-1][j-1]      // 左上角被算了两次，扣掉

1
2
3
4

sum = preSum[x2+1][y2+1]      // 整块从原点到右下
    - preSum[x1][y2+1]        // 砍掉上面
    - preSum[x2+1][y1]        // 砍掉左边
    + preSum[x1][y1]          // 左上角被砍了两次，补回来

1
2
3
4
5

slow 走：a + b
fast 走：2(a + b) = a + b + n·c     （fast 比 slow 多绕了 n 圈）

⇒  a + b = n·c
⇒  a = n·c - b

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (fast != nullptr) {
            if (fast->next == nullptr) {
                return nullptr;          // 无环
            }
            fast = fast->next->next;     // 走 2 步
            slow = slow->next;           // 走 1 步
            if (fast == slow) {          // 第一次相遇，说明有环
                ListNode* cur = head;
                while (fast != cur) {    // 同步走 1 步
                    cur = cur->next;
                    fast = fast->next;
                }
                return cur;              // 环入口
            }
        }
        return nullptr;                  // fast 走到末尾，无环
    }
};

 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

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    if (headA == nullptr || headB == nullptr) {
        return nullptr;
    }
    auto cur1 = headA;
    auto cur2 = headB;
    bool flag1 = 0;
    bool flag2 = 0;
    while (cur1 != cur2) {
        cur1 = cur1->next;
        cur2 = cur2->next;
        if ((flag1 && flag2) && (cur1 == nullptr || cur2 == nullptr)) {
            return nullptr;
        }
        if (cur1 == nullptr) {
            cur1 = headB;
            flag2 = 1;
        }
        if (cur2 == nullptr) {
            cur2 = headA;
            flag1 = 1;
        }
    }
    return cur1;
}

1
2
3
4
5
6
7
8
9

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    auto cur1 = headA;
    auto cur2 = headB;
    while (cur1 != cur2) {
        cur1 = cur1 ? cur1->next : headB;
        cur2 = cur2 ? cur2->next : headA;
    }
    return cur1;
}

1

dummy(0) → 1(1) → 2(2) → … → nodeL(L) → nullptr(L+1)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode* dummy = new ListNode(0, head);
    ListNode* fast = dummy;
    ListNode* slow = dummy;

    for (int i = 0; i <= n; ++i) {   // fast 先走 n+1 步
        fast = fast->next;
    }
    while (fast != nullptr) {        // 快慢一起走
        fast = fast->next;
        slow = slow->next;
    }
    // 现在 slow 是目标节点的前驱
    ListNode* target = slow->next;   // ① 记住要删的节点
    slow->next = slow->next->next;   // ② 先重接链表（摘下来）
    delete target;                   // ③ 再删除目标

    ListNode* result = dummy->next;  // ④ 先读答案
    delete dummy;                    // ⑤ 再删 dummy（可选）
    return result;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode* dummyhead = new ListNode(-1, head);
    ListNode* fast = dummyhead;
    ListNode* slow = dummyhead;
    fast = fast->next;                 // 先手动走 1 步
    for (int i = 0; i < n; i++) {      // 再走 n 步，合计 n+1 步
        fast = fast->next;
    }
    while (fast != nullptr) {
        fast = fast->next;
        slow = slow->next;
    }
    auto temp = slow->next;
    slow->next = slow->next->next;
    delete temp;
    return dummyhead->next;
}

1
2

反转 1→2→3→4
= 先反转 2→3→4（得到 4→3→2），再把 1 接到 2 的后面

1
2
3
4
5
6
7
8
9

ListNode* reverseList(ListNode* head) {
    if (head == nullptr || head->next == nullptr) {
        return head;                          // 基例
    }
    ListNode* last = reverseList(head->next); // 假设后面已经反转好
    head->next->next = head;                  // 把自己挂到末尾
    head->next = nullptr;                     // 断开旧指针
    return last;                              // 新头始终不变
}

1
2
3

反转前：          head → head->next → ... → last
调用后（还没处理 head 时）：
                  head → (4 → 3 → 2)        ← head->next 现在指向 2，正好是子链表尾巴

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

ListNode* reverseList(ListNode* head) {
    ListNode* pre = nullptr;
    ListNode* cur = head;
    while (cur != nullptr) {
        ListNode* next = cur->next;  // 先保存下一个，防止断链
        cur->next = pre;             // 反转当前指针
        pre = cur;                   // pre 前进
        cur = next;                  // cur 前进
    }
    return pre;                      // 结束时 pre 是原链表尾，即新链表头
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

ListNode* reverse(ListNode* pre, ListNode* cur) {
    if (cur == nullptr) return pre;      // 循环退出条件
    ListNode* temp = cur->next;          // 保存下一个，防止断链
    cur->next = pre;                     // 反转当前指针
    return reverse(cur, temp);           // 相当于 pre = cur; cur = temp; 进入下一轮
}

ListNode* reverseList(ListNode* head) {
    return reverse(nullptr, head);       // 相当于 pre = nullptr; cur = head;
}

1

reverse(NULL, 1) → reverse(1, 2) → reverse(2, 3) → reverse(3, 4) → reverse(4, NULL)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

ListNode* reverseList(ListNode* head) {
    ListNode* dummy = new ListNode(0);
    while (head != nullptr) {
        ListNode* next = head->next;   // 保存下一个，防止断链
        head->next = dummy->next;      // 把当前节点插到 dummy 后面
        dummy->next = head;
        head = next;
    }
    return dummy->next;                // dummy 站岗，dummy->next 交卷
}

1
2
3
4

dummy → 1              （插 1）
dummy → 2 → 1          （插 2）
dummy → 3 → 2 → 1      （插 3）
返回 3 → 2 → 1

 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

class PrefixSuffixProduct
{public:
    vector<int> prefix;
    vector<int> suffix;
    PrefixSuffixProduct(vector<int>& nums)
    {
        int sz = nums.size();
        prefix.resize(sz+1,1);
        suffix.resize(sz+1,1);
        for(int i=1;i<=sz;i++)
        {
            prefix[i] = prefix[i-1] * nums[i-1];
        }
        for(int i=sz-1;i>=0;i--)
        {
            suffix[i] = suffix[i+1] * nums[i];
        }
    }
    int plus_matrix(int x1)
    {
        return prefix[x1] * suffix[x1+1];
    }
};

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        vector<int> res;
        PrefixSuffixProduct am(nums);
        int sz = nums.size();
        res.resize(sz,1);
        for(int i = 0;i<sz;i++)
        {
           res[i] = am.plus_matrix(i);
        }
        return res;
    }
};

1

prev -> a -> b -> rest     交换成     prev -> b -> a -> rest

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// 交换 prev 后面的两个节点
// 调用前：prev -> a -> b -> rest
// 调用后：prev -> b -> a -> rest
void swapTwo(ListNode* prev) {
    ListNode* a = prev->next;
    ListNode* b = a->next;
    a->next = b->next;      // a 先接到 rest
    b->next = a;            // b 指回 a
    prev->next = b;         // 前面的链接上 b
}

ListNode* swapPairs(ListNode* head) {
    ListNode* dummy = new ListNode(0, head);  // 虚拟头，让第一对也有 prev
    ListNode* prev = dummy;
    while (prev->next != nullptr && prev->next->next != nullptr) {
        swapTwo(prev);
        prev = prev->next->next;   // 下一对的前一个节点 = a
    }
    return dummy->next;
}

1
2
3

dummy -> 1 -> 2 -> 3 -> 4
第 1 轮：dummy -> 2 -> 1 -> 3 -> 4，prev 跳到 1
第 2 轮：dummy -> 2 -> 1 -> 4 -> 3，prev 跳到 3

1
2
3
4
5
6
7

ListNode* swapPairs(ListNode* head) {
    if (head == nullptr || head->next == nullptr) return head;  // 基例
    ListNode* second = head->next;
    head->next = swapPairs(second->next);   // 信任子问题：后面的已经交换好
    second->next = head;                    // 这一层只交换前两个
    return second;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

swapPairs(1→2→3→4)
  ├─ head=1, second=2
  ├─ 先算 swapPairs(3→4)     ← 小问题 = 从第3个节点起的整段
  │    ├─ head=3, second=4
  │    ├─ swapPairs(nullptr)  ← 空链表 → 返回 nullptr（基例）
  │    ├─ 3->next = nullptr
  │    ├─ 4->next = 3
  │    └─ 返回 4             （3→4 已变 4→3）
  ├─ 回到第一层：1->next = 4   ← 4 接在 1 后面，链变成 1→4→3
  ├─ 2->next = 1              ← 最外层现在才交换 1 和 2
  └─ 返回 2                   （最终 2→1→4→3 ✓）

1
2

while(){ ... }                    // 空条件，编译不过
new_cur->next = x;                // x 没定义

1
2

插入：prev -> next      变成      prev -> newNode -> next
删除：prev -> target -> next     变成      prev -------> next

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

struct st_node {
    int st_val{};
    st_node* st_next{};
};

class NodeList {
    int numbers{};
    vector<st_node> node_list_;
    unordered_map<int, st_node> select_table;
};

1
2
3
4
5
6
7

MyLinkedList
├── dummyHead_：虚拟头节点
└── size_：真实节点数量

Node
├── val
└── next

1

st_node();

1

MyLinkedList() : dummyHead_(new Node()), size_(0) {}

1

head -> A -> B

1

dummy -> A -> B -> nullptr

1
2
3

dummy -> 0 -> 1 -> 2
                 ↑
               prev

 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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

class MyLinkedList {
private:
    struct Node {
        int val;
        Node* next;

        Node(int value = 0, Node* nextNode = nullptr)
            : val(value), next(nextNode) {}
    };

    Node* dummyHead_;  // 永远存在，不计入 size_
    int size_;         // 真实数据节点的数量

public:
    MyLinkedList()
        : dummyHead_(new Node()), size_(0) {}

    ~MyLinkedList() {
        Node* cur = dummyHead_;
        while (cur != nullptr) {
            Node* next = cur->next;
            delete cur;
            cur = next;
        }
    }

    int get(int index) {
        if (index < 0 || index >= size_) {
            return -1;
        }

        Node* cur = dummyHead_->next;
        for (int i = 0; i < index; ++i) {
            cur = cur->next;
        }
        return cur->val;
    }

    void addAtHead(int val) {
        addAtIndex(0, val);
    }

    void addAtTail(int val) {
        addAtIndex(size_, val);
    }

    void addAtIndex(int index, int val) {
        if (index < 0) {
            index = 0;
        }
        if (index > size_) {
            return;
        }

        Node* prev = dummyHead_;
        for (int i = 0; i < index; ++i) {
            prev = prev->next;
        }

        prev->next = new Node(val, prev->next);
        ++size_;
    }

    void deleteAtIndex(int index) {
        if (index < 0 || index >= size_) {
            return;
        }

        Node* prev = dummyHead_;
        for (int i = 0; i < index; ++i) {
            prev = prev->next;
        }

        Node* target = prev->next;
        prev->next = target->next;
        delete target;
        --size_;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

初始：dummy

addAtHead(1)
dummy -> 1

addAtTail(3)
dummy -> 1 -> 3

addAtIndex(1, 2)
dummy -> 1 -> 2 -> 3

deleteAtIndex(1)
dummy -> 1 -> 3

1

diff[i] = nums[i] - nums[i-1]

1
2

diff[i] += val;
diff[j + 1] -= val;   // 注意边界：j+1 不能越界

1
2
3
4

res[0] = diff[0];
for (int i = 1; i < n; i++) {
    res[i] = res[i - 1] + diff[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
33

class Difference {
private:
    vector<int> diff;

public:
    // 构造差分数组
    Difference(vector<int>& nums) {
        diff.resize(nums.size());
        diff[0] = nums[0];
        for (int i = 1; i < nums.size(); i++) {
            diff[i] = nums[i] - nums[i - 1];
        }
    }

    // 区间 [i, j] 增加 val（可为负数）
    void increment(int i, int j, int val) {
        diff[i] += val;
        if (j + 1 < diff.size()) {
            diff[j + 1] -= val;
        }
        // j+1 越界说明加到末尾，不用减
    }

    // 返回最终结果数组
    vector<int> result() {
        vector<int> res(diff.size());
        res[0] = diff[0];
        for (int i = 1; i < diff.size(); i++) {
            res[i] = res[i - 1] + diff[i];
        }
        return res;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

vector<int> getModifiedArray(int n, vector<vector<int>>& updates) {
    vector<int> diff(n, 0);
    for (auto& op : updates) {
        int s = op[0], e = op[1], val = op[2];
        diff[s] += val;
        if (e + 1 < n) diff[e + 1] -= val;
    }
    // 还原
    vector<int> res(n);
    res[0] = diff[0];
    for (int i = 1; i < n; i++) {
        res[i] = res[i - 1] + diff[i];
    }
    return res;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

vector<int> corpFlightBookings(vector<vector<int>>& bookings, int n) {
    vector<int> diff(n, 0);
    for (auto& b : bookings) {
        int first = b[0] - 1;   // 注意题目是 1-based
        int last = b[1] - 1;
        int seats = b[2];
        diff[first] += seats;
        if (last + 1 < n) diff[last + 1] -= seats;
    }
    // 前缀和还原
    for (int i = 1; i < n; i++) {
        diff[i] += diff[i - 1];
    }
    return diff;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

bool carPooling(vector<vector<int>>& trips, int capacity) {
    vector<int> diff(1001, 0);  // 站点最多 1000
    for (auto& t : trips) {
        int num = t[0], from = t[1], to = t[2];
        diff[from] += num;
        diff[to] -= num;   // 到 to 站下车，不用 to+1
    }

    int cur = 0;
    for (int x : diff) {
        cur += x;
        if (cur > capacity) return false;
    }
    return true;
}

1
2
3
4
5
6
7

// 对矩形 (x1,y1) ~ (x2,y2) 加 val
diff[x1][y1] += val;
diff[x2 + 1][y1] -= val;
diff[x1][y2 + 1] -= val;
diff[x2 + 1][y2 + 1] += val;

// 最后做二维前缀和还原

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 输入 nums，返回每个元素右边第一个比它大的元素值，没有返回 -1
vector<int> nextGreaterElement(vector<int>& nums) {
    int n = nums.size();
    vector<int> res(n, -1);
    stack<int> st;  // 存下标，不是值

    // 从后往前遍历
    for (int i = n - 1; i >= 0; i--) {
        // 栈顶比当前小，肯定不是答案，弹出
        while (!st.empty() && nums[st.top()] <= nums[i]) {
            st.pop();
        }
        // 此时栈顶就是右边第一个更大的
        if (!st.empty()) res[i] = nums[st.top()];
        st.push(i);
    }
    return res;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

vector<int> dailyTemperatures(vector<int>& temperatures) {
    int n = temperatures.size();
    vector<int> res(n, 0);
    stack<int> st;

    for (int i = n - 1; i >= 0; i--) {
        while (!st.empty() && temperatures[st.top()] <= temperatures[i]) {
            st.pop();
        }
        if (!st.empty()) res[i] = st.top() - i;  // 存下标，算天数差
        st.push(i);
    }
    return res;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

vector<int> nextGreaterElements(vector<int>& nums) {
    int n = nums.size();
    vector<int> res(n, -1);
    stack<int> st;

    for (int i = 2 * n - 1; i >= 0; i--) {
        while (!st.empty() && st.top() <= nums[i % n]) {
            st.pop();
        }
        if (i < n && !st.empty()) res[i] = st.top();
        st.push(nums[i % n]);
    }
    return res;
}

 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

int largestRectangleArea(vector<int>& heights) {
    int n = heights.size();
    vector<int> left(n, -1);   // 左边第一个更小的下标
    vector<int> right(n, n);   // 右边第一个更小的下标
    stack<int> st;

    // 找左边第一个更小
    for (int i = 0; i < n; i++) {
        while (!st.empty() && heights[st.top()] >= heights[i]) {
            st.pop();
        }
        if (!st.empty()) left[i] = st.top();
        st.push(i);
    }

    // 清空栈，找右边第一个更小
    while (!st.empty()) st.pop();
    for (int i = n - 1; i >= 0; i--) {
        while (!st.empty() && heights[st.top()] >= heights[i]) {
            st.pop();
        }
        if (!st.empty()) right[i] = st.top();
        st.push(i);
    }

    // 计算面积
    int ans = 0;
    for (int i = 0; i < n; i++) {
        ans = max(ans, heights[i] * (right[i] - left[i] - 1));
    }
    return ans;
}