HOT100与剑指Offer

---

前言

一个本硕双非的小菜鸡，备战24年秋招，计划刷完hot100和剑指Offer的刷题计划，加油！
根据要求，每一道题都要写出两种以上的解题技巧。

一、763. 划分字母区间（HOT100）

763. 划分字母区间
Note：贪心解题，首先统计每一个字符最后出现的位置，再从头遍历字符，并更新字符的最远出现下标，如果找到字符最远出现位置下标和当前下标相等了，则找到了分割点，放入结果，更新左右指针。

class Solution {
public:
    vector<int> partitionLabels(string s) {
        
        int hash[127] = {0};
        vector<int> res;

        for (int i = 0; i < s.size(); i++) {
            hash[s[i] - 'a'] = i;
        }

        int left = 0;
        int right = 0;

        for (int i = 0; i < s.size(); i++) {
            right = max(right, hash[s[i] - 'a']);

            if (i == right) {
                res.push_back(right - left + 1);
                left = i + 1;
            }
        }
        return res;
    }
};

Note：首先记录26个字母出现的左端点和右端点，然后并保存按左端点从小到大排序（题目要求要从左到右返回一个表示每个字符串片段的长度的列表），最后合并重叠的区间。如果发现区间合并重叠，就采用右边边界最小值。
（说实话这方法实在是费力不讨好）

typedef pair<int, int> PA;
class Solution {
public:
    vector<int> partitionLabels(string s) {
        int n = s.size();
        vector<int> res;
        vector<PA> mp;
        for (int i = 0; i < 26; i++) {
            char c = 'a' + i;
            int l = 0, r = n - 1;
            while (l < n && s[l] != c) l++;
            if (l == n) continue;
            while (r >= 0 && s[r] != c) r--;
            mp.emplace_back(l, r);
        }
        sort(mp.begin(), mp.end(), [](PA &p1, PA &p2) {
            return p1.first < p2.first;
        });
        int lasta = -1, lastb = -1;
        for (auto &[a, b] : mp) {
            if (lastb < 0) {
                lasta = a;
                lastb = b;
            } else {
                if (a > lastb) {
                    res.emplace_back(lastb - lasta + 1);
                    lasta = a;
                    lastb = b;
                } else {
                    lastb = max(lastb, b);
                }
            }
        }
        res.emplace_back(lastb - lasta + 1);
        return res;
    }
};

二、6. 从尾到头打印链表（剑指Offer）

从尾到头打印链表

Note：使用栈作为辅助

class Solution {
public:
    vector<int> printListReversingly(ListNode* head) {
        
        stack<int> stk;

        
        ListNode* pNode = head;
        
        while (pNode != nullptr) {
            stk.push(pNode->val);
            pNode = pNode->next;
        }
        
        int sizes = stk.size();
        vector<int> res(sizes);
        
        for (int i = 0; i < sizes; i++) {
            res[i] = stk.top();
            stk.pop();
        }
        return res;
    }
};

Note：翻转数组

class Solution {
public:
    vector<int> printListReversingly(ListNode* head) {
        vector<int> res;
        
        while (head != nullptr) {
            res.push_back(head->val);
            head = head->next;
        }
        
        reverse(res.begin(), res.end());
        
        return res;
    }
};

总结

祝大家都能学有所成，找到一份好工作！