[朝花夕拾] LeetCode每日一题

值得一提：

20220304 2104; 20220309 798; 20220330 1606;

 

20220228 1601. 最多可达成的换楼请求数目

方法一：DFS 枚举

枚举所有换楼请求的选择与不选择两种情况，最后判断是否满足题意，时间复杂度为 O(2 ^ m)，m 为请求个数，依题意 m <= 16，符合要求。

#include <cstring> 

const int N = 25;

class Solution {
public:
    int a[N][N], b[N];
    int dfs(int o, int x, int n, int m) {
        int res = 0;
        if (o == m) {
            int tot = 0;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++)
                    tot += (b[j] ? a[j][i] : 0);
                if (tot != 0) return 0;
            }
            return x;        
        }
        b[o] = 1;
        res = dfs(o + 1, x + 1, n, m);
        b[o] = 0;
        res = max(res, dfs(o + 1, x, n, m));
        return res;
    }
    int maximumRequests(int n, vector<vector<int>>& requests) {
        int m = requests.size();
        for (int i = 0; i < m; i++)
            a[i][requests[i][0]] += -1, a[i][requests[i][1]] += 1;
        memset(b, 0, sizeof(b));
        return dfs(0, 0, n, m); 
    }
};

其实不用转换为二维数组，可以节省空间，并且 DFS 过程中就可以维护是否满足条件而不需要最后用 for 循环判断，代码有优化空间。

方法二：二进制位运算枚举

由于对于请求只有选择与不选择两种可能，使用二进制位运算，会大幅精简代码，但需要再最后用 for 循环判断是否满足条件，故时间复杂度会达到 O(n * 2 ^ m)。

const int N = 25;

class Solution {
public:
    int maximumRequests(int n, vector<vector<int>>& r) {
        int a[N], m = r.size(), ans = 0;
        for (int o = 0; o < (1 << m); o++) {
            memset(a, 0, sizeof(a));
            int res = 0;
            for (int i = 0; i < m; i++)
                if (o & (1 << i))
                    a[r[i][0]]--, a[r[i][1]]++, res++;
            int tot = 0;
            for (int i = 0; i < n; i++)
                tot += (a[i] == 0);
            if (tot == n) ans = max(res, ans);
        }
        return ans;
    }
};

其他：最小费用最大流

由于数据量并不大，用网络流有点杀鸡用牛刀了。

 

20220301 6. Z 字形变换

方法：找规律构造

对需要输出的 Z 字形矩阵进行编号，找出规律即可直接构造。

class Solution {
public:
    string convert(string s, int r) {
        string a;
        int l = s.length(), x = 0;
        if (r == 1) return s;
        for (int i = 0; i < r; i++) {
            int o = i;
            if (o >= l) return a;
            while (1) {
                if (i != r - 1) {
                    a += s[o];
                    o += (r - i - 1) * 2;
                    if (o >= l) break;
                }
                if (i != 0) {
                    a += s[o];
                    o += i * 2;
                    if (o >= l) break;
                }
            }
        }
        return a;
    }
};

注意 numRows 为 1 时在这里需要单独考虑。

其他：官方也提供了二维矩阵模拟和压缩存储空间两种方法，但显然是构造最为简单。

 

20220302 564. 寻找最近的回文数

自己做的时候思路不太行，越做越麻烦。

看了官方的题解，温习和新学到了很多 C++ 特别是新版的用法：

> stoi, stol, to_string... 等字符串转换函数

> rbegin(), rend() 反向迭代器同样适用于 string

> i & 1 非常方便的区分奇数偶数的写法

> for (int i : {...}) 以及 for (auto& i: list)

class Solution {
public:
    vector<long> getlist(const string& str) {
        int l = str.length();
        vector<long> list = {(long)pow(10, l - 1) - 1, (long)pow(10, l) + 1};
        long pre = stol(str.substr(0, (l + 1) / 2));
        for (int i : {pre - 1, pre, pre + 1}) {
            string pres = to_string(i);
            string o = pres + string(pres.rbegin() + (l & 1), pres.rend());
            list.push_back(stol(o));
        }
        return list;
    }

    string nearestPalindromic(string str) {
        long n = stol(str), ans = -1;
        const vector<long>& list = getlist(str);
        for (auto& i : list) {
            if (i != n) {
                long a1 = abs(i - n), a2 = abs(ans - n);
                if (ans == -1 || a1 < a2 || a1 == a2 && i < ans) 
                    ans = i;
            }
        }
        return to_string(ans);
    }
};

 

20220303 258. 各位相加

方法一：暴力回溯

class Solution {
public:
    int work(int num) {
        if (num < 10) return num;
        int res = 0;
        while (num)
            res += num % 10, num /= 10;
        return work(res);
    }
    
    int addDigits(int num) {
        return work(num); 
    }
};

方法二：规律

由于数据范围在 int 内，num 的位数不会超过 10，则在第一次相加后得到的 num 必然在 100 以内，所以我考虑用方法一打出 100 以内的表，这样就最多只需要一次相加。

实际上这也并非题目要求的 O(1)，但打完表之后我们惊喜地发现，结果是 1 ~ 9 的循环，答案也就不言而喻了。

class Solution {
public:
    int addDigits(int num) {
        return (num - 1) % 9 + 1; 
    }
};

 

20220304 2104. 子数组范围和

在写线段树的我是真的没救了（

方法一：暴力枚举

class Solution {
public:
    long long subArrayRanges(vector<int>& a) {
        long long n = a.size(), ans = 0;
        for (int i = 0; i < n; i++) {
            int mx = a[i], mi = a[i];
            for (int j = i + 1; j < n; j++) {
                mx = max(mx, a[j]);
                mi = min(mi, a[j]);
                ans += mx - mi;
            }    
        }        
        return ans;
    }
};

方法二：单调栈

假设区间 i ∈ [j, k] 中，且 a[i] 是区间所有元素中的最大值，则该数对最后的范围和贡献了 a[i] * (i - j) * (k - i)；同理如果是最小值，则贡献值取负。

如何求得上述区间？当且仅当 [j, i - 1] ∪ [i + 1, k] 所有元素均 < a[i]，且 a[j - 1] > a[i], a[k + 1] > a[i]，即分别求左右侧距离 a[i] 最近的比 a[i] 大的元素。

求最近元素采用：单调栈。单调栈的特点就是栈里保存的元素是有序的，举个例子，对于 [6, 4, 3, 5, 4, 2]，找最近的比目标大的元素：

入栈 6；当前栈顶为 6，比 4 大，记录，入栈 4；当前栈顶为 4，比 3 大，记录，入栈 3；当前栈顶为 3，比 5 小，出栈；为 4，比 5 小，出栈；为 6，比 5 大，记录，入栈 5……以此类推。

不难发现这个过程中，栈始终会保持从栈顶到栈底的元素依次递减，这种栈被称之为单调栈。

class Solution {
public:
    long long subArrayRanges(vector<int>& a) {
        int n = a.size();
        long long ans = 0;
        stack<int> s1, s2;
        vector<int> mil(n), mxl(n), mir(n), mxr(n);
        for (int i = 0; i < n; i++) {
            while (!s1.empty() && a[s1.top()] > a[i])
                s1.pop();
            mil[i] = s1.empty() ? -1 : s1.top();
            s1.push(i);
            while (!s2.empty() && a[s2.top()] <= a[i])
                s2.pop();
            mxl[i] = s2.empty() ? -1 : s2.top();
            s2.push(i);
        }
        s1 = s2 = stack<int>();
        for (int i = n - 1; i >= 0; i--) {
            while (!s1.empty() && a[s1.top()] >= a[i])
                s1.pop();
            mir[i] = s1.empty() ? n : s1.top();
            s1.push(i);
            while (!s2.empty() && a[s2.top()] < a[i])
                s2.pop();
            mxr[i] = s2.empty() ? n : s2.top();
            s2.push(i);
        }
        for (int i = 0; i < n; i++)
            ans += (long long)a[i] * (long long)((i - mxl[i]) * (mxr[i] - i) - (i - mil[i]) * (mir[i] - i));
        return ans;
    }
};

细节：元素可能相等，可以对其中一侧允许包含相等，另一侧不允许。

 

20220305 521. 最长特殊序列 I

方法：脑筋急转弯

class Solution {
public:
    int findLUSlength(string a, string b) {
        return a == b ? -1 : max(a.size(), b.size());
    }
};

 

20220306 2100. 适合打劫银行的日子

方法：前缀和（LC官方写的是动态规划）

class Solution {
public:
    vector<int> goodDaysToRobBank(vector<int>& a, int t) {
        int n = a.size();
        vector<int> dec(n);
        vector<int> inc(n);
        for (int i = 1; i < n; i++) {
            if (a[i] <= a[i - 1])
                dec[i] = dec[i - 1] + 1;
            if (a[n - i - 1] <= a[n - i])
                inc[n - i - 1] = inc[n - i] + 1;
        }
        vector<int> ans;
        for (int i = t; i < n - t; i++) {
            if (dec[i] >= t && inc[i] >= t) {
                ans.emplace_back(i);
            }
        }
        return ans;
    }
};

 

20220307 504. 七进制数

class Solution {
public:
    string convertToBase7(int num) {
        string ans;
        int x;
        if (num < 0) num = -num, ans.push_back('-');
        for (x = 1; x * 7 <= num; x *= 7);
        while (x) {
            int o = 0, i;
            for (i = 0; o + x <= num; i++, o += x);
            num -= o, x /= 7, ans.push_back((char)i + '0');
        } 
        return ans;
    }
};

 

20220308 2055. 蜡烛之间的盘子

方法：预处理前缀和

看起来像 DP，但其实不需要，预处理出每个位置左右侧最近的蜡烛位置以及前 i 个位置的蜡烛个数即可。

class Solution {
public:
    vector<int> platesBetweenCandles(string s, vector<vector<int>>& q) {
        int len = s.length();
        vector<int> ans, l(len), r(len), sum(len);
        sum[0] = s[0] == '|', l[0] = s[0] == '|' ? 0 : -1;
        for (int i = 1; i < len; i++) {
            sum[i] = sum[i - 1] + (s[i] == '|');
            l[i] = s[i] == '|' ? i : l[i - 1];
        }
        r[len - 1] = s[len - 1] == '|' ? len - 1 : -1;
        for (int i = len - 2; i >= 0; i--)
            r[i] = s[i] == '|' ? i : r[i + 1];
        int tot = q.size();
        for (int i = 0; i < tot; i++)
            if (l[q[i][1]] == -1 || r[q[i][0]] == -1) ans.push_back(0); 
            else ans.push_back(max(0, l[q[i][1]] - r[q[i][0]] + 1 - sum[q[i][1]] + (q[i][0] == 0 ? 0 : sum[q[i][0] - 1])));
        return ans;
    }
};

 

20220309 798. 得分最高的最小轮调

方法：差分数组

对于元素 a[i] = x，当其轮调后的新下标 j >= x 时，会得到 1 分，即得分下标范围为 [x, n - 1]，共 n - x 个；不得分范围为 [0, x - 1]，共 x 个。

由于其初始下标为 i，轮调下标为 k，则新下标 j = (i - k + n) mod n，当且仅当 (i - k + n) mod n >= x 时得分，等价于 k <= (i - x + n) mod n；又得分下标共  n - x 个，故 k >= (i + 1) mod n。

综上，当 i < x 时，i + 1 <= k <= i - x + n；当 i >= x 时，k >= i + 1 或 k <= i - x。

创建数组 points，points[k] 表示轮调下标为 k 时的得分。对于 nums 的每个元素，直接将 points 的对应的得分下标范围所有元素 +1。完成后求得 points 中的最大值即可。这个过程本身和暴力一样也是 O(n ^ 2)，但是由于所有的操作都是范围操作，使用差分数组即可降维。

比如针对 i < x，我们需要将 [i + 1, i - x + n] 所有元素 +1，定义差分数组 diffs[k] = points[k] - points[k - 1]，直接 diffs[i + 1]++, diffs[i - x + n]-- 即可，最后计算 diffs 的前缀和，即可还原 points 的数据。

记得取模。

class Solution {
public:
    int bestRotation(vector<int>& nums) {
        int n = nums.size(), ans = 0, sum = 0, mx = 0;
        vector<int> diffs(n);
        for (int i = 0; i < n; i++) {
            int l = (i + 1) % n, r = (i - nums[i] + n + 1) % n;
            diffs[l]++, diffs[r]--; 
            if (l >= r) diffs[0]++;
        }
        for (int i = 0; i < n; i++)
            if (mx < (sum += diffs[i]))
                mx = sum, ans = i;
        return ans;
    }
};

 

20220310. N 叉树的前序遍历

class Solution {
public:
    void dfs(const Node* root, vector<int> & res) {
        if (root == nullptr) {
            return;
        }
        res.emplace_back(root->val);
        for (auto & ch : root->children) {
            dfs(ch, res);
        }
    }

    vector<int> preorder(Node* root) {
        vector<int> res;
        dfs(root, res);
        return res;
    }
};

 

20220311 2049. 统计最高分的节点数目

方法：DFS

题目第一眼看起来好麻烦，其实其得分乘积很容易得出：左子树结点数 * 右子树结点数 * (总结点数 - 以该结点为根的子树结点数)，把父结点关系数组转化为左右子树关系后再 DFS 就很容易求出来了。

const int N = 1e5 + 5;

class Solution {
    long long l[N], r[N], tl[N], tr[N], b[N];
public:
    int dfs(int o) {
        if (!tl[o]) return 1;
        l[o] = dfs(tl[o]);
        if (tr[o]) r[o] = dfs(tr[o]);
        return l[o] + r[o] + 1;
    }
    int countHighestScoreNodes(vector<int>& p) {
        int n = p.size(), ans;
        long long mx = 0;
        for (int i = 1; i < n; i++)
            if (tl[p[i]]) tr[p[i]] = i;
            else tl[p[i]] = i;
        int root = dfs(0);
        for (int i = 0 ; i < n; i++) {
            for (auto &j : {&l[i], &r[i], &(b[i] = root - l[i] - r[i] - 1)})
                if (!*j) *j = 1; 
            long long res = l[i] * r[i] * b[i];
            if (res > mx) mx = res, ans = 1;
            else if (res == mx) ans++;
        }
        return ans;
    }
} s;

其实求最大值的这个循环可以直接在 DFS 中完成，因为显然 DFS 每个结点也有且仅有一次遍历，在 return 前就可以进行比较了。

 

20220312 590. N 叉树的后序遍历

class Solution {
public:
    void helper(const Node* root, vector<int> & res) {
        if (root == nullptr) {
            return;
        }
        for (auto & ch : root->children) {
            helper(ch, res);
        }
        res.emplace_back(root->val);
    }

    vector<int> postorder(Node* root) {
        vector<int> res;
        helper(root, res);
        return res;
    }
};

 

20220313 393. UTF-8 编码验证

class Solution {
public:
    bool validUtf8(vector<int>& data) {
        int cnt = 0;
        for(int x : data) {
            if((x >> 7) & 1) {
                if((x >> 6) & 1) {
                    if((x >> 5) & 1) {
                        if((x >> 4) & 1) {
                            if((x >> 3) & 1) {
                                return false;
                            } else {
                                if(cnt) {
                                    return false;
                                }
                                cnt = 3;
                            }
                        } else {
                            if(cnt) {
                                return false;
                            }
                            cnt = 2;
                        }
                    } else {
                        if(cnt) {
                            return false;
                        }
                        cnt = 1;
                    }
                } else {
                    cnt--;
                }
            } 
        }

        return cnt == 0;
    }
};

 

 

22020314 599. 两个列表的最小索引总和

class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        unordered_map<string, int> index;
        for (int i = 0; i < list1.size(); i++) {
            index[list1[i]] = i;
        }

        vector<string> ret;
        int indexSum = INT_MAX;
        for (int i = 0; i < list2.size(); i++) {
            if (index.count(list2[i]) > 0) {
                int j = index[list2[i]];
                if (i + j < indexSum) {
                    ret.clear();
                    ret.push_back(list2[i]);
                    indexSum = i + j;
                } else if (i + j == indexSum) {
                    ret.push_back(list2[i]);
                }
            }
        }
        return ret;
    }
};

 

20220315 2044. 统计按位或能得到最大值的子集数目

class Solution {
public:
    int countMaxOrSubsets(vector<int> const& nums) {
        const int n = nums.size(), maxsum = accumulate(nums.begin(), nums.end(), 0, bit_or<int>{});
        const auto dfs = [&] (auto&& dfs, int p = 0, int sum = 0) {
            if (sum == maxsum) return 1 << (n - p);
            if (n == p) return 0;
            assert(p < n);
            return dfs(dfs, p + 1, sum) + dfs(dfs, p + 1, sum | nums[p]);
        };
        return dfs(dfs);
    }
};

 

20220316 432. 全 O(1) 的数据结构

方法：双向链表+哈希

class AllOne {
    list<pair<unordered_set<string>, int>> l;
    unordered_map<string, list<pair<unordered_set<string>, int>> :: iterator> mp; 
public:
    AllOne() {}
    
    void inc(string key) {
        if (mp.count(key)) {
            auto cur = mp[key], nxt = next(cur);
            if (nxt == l.end() || nxt->second > cur->second + 1) {
                unordered_set<string> s({key});
                mp[key] = l.emplace(nxt, s, cur->second + 1);
            }
            else {
                nxt->first.emplace(key);
                mp[key] = nxt;    
            }
            cur->first.erase(key);
            if (cur->first.empty())
                l.erase(cur);
        } else {
            if (l.empty() || l.begin()->second > 1) {
                unordered_set<string> s({key});
                l.emplace_front(s, 1);
            } else {
                l.begin()->first.emplace(key);
            }
            mp[key] = l.begin();    
        }
    }
    
    void dec(string key) {
        auto cur = mp[key];
        if (cur->second == 1) {
            mp.erase(key);
        } else {
            auto pre = prev(cur);
            if (cur == l.begin() || pre->second < cur->second - 1) {
                unordered_set<string> s({key});
                mp[key] = l.emplace(cur, s, cur->second - 1);
            } else {
                pre->first.emplace(key);
                mp[key] = pre;
            }
        }
        cur->first.erase(key);
        if (cur->first.empty()) {
            l.erase(cur);
        }
    }
    
    string getMaxKey() {
        return l.empty() ? "" : *l.rbegin()->first.begin();
    }
    
    string getMinKey() {
        return l.empty() ? "" : *l.begin()->first.begin();
    }
};

 

 

20220317 720. 词典中最长的单词

方法一：排序+哈希

class Solution {
public:
    string longestWord(vector<string>& words) {
        sort(words.begin(), words.end(), [](const string &a, const string &b){
            return a.size() == b.size() ? a > b : a.size() < b.size();
        });
        string ans = "";
        unordered_set<string> s;
        s.emplace("");
        for (auto & word : words) {
            if (s.count(word.substr(0, word.size() - 1))) {
                s.emplace(word);
                ans = word;
            }
        }
        return ans;
    }
};

方法二：Trie 字典树

class Trie {
    vector<Trie*> child;
    bool isEnd;
public:
    Trie() {
        this->child = vector<Trie*>(26, nullptr);
        this->isEnd = 0;
    }
    void insert(const string& word) {
        Trie* node = this;
        for (const auto &ch : word) {
            int o = ch - 'a';
            Trie* nxt = node->child[o]; 
            if (node->child[o] == nullptr)
                node->child[o] = new Trie();
            node = node->child[o];
        }
        node->isEnd = 1;
    }
    bool dfs(const string& word) {
        Trie* node = this;
        for (const auto &ch : word) {
            int o = ch - 'a';
            if (node->child[o] == nullptr || !node->child[o]->isEnd)
                return 0;
            node = node->child[o];
        }
        return node != nullptr && node->isEnd;
    }
};

class Solution {
public:
    string longestWord(vector<string>& words) {
        Trie t;
        for (const auto &word : words)
            t.insert(word);
        string ans = "";
        int mx = 0;
        for (const auto &word : words) {
            int l = word.size();
            if (t.dfs(word))
                if (l > mx || l == mx && word < ans)
                ans = word, mx = l;
        }
        return ans;
    }
};

 

中间因为准备毕设和复试中断了一段时间，现在恢复保护现场。

 

20220329 2024. 考试的最大困扰度

方法：双指针法

和第 3 题差不多，完全不需要用到 DP。

class Solution {
public:
    int work(string s, int k) {
        int l = 0, r = 0, ans = 0, o = 0, len = s.length();
        while (r < len) {
            while (s[r] == 'T') r++;
            while (s[r] == 'F' && o < k)
                r++, o++;
            ans = max(ans, r - l);
            while (o == k && s[r] == 'F')
                if (s[l] == 'F') l++, o--;
                else while (s[l] == 'T') l++;
        }
        return ans;
    }
    int maxConsecutiveAnswers(string s, int k) {
        int len = s.length();
        string t = s;
        for (int i = 0; i < len; i++)
            t[i] = (s[i] == 'F' ? 'T' : 'F');
        return max(work(s, k), work(t, k));   
    }
};

 

20220330 1606. 找到处理最多请求的服务器

方法一：模拟

直接按题意要求，从第 i % k 个服务器开始依次查询是否繁忙，同时维护每个服务器处理请求个数，时间复杂度为 O(n * k)，不满足题意。

方法：优先队列

模拟过程有个问题在于，每次会扫描所有服务器判断是否繁忙，重复操作相当多；

考虑将所有当前繁忙的服务器放入一个优先队列 priority_queue，按照处理结束时间从早到晚排序，每次接收一个新处理时，将所有结束时间早于该新处理开始时间的服务器取出，再放入一个空闲服务器的 set，再从 set 中取出大于 i % k 的服务器（主要服务器是环形，还要考虑绕一圈从服务器 0 开始的情况），这样每次查询都只有 log 的复杂度了，最后时间复杂度为 O(n log n) 或 O(n log k)；

一道不错的 STL 综合运用。

class Solution {
public:
    vector<int> busiestServers(int k, vector<int>& a, vector<int>& l) {
        set<int> avail;
        vector<int> tot(k), ans;
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> busy;
        int n = a.size();
        for (int i = 0; i < k; i++)
            avail.insert(i);
        for (int i = 0; i < n; i++) {
            while (!busy.empty() && busy.top().first <= a[i])
                avail.insert(busy.top().second), busy.pop();
            if (avail.empty())
                continue;
            auto o = avail.lower_bound(i % k);
            if (o == avail.end())
                o = avail.begin();
            tot[*o]++;
            busy.emplace(a[i] + l[i], *o);
            avail.erase(o);
        }
        int mx = *max_element(tot.begin(), tot.end());
        for (int i = 0; i < k; i++)
            if (tot[i] == mx)
                ans.push_back(i);
        return ans;
    }
};

 

20220331 728. 自除数

class Solution {
public:
    vector<int> selfDividingNumbers(int l, int r) {
        vector<int> ans;
        for (int i = l; i <= r; i++) {
            int o = i, x = i, nob = 0;
            while (x) {
                if (!(x % 10) || o % (x % 10)) {
                    nob = 1;
                    break;
                }
                x /= 10;
            }
            if (!nob) ans.push_back(i);
        }
        return ans;
    }
} s;