Posts on My blog

Leetcode-72

Wed, 31 Dec 2025 10:28:15 -0800

Time complexity: $O(mn)$

#include <iostream>
#include <cstring>
#include <vector>
#include <numeric>

class Solution {
public:
    int minDistance(std::string word1, std::string word2) {
        int m = word1.length();
        int n = word2.length();
        std::vector<int> dp(n + 1);
        std::iota(dp.begin(), dp.end(), 0);
        
        for (int i = 1; i <= m; ++i) {
            int tmp = dp[0], tmp2;
            dp[0] = i;
            for (int j = 1; j <= n; ++j) {
                tmp2 = dp[j];
                dp[j] = std::min(dp[j], dp[j - 1]) + 1;
                if (word1[i - 1] == word2[j - 1]) {
                    dp[j] = std::min(dp[j], tmp);
                }
                else {
                    dp[j] = std::min(dp[j], tmp + 1);
                }
                std::swap(tmp, tmp2);
            }
        }
        
        return dp.back();
    }
};

Leetcode-210

Sun, 30 Nov 2025 02:04:56 -0800

#include <iostream>
#include <vector>
#include <queue>

class Solution {
public:
    std::vector<int> findOrder(int numCourses, std::vector<std::vector<int>>& prerequisites) {
        std::vector<int> res;
        std::vector<int> inDegree(numCourses, 0);
        std::vector<std::vector<int>> adj(numCourses);
        for (auto& e : prerequisites) {
            adj[e[1]].push_back(e[0]);
        }
        for (auto& course : adj) {
            for (auto& v : course) {
                ++inDegree[v];
            }
        }
        
        std::queue<int> q;
        for (int i = 0; i < numCourses; ++i) {
            if (inDegree[i] == 0) {
                q.push(i);
            }
        }
        
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            res.push_back(u);
            for (auto& v : adj[u]) {
                --inDegree[v];
                if (inDegree[v] == 0) {
                    q.push(v);
                }
            }
        }
        
        if (res.size() != numCourses) {
            return {};
        }
        return res;
    }
};

Leetcode-229

Sun, 07 Dec 2025 01:34:10 -0800

#include <iostream>
#include <vector>

class Solution {
public:
    std::vector<int> majorityElement(std::vector<int>& nums) {
        int num1, num2;
        int cnt1 = 0, cnt2 = 0;
        for (auto& n : nums) {
            if (cnt1 == 0) {
                num1 = n;
                cnt1 = 1;
            }
            else if (num1 == n) {
                ++cnt1;
            }
            else if (cnt2 == 0) {
                num2 = n;
                cnt2 = 1;
            }
            else if (num2 == n) {
                ++cnt2;
            }
            else {
                --cnt1;
                --cnt2;
                if (cnt1 == 0) {
                    std::swap(cnt1, cnt2);
                    std::swap(num1, num2);
                }
            }
        }
        
        cnt1 = cnt2 = 0;
        for (auto& n : nums) {
            if (n == num1) {
                ++cnt1;
            }
            else if (n == num2) {
                ++cnt2;
            }
        }
        
        int n = nums.size() / 3;
        std::vector<int> res;
        if (cnt1 > n) {
            res.push_back(num1);
        }
        if (cnt2 > n) {
            res.push_back(num2);
        }
        
        return res;
    }
};

Leetcode-279

Mon, 29 Dec 2025 15:07:51 -0800

Time complexity: $O(n^\frac{3}{2})$

#include <iostream>
#include <vector>
#include <numeric>

class Solution {
public:
    int numSquares(int n) {
        int dp[10001];
        std::iota(dp, dp + n + 1, 0);
        
        int b = 1;
        while (true) {
            ++b;
            int s = b * b;
            if (s > n) {
                break;
            }
            for (int i = s; i <= n; ++i) {
                dp[i] = std::min(dp[i], dp[i - s] + 1);
            }
        }
        
        return dp[n];
    }
};

Leetcode-298

Mon, 15 Dec 2025 11:21:54 -0800

298. Binary Tree Longest Consecutive Sequence

Difficulty: Medium

Given the root of a binary tree, return the length of the longest consecutive sequence path.

A consecutive sequence path is a path where the values increase by one along the path.

Note that the path can start at any node in the tree, and you cannot go from a node to its parent in the path.

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int longestConsecutive(TreeNode* root) {
        DFS(root);
        return maxlen_;
    }

private:
    int DFS(TreeNode* node) {
        int left = 0, right = 0;
        if (node->left != nullptr) {
            if (node->left->val == node->val + 1) {
                left = DFS(node->left);
            }
            else {
                DFS(node->left);
            }
        }
        if (node->right != nullptr) {
            if (node->right->val == node->val + 1) {
                right = DFS(node->right);
            }
            else {
                DFS(node->right);
            }
        }
        int res = 1 + std::max(left, right);
        maxlen_ = std::max(maxlen_, res);
        return res;
    }
    
    int maxlen_ = 0;
};

Leetcode-301

Sat, 29 Nov 2025 22:42:44 -0800

#include <iostream>
#include <vector>
#include <cstring>
#include <unordered_set>

class Solution {
    int rmPar(std::string& str) {
        int lrm = 0, rrm = 0;
        for (auto& c : str) {
            if (c == '(') {
                ++lrm;
            }
            if (c == ')') {
                if (lrm > 0) {
                    --lrm;
                }
                else {
                    ++rrm;
                }
            }
        }
        return lrm + rrm;
    }
    
public:
    std::vector<std::string> removeInvalidParentheses(std::string s) {
        std::vector<std::string> res;
        int n = rmPar(s);
        if (n == 0) {
            res.push_back(s);
            return res;
        }
        std::queue<std::pair<std::string, int>> q;
        q.push({s, n});
        std::unordered_set<std::string> visited;
        
        while (!q.empty()) {
            std::string s = q.front().first;
            n = q.front().second;
            q.pop();
            for (int i = 0; i < s.length(); ++i) {
                std::string next = s;
                next.erase(i, 1);
                if (visited.count(next)) {
                    continue;
                }
                visited.insert(next);
                int nn = rmPar(next);
                if (nn >= n) {
                    continue;
                }
                if (nn == 0) {
                    res.push_back(next);
                }
                else {
                    q.push({next, nn});
                }
            }
        }
        return res;
    }
};

Leetcode-315

Sat, 06 Dec 2025 14:39:49 -0800

#include <iostream>
#include <vector>
#include <algorithm>

class Solution {
public:
    std::vector<int> countSmaller(std::vector<int>& nums) {
        nums = Discretize(nums);
        int n = nums.size();
        tree_.resize(n + 1, 0);
        
        std::vector<int> res;
        res.reserve(n);
        
        for (int i = n - 1; i >= 0; --i) {
            res.push_back(Query(nums[i] - 1));
            Add(nums[i], 1);
        }
        
        std::reverse(res.begin(), res.end());
        return res;
    }
    
private:
    static int LowBit(int x) {
        return x & (-x);
    }
    
    void Add(int idx, int delta) {
        while (idx < tree_.size()) {
            tree_[idx] += delta;
            idx += LowBit(idx);
        }
    }
    
    int Query(int idx) const {
        int sum = 0;
        while (idx > 0) {
            sum += tree_[idx];
            idx -= LowBit(idx);
        }
        return sum;
    }
    
    std::vector<int> Discretize(const std::vector<int>& nums) {
        std::vector<int> sorted_nums(nums);
        std::sort(sorted_nums.begin(), sorted_nums.end());
        auto last = std::unique(sorted_nums.begin(), sorted_nums.end());
        sorted_nums.erase(last, sorted_nums.end());
        
        std::vector<int> ranks;
        ranks.reserve(nums.size());
        
        for (int num : nums) {
            int rank = std::lower_bound(sorted_nums.begin(), sorted_nums.end(), num) - sorted_nums.begin();
            ranks.push_back(rank + 1);
        }
        
        return ranks;
    }
    
    std::vector<int> tree_;
};

Leetcode-474

Fri, 26 Dec 2025 21:37:41 -0800

Time complexity: $O(mn|strs|)$

#include <iostream>
#include <vector>
#include <cstring>

class Solution {
public:
    int findMaxForm(std::vector<std::string>& strs, int m, int n) {
        std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1));
        for (std::string& str : strs) {
            int a = 0, b = 0;
            for (char c : str) {
                if (c == '0') {
                    ++a;
                }
                else {
                    ++b;
                }
            }
            for (int i = m; i >= a; --i) {
                for (int j = n; j >= b; --j) {
                    dp[i][j] = std::max(dp[i][j], 1 + dp[i - a][j - b]);
                }
            }
        }
        return dp.back().back();
    }
};

Leetcode-475

Tue, 23 Dec 2025 14:33:03 -0800

Time complexity: $O((m+n)\log n)$

#include <iostream>
#include <vector>
#include <algorithm>

class Solution {
public:
    int findRadius(std::vector<int>& houses, std::vector<int>& heaters) {
        std::sort(heaters.begin(), heaters.end());
        int n = heaters.size();
        int max_dist = 0, dist;
        for (int house : houses) {
            int j = std::lower_bound(heaters.begin(), heaters.end(), house) - heaters.begin();
            dist = 0x3fff'ffff;
            if (j < n) {
                dist = heaters[j] - house;
            }
            if (j) {
                dist = std::min(dist, house - heaters[j - 1]);
            }
            max_dist = std::max(dist, max_dist);
        }
        return max_dist;
    }
};

Leetcode-518

Mon, 29 Dec 2025 15:06:35 -0800

Time complexity: $O(nk)$

#include <iostream>
#include <vector>

class Solution {
public:
    int change(int amount, std::vector<int>& coins) {
        std::vector<long long> dp(amount + 1);
        dp[0] = 1;
        for (int c : coins) {
            for (int i = c; i <= amount; ++i) {
                dp[i] += dp[i - c];
                dp[i] &= 0x7fff'ffff;
            }
        }
        return dp.back();
    }
};

Leetcode-547

Wed, 26 Nov 2025 19:00:13 -0800

#include <iostream>
#include <vector>
#include <numeric>

struct DSU {
    std::vector<int> size;
    std::vector<int> parent;
    int count;
    
    DSU(int n) {
        size.resize(n, 1);
        parent.resize(n);
        std::iota(parent.begin(), parent.end(), 0);
        count = n;
    }
    
    int find(int i) {
        if (parent[i] == i) {
            return i;
        }
        parent[i] = find(parent[i]);
        return parent[i];
    }
    
    void unite(int i, int j) {
        int ii = find(i);
        int jj = find(j);
        if (ii != jj) {
            --count;
            if (size[ii] < size[jj]) {
                std::swap(ii, jj);
            }
            parent[jj] = ii;
            size[ii] += size[jj];
        }
    }
};

class Solution {
public:
    int findCircleNum(vector<vector<int>>& isConnected) {
        int n = isConnected.size();
        DSU dsu(n);
        for (int i = 0; i < n - 1; ++i) {
            for (int j = i + 1; j < n; ++j) {
                if (isConnected[i][j] == 1) {
                    dsu.unite(i, j);
                }
            }
        }
        return dsu.count;
    }
};

Leetcode-718

Wed, 31 Dec 2025 10:32:36 -0800

Time complexity: $O(mn)$

#include <iostream>
#include <vector>
#include <algorithm>

class Solution {
public:
    int findLength(std::vector<int>& nums1, std::vector<int>& nums2) {
        int m = nums1.size();
        int n = nums2.size();
        if (m < n) {
            std::swap(nums1, nums2);
            std::swap(m, n);
        }
        std::vector<int> dp(n + 1, 0);
        int res = 0;
        
        for (int num : nums1) {
            for (int i = n; i > 0; --i) {
                if (nums2[i -  1] == num) {
                    dp[i] = 1 + dp[i - 1];
                    res = std::max(res, dp[i]);
                }
                else {
                    dp[i] = 0;
                }
            }
        }
        
        return res;
    }
};

Leetcode-752

Sat, 29 Nov 2025 22:09:48 -0800

#include <iostream>
#include <vector>
#include <queue>
#include <cstring>

const int INF = 10000;
const int DEAD = 10001;

class Solution {
    int met(std::string str) {
        int res = 0;
        for (auto& c : str) {
            res *= 10;
            res += (c - '0');
        }
        return res;
    }
    
public:
    int openLock(std::vector<std::string>& deadends, std::string target) {
        std::vector<int> dist(10000, INF);
        int start = 0;
        start = met(target);
        if (start == 0) {
            return 0;
        }
        
        for (auto& str : deadends) {
            dist[met(str)] = DEAD;
        }
        std::queue<int> q;
        q.push(start);
        dist[start] = 0;
        int mods[] = { 1, 10, 100, 1000 };
        int dirs[] = { 1, 9 };
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            for (auto& m : mods) {
                for (auto& dir : dirs) {
                    int r = u / (m * 10) * m * 10;
                    int v = (dir * m + (u - r)) % (m * 10) + r;
                    if (dist[v] == DEAD) {
                        continue;
                    }
                    if (v == 0) {
                        return dist[u] + 1;
                    }
                    if (dist[v] == INF) {
                        dist[v] = dist[u] + 1;
                        q.push(v);
                    }
                }
            }
        }
        return -1;
    }
};

Leetcode-773

Sat, 29 Nov 2025 21:40:20 -0800

#include <iostream>
#include <vector>
#include <queue>
#include <cstring>
#include <unordered_set>

class Solution {
public:
    int slidingPuzzle(std::vector<std::vector<int>>& board) {
        std::string start = "";
        int p = 0;
        for (auto& row : board) {
            for (auto& c : row) {
                start += (c + '0');
            }
        }
        if (start == "123450") {
            return 0;
        }
        for (int i = 0; i < 6; ++i) {
            if (start[i] == '0') {
                p = i;
                break;
            }
        }
        
        std::vector<std::vector<int>> dirs = {{1, 3}, {0, 2, 4}, {1, 5}, {0, 4}, {1, 3, 5}, {2, 4}};
        std::unordered_set<std::string> visited = { start };
        std::queue<std::pair<std::string, std::pair<int, int>>> q;
        q.push({start, {0, p}});
        while (!q.empty()) {
            std::string u = q.front().first;
            int d = q.front().second.first;
            int p = q.front().second.second;
            q.pop();
            for (auto& v : dirs[p]) {
                std::swap(u[p], u[v]);
                if (!visited.count(u)) {
                    if (u == "123450") {
                        return d + 1;
                    }
                    q.push({u, {d + 1, v}});
                    visited.insert(u);
                }
                std::swap(u[p], u[v]);
            }
        }
        return -1;
    }
};

Leetcode-778

Tue, 23 Dec 2025 20:17:09 -0800

Time complexity: $O(n^2\log n)$

#include <iostream>
#include <vector>
#include <queue>
#include <functional>

typedef std::pair<int, std::pair<int, int>> PIPII;

class Solution {
public:
    int swimInWater(std::vector<std::vector<int>>& grid) {
        int n = grid.size();
        std::vector<std::vector<int>> dist(n, std::vector<int>(n, 0x3fff'ffff));
        std::priority_queue<PIPII, std::vector<PIPII>, std::greater<PIPII>> pq;
        
        dist[0][0] = grid[0][0];
        pq.push({dist[0][0], {0, 0}});
        int dirs[4][2] = { {1, 0}, {0, 1}, {-1, 0}, {0, -1} };
        
        while (!pq.empty()) {
            int d = pq.top().first;
            int x = pq.top().second.first;
            int y = pq.top().second.second;
            pq.pop();
            if (x == n - 1 && y == n - 1) {
                return d;
            }
            if (d > dist[x][y]) {
                continue;
            }
            
            for (auto& dir : dirs) {
                int xx = x + dir[0];
                int yy = y + dir[1];
                if (xx >= 0 && xx < n && yy >= 0 && yy < n) {
                    int nd = std::max(d, grid[xx][yy]);
                    if (nd < dist[xx][yy]) {
                        dist[xx][yy] = nd;
                        pq.push({nd, {xx, yy}});
                    }
                }
            }
        }
        
        return -1;
    }
};

Leetcode-785

Fri, 05 Dec 2025 20:37:19 -0800

#include <iostream>
#include <queue>
#include <vector>

class Solution {
public:
    bool isBipartite(std::vector<std::vector<int>>& graph) {
        int n = graph.size();
        std::vector<int> color(n, 0);
        std::queue<int> q;
        
        for (int i = 0; i < n; ++i) {
            if (color[i] != 0) {
                continue;
            }
            color[i] = 1;
            q.push(i);
            
            while (!q.empty()) {
                int u = q.front();
                q.pop();
                for (auto& v : graph[u]) {
                    if (color[v] == color[u]) {
                        return false;
                    }
                    if (color[v] == 0) {
                        q.push(v);
                    }
                    color[v] = -color[u];
                }
            }
        }
        
        return true;
    }
};

Leetcode-797

Wed, 26 Nov 2025 21:13:14 -0800

#include <iostream>
#include <vector>

class Solution {
    void DFS(int n, int i, std::vector<int>& path, 
            std::vector<std::vector<int>>& graph, std::vector<std::vector<int>>& res) {
        path.push_back(i);
        if (i == n - 1) {
            res.push_back(path);
        }
        for (auto& j : graph[i]) {
            DFS(n, j, path, graph, res);
        }
        path.pop_back();
    }
    
public:
    std::vector<std::vector<int>> allPathsSourceTarget(std::vector<std::vector<int>>& graph) {
        int n = graph.size();
        std::vector<std::vector<int>> res;
        std::vector<int> path;
        path.reserve(n);
        DFS(n, 0, path, graph, res);
        return res;
    }
};

Leetcode-802

Mon, 01 Dec 2025 01:04:10 -0800

#include <iostream>
#include <vector>

const int UNVISITED = 0;
const int VISITED = 1;
const int SAFE = 2;

class Solution {
    bool DFS(int i, std::vector<int>& state, std::vector<std::vector<int>>& graph) {
        if (state[i] != UNVISITED) {
            return state[i] == SAFE;
        }
        state[i] = VISITED;
        for (auto j : graph[i]) {
            if (!DFS(j, state, graph)) {
                return false;
            }
        }
        state[i] = SAFE;
        return true;
    }
        
public:
    std::vector<int> eventualSafeNodes(std::vector<std::vector<int>>& graph) {
        int n = graph.size();
        std::vector<int> state(n, UNVISITED);
        std::vector<int> res;
        res.reserve(n);
        for (int i = 0; i < n; ++i) {
            if (DFS(i, state, graph)) {
                res.push_back(i);
            }
        }
        return res;
    }
};

Leetcode-875

Tue, 23 Dec 2025 14:28:42 -0800

Time complexity: $O(n\log M)$

#include <iostream>
#include <vector>

class Solution {
public:
    int minEatingSpeed(std::vector<int>& piles, int h) {
        int n = piles.size();
        
        int left = 1, right = 0;
        for (int i : piles) {
            right = std::max(i, right);
        }
        h -= n;
        if (h == 0) {
            return right;
        }
        
        for (int mid = (left + right) / 2; right > left;) {
            if (check(piles, h, mid)) {
                right = mid;
            }
            else {
                left = mid + 1;
            }
            mid = (left + right) / 2;
        }
        
        return left;
    }
    
private:
    bool check(std::vector<int> piles, int h, int speed) {
        for (int i : piles) {
            h -= (i - 1) / speed;
            if (h < 0) {
                return false;
            }
        }
        return true;
    }
};

Leetcode-879

Fri, 26 Dec 2025 21:44:07 -0800

Time complexity: $O(mn\cdot Minprofit)$

#include <iostream>
#include <vector>

const int M = 1'000'000'007;

class Solution {
public:
    int profitableSchemes(int n, int minProfit, std::vector<int>& group, std::vector<int>& profit) {
        int m = group.size();
        std::vector<std::vector<int>> dp(n + 1, std::vector<int>(minProfit + 1));
        
        dp[0][0] = 1;
        for (int s = 0; s < m; ++s) {
            for (int i = n; i >= group[s]; --i) {
                for (int j = minProfit; j >= 0; --j) {
                    dp[i][j] = (dp[i][j] + dp[i - group[s]][std::max(0, j - profit[s])]) % M;
                }
            }
        }
        
        long long sum = 0;
        for (int i = 0; i <= n; ++i) {
            sum += dp[i].back();
        }
        
        return sum % M;
    }
};

Leetcode-886

Fri, 05 Dec 2025 21:26:56 -0800

#include <iostream>
#include <vector>
#include <queue>

class Solution {
public:
    bool possibleBipartition(int n, std::vector<std::vector<int>>& dislikes) {
        std::vector<std::vector<int>> adj(n);
        for (auto& e : dislikes) {
            adj[e[0] - 1].push_back(e[1] - 1);
            adj[e[1] - 1].push_back(e[0] - 1);
        }
        
        std::vector<int> color(n, 0);
        std::queue<int> q;
        for (int i = 0; i < n; ++i) {
            if (color[i] != 0) {
                continue;
            }
            
            color[i] = 1;
            q.push(i);
            while (!q.empty()) {
                int u = q.front();
                q.pop();
                for (int& v : adj[u]) {
                    if (color[v] == 0) {
                        color[v] = -color[u];
                        q.push(v);
                    }
                    else if (color[u] == color[v]) {
                        return false;
                    }
                }
            }
        }
        
        return true;
    }
};

Leetcode-911

Tue, 23 Dec 2025 14:14:41 -0800

Time complexity: $O(\log N)$

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>

class TopVotedCandidate {
public:
    TopVotedCandidate(std::vector<int>& persons, std::vector<int>& times) {
        int n = persons.size();
        tops.resize(n);
        times_ = times;
        std::unordered_map<int, int> votes;
        
        int top = -1;
        for (int i = 0; i < n; ++i) {
            ++votes[persons[i]];
            if (votes[persons[i]] >= votes[top]) {
                top = persons[i];
            }
            tops[i] = top;
        }
    }
    
    int q(int t) {
        auto it = std::lower_bound(times_.begin(), times_.end(), t + 1);
        if (it == times_.begin()) {
            return tops[0];
        }
        return tops[it - times_.begin() - 1];
    }
    
private:
    std::vector<int> tops;
    std::vector<int> times_;
};

/**
 * Your TopVotedCandidate object will be instantiated and called as such:
 * TopVotedCandidate* obj = new TopVotedCandidate(persons, times);
 * int param_1 = obj->q(t);
 */

Leetcode-956

Mon, 29 Dec 2025 12:27:30 -0800

Time complexity: $O(n\cdot\max(rods))$

#include <iostream>
#include <vector>

class Solution {
public:
    int tallestBillboard(std::vector<int>& rods) {
        int sum = 0;
        for (int r : rods) {
            sum += r;
        }
        std::vector<int> dp(sum + 1, -1);
        dp[0] = 0;
        
        for (int r : rods) {
            std::vector<int> tmp(dp);
            for (int j = 0; j <= sum; ++j) {
                if (tmp[j] < 0) {
                    continue;
                }
                if (j + r <= sum) {
                    dp[j + r] = std::max(dp[j + r], tmp[j] + r);
                }
                dp[std::abs(j - r)] = std::max(dp[std::abs(j - r)], std::max(tmp[j], tmp[j] - j + r));
            }
        }
        
        return dp[0];
    }
};

Leetcode-1011

Tue, 23 Dec 2025 14:26:14 -0800

Time complexity: $O(n\log M)$

#include <iostream>
#include <vector>

class Solution {
public:
    int shipWithinDays(std::vector<int>& weights, int days) {
        int left = 0, right = 0;
        for (int w : weights) {
            left = std::max(left, w);
            right += w;
        }
        
        if (days >= weights.size()) {
            return left;
        }
        
        for (int mid = (left + right) / 2; right > left;) {
            if (check(weights, days, mid)) {
                right = mid;
            }
            else {
                left = mid + 1;
            }
            mid = (left + right) / 2;
        }
        
        return left;
    }
    
private:
    bool check(std::vector<int>& weights, int days, int cap) {
        int cur = 0;
        
        for (int weight : weights) {
            cur += weight;
            if (cur > cap) {
                cur = weight;
                if (!(--days)) {
                    return false;
                }
            }
        }
        
        return true;
    }
};

Leetcode-1035

Wed, 31 Dec 2025 10:29:47 -0800

Time complexity: $O(mn)$

#include <iostream>
#include <vector>

class Solution {
public:
    int maxUncrossedLines(std::vector<int>& nums1, std::vector<int>& nums2) {
        int m = nums1.size();
        int n = nums2.size();
        std::vector<int> dp(n + 1);
        
        for (int i = 1; i <= m; ++i) {
            int tmp = 0, tmp2;
            for (int j = 1; j <= n; ++j) {
                tmp2 = dp[j];
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[j] = tmp + 1;
                }
                else {
                    dp[j] = std::max(dp[j], dp[j - 1]);
                }
                std::swap(tmp, tmp2);
            }
        }
        
        return dp.back();
    }
};

Leetcode-1186

Thu, 25 Dec 2025 22:30:36 -0800

Time complexity: $O(n)$

#include <iostream>
#include <vector>
#include <cmath>

class Solution {
public:
    int maximumSum(std::vector<int>& arr) {
        int n = arr.size();
        std::vector<std::pair<int, int>> dp(n);
        dp[0] = {arr[0], arr[0]};
        
        int max_sum = arr[0];
        for (int i = 1; i < n; ++i) {
            dp[i].first = std::max(0, dp[i - 1].first) + arr[i];
            dp[i].second = std::max(0, dp[i - 1].second) + arr[i];
            dp[i].second = std::max(dp[i - 1].first, dp[i].second);
            max_sum = std::max(max_sum, dp[i].second);
        }
        
        return max_sum;
    }
};

Leetcode-1192

Sat, 06 Dec 2025 01:44:17 -0800

#include <iostream>
#include <vector>
#include <stack>

class Solution {
public:
    std::vector<std::vector<int>> criticalConnections(int n, std::vector<std::vector<int>>& connections) {
        adj_.resize(n);
        for (std::vector<int>& e : connections) {
            adj_[e[0]].push_back(e[1]);
            adj_[e[1]].push_back(e[0]);
        }
        
        dfn_.resize(n, -1);
        low_.resize(n, -1);
        timer_ = 0;
        
        std::vector<std::vector<int>> res;
        dfs(0, -1, res);
        return res;
    }

private:
    void dfs(int u, int parent, std::vector<std::vector<int>>& res) {
        dfn_[u] = low_[u] = ++timer_;        
        for (int v : adj_[u]) {
            if (v == parent) {
                continue;
            }
            if (dfn_[v] == -1) {
                dfs(v, u, res);
                low_[u] = std::min(low_[u], low_[v]);
                if (low_[v] > dfn_[u]) {
                    res.push_back({u, v});
                }
            }
            else {
                low_[u] = std::min(low_[u], low_[v]);
            }
        }
    }

    int timer_;
    
    std::vector<std::vector<int>> adj_;
    std::vector<int> dfn_;
    std::vector<int> low_;
};

Leetcode-1203

Mon, 01 Dec 2025 02:22:48 -0800

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_set>

class Solution {
    std::vector<int> tpsort(int n, std::vector<std::vector<int>> adj) {
        std::vector<int> res;
        std::vector<int> inDegree(n, 0);
        for (int i = 0; i < n; ++i) {
            for (int j : adj[i]) {
                ++inDegree[j];
            }
        }
        
        std::queue<int> q;
        for (int i = 0; i < n; ++i) {
            if (inDegree[i] == 0) {
                q.push(i);
            }
        }
        
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            res.push_back(u);
            for (int v : adj[u]) {
                --inDegree[v];
                if (inDegree[v] == 0) {
                    q.push(v);
                }
            }
        }
        
        if (res.size() != n) {
            return {};
        }
        return res;
    }
    
public:
    std::vector<int> sortItems(int n, int m, std::vector<int>& group, std::vector<std::vector<int>>& beforeItems) {
        for (int i = 0; i < n; ++i) {
            if (group[i] == -1) {
                group[i] = m++;
            }
        }
        
        std::vector<std::vector<int>> adjg(m);
        std::vector<std::vector<int>> adji(n);
        std::unordered_set<int> edges;
        for (int i = 0; i < n; ++i) {
            int gb = group[i];
            for (int j : beforeItems[i]) {
                int ga = group[j];
                adji[j].push_back(i);
                int edge = (gb << 16) + ga;
                if (ga != gb && !edges.count(edge)) {
                    adjg[ga].push_back(gb);
                    edges.insert(edge);
                }
            }
        }
        
        std::vector<int> gorder = tpsort(m, adjg);
        if (gorder.size() < m) {
            return {};
        }
        std::vector<int> iorder = tpsort(n, adji);
        if (iorder.size() < n) {
            return {};
        }
        
        std::vector<std::vector<int>> g2i(m);
        for (int i : iorder) {
            g2i[group[i]].push_back(i);
        }
        std::vector<int> res;
        res.reserve(n);
        for (auto& g : gorder) {
            for (int i : g2i[g]) {
                res.push_back(i);
            }
        }
        return res;
    }
};

Leetcode-1214

Mon, 15 Dec 2025 01:07:27 -0800

1214. Two Sum BSTs

Given the roots of two binary search trees, root1 and root2, return true if and only if there is a node in the first tree and a node in the second tree whose values sum up to a given integer target.

Example 1:(Image shows two binary search trees. Tree 1 has root 2, left child 1, right child 4. Tree 2 has root 1, left child 0, right child 3.)

Input: root1 = [2,1,4], root2 = [1,0,3], target = 5

Output: true

Explanation: 2 and 3 sum up to 5.

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

#include <iostream>
#include <vector>
 
class Solution {
public:
    bool twoSumBSTs(TreeNode* root1, TreeNode* root2, int target) {
        std::vector<int> array1, array2;
        DFS(root1, array1);
        DFS(root2, array2);
        int m = array1.size();
        int n = array2.size();
        for (int a = 0, b = n - 1; a < m && b >= 0;) {
            int cur = array1[a] + array2[b];
            if (cur == target) {
                return true;
            }
            else if (cur > target) {
                --b;
            }
            else {
                ++a;
            }
        }
        return false;
    }

private:
    void DFS(TreeNode* node, std::vector<int>& array) {
        if (node->left != nullptr) {
            DFS(node->left, array);
        }
        array.push_back(node->val);
        if (node->right != nullptr) {
            DFS(node->right, array);
        }
    }
};

Leetcode-1283

Tue, 23 Dec 2025 14:18:55 -0800

Time complexity: $O(N\log M)$

#include <iostream>
#include <vector>

class Solution {
public:
    int smallestDivisor(std::vector<int>& nums, int threshold) {
        long long sum = 0;
        int right = 0;
        for (int i : nums) {
            sum += i;
            right = std::max(right, i);
        }
        int left = sum / threshold;
        if (!left) {
            return 1;
        }
        
        for (int mid = (left + right) / 2; right > left; mid = (left + right) / 2) {
            int k = getSum(nums, mid);
            if (k > threshold) {
                left = mid + 1;
            }
            else {
                right = mid;
            }
        }
        
        return left;
    }
    
private:
    int getSum(std::vector<int>& nums, int divisor) {
        int sum = nums.size();
        for (int num : nums) {
            sum += (num - 1) / divisor;
        }
        return sum;
    }
};

Leetcode-1284

Sat, 29 Nov 2025 21:01:40 -0800

#include <iostream>
#include <vector>
#include <queue>

const int INF = 0x3fff'ffff;

class Solution {    
public:
    int minFlips(std::vector<std::vector<int>>& mat) {
        int m = mat.size();
        int n = mat[0].size();
        if (m * n == 1) {
            return mat[0][0];
        }
        if (m * n == 2) {
            if (mat[0][0] == mat.back().back()) {
                return mat[0][0];
            }
            return -1;
        }
        if (m * n == 4) {
            int a = mat[0][0] + mat[0][1] + mat[1][0] + mat[1][1];
            if (a != 1) {
                return a;
            }
            return 3;
        }
        
        int M = m * n;
        std::vector<int> dist((1 << M), INF);
        std::vector<int> mask(M, 0);
        for (int i = 0; i < M; ++i) {
            for (int j = 0; j < M; ++j) {
                mask[i] *= 2;
                if (i / n == j / n && std::abs(i - j) < 2) {
                    ++mask[i];
                }
                else if (!(i - j - n) || !(i - j + n)) {
                    ++mask[i];
                }
            }
        }
        
        int start = 0;
        for (auto& row : mat) {
            for (auto& y : row) {
                start *= 2;
                start += y;
            }
        }
        dist[start] = 0;
        
        std::queue<int> q;
        q.push(start);
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            for (auto& m : mask) {
                int v = u ^ m;
                if (v == 0) {
                    return dist[u] + 1;
                }
                if (dist[v] != INF) {
                    continue;
                }
                dist[v] = dist[u] + 1;
                q.push(v);
            }
        }
        
        return -1;
    }
};

Leetcode-1306

Thu, 27 Nov 2025 00:11:51 -0800

#include <iostream>
#include <vector>

class Solution {
    bool DFS(int i, int n, std::vector<int>& visited, std::vector<int>& arr) {
        if (i < 0 || i >= n || visited[i]) {
            return false;
        }
        if (arr[i] == 0) {
            return true;
        }
        visited[i] = true;
        return (DFS(i - arr[i], n, visited, arr) || DFS(i + arr[i], n, visited, arr));
    }
public:
    bool canReach(std::vector<int>& arr, int start) {
        int n = arr.size();
        std::vector<int> visited(n, 0);
        return DFS(start, n, visited, arr);
    }
};

Leetcode-1334

Mon, 24 Nov 2025 23:28:21 -0800

#include <iostream>
#include <vector>
#include <algorithm>

class Solution {
public:
    int findTheCity(int n, std::vector<std::vector<int>>& edges, int distanceThreshold) {
        int INF = distanceThreshold + 1;
        std::vector<std::vector<int>> dist(n, std::vector<int>(n, INF));
        for (auto& e : edges) {
            dist[e[0]][e[1]] = std::min(dist[e[0]][e[1]], e[2]);
            dist[e[1]][e[0]] = std::min(dist[e[1]][e[0]], e[2]);
        }
        for (int k = 0; k < n; ++k) {
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n; ++j) {
                    if (i != j && dist[i][k] < INF && dist[k][j] < INF) {
                        dist[i][j] = std::min(dist[i][j], dist[i][k] + dist[k][j]);
                    }
                }
            }
        }
        int min_id = 0, min_num = 0x3fff'ffff;
        for (int i = 0; i < n; ++i) {
            int num = 0;
            for (int j = 0; j < n; ++j) {
                if (dist[i][j] < INF) {
                    ++num;
                }
            }
            if (num <= min_num) {
                min_id = i;
                min_num = num;
            }
        }
        return min_id;
    }
};

Leetcode-1343

Wed, 17 Dec 2025 02:39:54 -0800

题目内容 (Markdown)

1343. Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold

Given an array of integers arr and two integers k and threshold, return the number of sub-arrays of size k and average greater than or equal to threshold.

Example 1:

Input: arr = [2,2,2,2,5,5,5,8], k = 3, threshold = 4 Output: 3 Explanation: Sub-arrays [2,5,5], [5,5,5] and [5,5,8] have averages 4, 5 and 6 respectively. All other sub-arrays of size 3 have averages less than 4 (the threshold).

Example 2:

Input: arr = [11,13,17,23,29,31,7,5,2,3], k = 3, threshold = 5 Output: 6 Explanation: The first 6 sub-arrays of size 3 have averages greater than 5. Note that averages are not integers.

#include <iostream>
#include <vector>

class Solution {
public:
    int numOfSubarrays(std::vector<int>& arr, int k, int threshold) {
		int n = arr.size();
		if (n < k) {
			return 0;
		}
		threshold *= k;
		
        int sum = 0, num = 0;
		for (int i = 0; i < k; ++i) {
			sum += arr[i];
		}
		if (sum >= threshold) {
			num = 1;
		}
		
		for (int i = k; i < n; ++i) {
			sum = sum + arr[i] - arr[i - k];
			if (sum >= threshold) {
				++num;
			}
		}
		return num;
    }
};

Leetcode-1345

Fri, 28 Nov 2025 00:38:40 -0800

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_map>

const int INF = 0x3fff'ffff;

class Solution {
public:
    int minJumps(std::vector<int>& arr) {
        int n = arr.size();
        std::unordered_map<int, std::vector<int>> edges;
        for (int i = 0; i < n; ++i) {
            edges[arr[i]].push_back(i);
        }
        
        std::vector<int> dist(n, INF);
        std::queue<int> q;
        dist[0] = 0;
        q.push(0);
        while (!q.empty()) {
            int u = q.front();
            int d = dist[u];
            q.pop();
            if (u > 0 && dist[u] + 1 < dist[u - 1]) {
                dist[u - 1] = dist[u] + 1;
                q.push(u - 1);
            }
            if (u < n - 1 && dist[u] + 1 < dist[u + 1]) {
                dist[u + 1] = dist[u] + 1;
                q.push(u + 1);
            }
            auto it = edges.find(arr[u]);
            if (it == edges.end()) {
                continue;
            }
            const vector<int>& next_indices = it->second;
            for (auto& v : next_indices) {
                if (INF == dist[v]) {
                    dist[v] = dist[u] + 1;
                    q.push(v);
                }
            }
            edges.erase(it);
        }
        return dist.back();
    }
};

Leetcode-1456

Mon, 15 Dec 2025 19:48:53 -0800

1456. Maximum Number of Vowels in a Substring of Given Length

Difficulty: Medium

Given a string s and an integer k, return the maximum number of vowel letters in any substring of s with length k.

Vowel letters in English are 'a', 'e', 'i', 'o', and 'u'.

Example 1:

Input: s = "abciiidef", k = 3

Output: 3

Explanation: The substring “iii” contains 3 vowel letters.

Example 2:

Input: s = "aeiou", k = 2

Output: 2

Explanation: Any substring of length 2 contains 2 vowels.

Example 3:

Input: s = "leetcode", k = 3

Output: 2

Explanation: “lee”, “eet” and “ode” contain 2 vowels.

#include <iostream>
#include <cstring>

class Solution {
public:
    int maxVowels(std::string s, int k) {
        int n = s.size(), m = std::min(n, k);
        int num = 0;
        for (int i = 0; i < m; ++i) {
            if (isVowel(s[i])) {
                ++num;
            }
        }
        int max_num = num;
        for (int i = m; i < n; ++i) {
            if (isVowel(s[i])) {
                ++num;
            }
            if (isVowel(s[i - k])) {
                --num;
            }
            max_num = std::max(num, max_num);
        }
        return max_num;
    }

private:
    bool isVowel(char c) {
        if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
            return true;
        }        return false;
    }
};

Leetcode-1458

Wed, 31 Dec 2025 10:31:25 -0800

Time complexity: $O(mn)$

#include <iostream>
#include <vector>

class Solution {
public:
    int maxDotProduct(std::vector<int>& nums1, std::vector<int>& nums2) {
        int m = nums1.size();
        int n = nums2.size();
        std::vector<int> dp(n + 1);
        
        for (int i = 0; i < m; ++i) {
            int tmp = 0, tmp2;
            for (int j = 0; j < n; ++j) {
                tmp2 = dp[j + 1];
                dp[j + 1] = std::max(dp[j], dp[j + 1]);
                dp[j + 1] = std::max(tmp + nums1[i] * nums2[j], dp[j + 1]);
                std::swap(tmp, tmp2);
            }
        }
        
        if (dp.back() == 0) {
            int a = 0x8000'0000, aa = 0x7fff'ffff;
            int b = 0x8000'0000, bb = 0x7fff'ffff;
            for (int num : nums1) {
                a = std::max(a, num);
                aa = std::min(aa, num);
            }
            for (int num : nums2) {
                b = std::max(b, num);
                bb = std::min(bb, num);
            }
            return std::max(a * bb, b * aa);
        }
        
        return dp.back();
    }
};

Leetcode-1462

Wed, 26 Nov 2025 01:51:13 -0800

#include <iostream>
#include <vector>

class Solution {
public:
    std::vector<bool> checkIfPrerequisite(int numCourses, std::vector<std::vector<int>>& prerequisites, std::vector<std::vector<int>>& queries) {
        std::vector<std::vector<bool>> d(numCourses, std::vector<bool>(numCourses, false));
        for (auto& e : prerequisites) {
            d[e[0]][e[1]] = true;
        }
        for (int k = 0; k < numCourses; ++k) {
            for (int i = 0; i < numCourses; ++i) {
                for (int j = 0; j < numCourses; ++j) {
                    if (d[i][k] && d[k][j]) {
                        d[i][j] = true;
                    }
                }
            }
        }
        
        int n = queries.size();
        std::vector<bool> res(n);
        for (int i = 0; i < n; ++i) {
            res[i] = d[queries[i][0]][queries[i][1]];
        }
        return res;
    }
};

Leetcode-1482

Tue, 23 Dec 2025 14:36:52 -0800

Time complexity: $O(n\log M)$

#include <iostream>
#include <vector>

class Solution {
public:
    int minDays(std::vector<int>& bloomDay, int m, int k) {
        int n = bloomDay.size();
        if ((long long)m * k > n) {
            return -1;
        }
        int left = 1, right = 0;
        for (int d : bloomDay) {
            right = std::max(right, d);
        }
        
        for (int t = (left + right) / 2; right > left;) {
            if (check(bloomDay, k, m, t)) {
                right = t;
            }
            else {
                left = t + 1;
            }
            t = (left + right) / 2;
        }
        
        return left;
    }
    
private:
    bool check(std::vector<int>& bloomDay, int k, int m, int t) {
        int cur = 0;
        for (int d : bloomDay) {
            if (d <= t) {
                ++cur;
            }
            else {
                cur = 0;
            }
            if (cur == k) {
                --m;
                if (m == 0) {
                    return true;
                }
                cur = 0;
            }
        }
        return false;
    }
};

Leetcode-1493

Fri, 19 Dec 2025 00:38:44 -0800

1493. Longest Subarray of 1’s After Deleting One Element

Given a binary array nums, you should delete one element from it.

Return the size of the longest non-empty subarray containing only 1’s in the resulting array. Return 0 if there is no such subarray.

Example 1:

Input: nums = [1,1,0,1] Output: 3 Explanation: After deleting the number in position 2, [1,1,1] contains 3 numbers with value of 1’s.

Example 2:

Input: nums = [0,1,1,1,0,1,1,0,1] Output: 5 Explanation: After deleting the number in position 4, [0,1,1,1,1,0,1] longest subarray with value of 1’s is [1,1,1,1,1].

Example 3:

Input: nums = [1,1,1] Output: 2 Explanation: You must delete one element.

Constraints:

1 <= nums.length <= 10^5
nums[i] is either 0 or 1.

#include <iostream>
#include <vector>

class Solution {
public:
    int longestSubarray(std::vector<int>& nums) {
        int a = 0, b = 0, max_len = 0;
        
        for (int num : nums) {
            if (num == 0) {
                max_len = std::max(max_len, a + b);
                b = a;
                a = 0;
            }
            else {
                ++a;
            }
        }
        
        max_len = std::max(max_len, a + b);
        return std::min(max_len, (int)nums.size() - 1);
    }
};

Leetcode-1552

Wed, 24 Dec 2025 19:50:52 -0800

Time complexity: $O(n(\log M-\log n))$

#include <iostream>
#include <vector>
#include <algorithm>

class Solution {
public:
    int maxDistance(std::vector<int>& position, int m) {
        std::sort(position.begin(), position.end());
        int n = position.size();
        int left = 1, right = (position.back() - position[0]) / (m - 1);
        while (right >= left) {
            int mid = (right + left) / 2;
            if (check(position, m, n, mid)) {
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
        }
        return right;
    }
    
private:
    bool check(std::vector<int>& position, int m, int n, int dist) {
        int prev = 0;
        for (int i = 1; i < n; ++i) {
            if (position[i] - position[prev] >= dist) {
                --m;
                if (m == 1) {
                    return true;
                }
                prev = i;
            }
        }
        return false;
    }
};

Leetcode-1584

Mon, 01 Dec 2025 23:25:19 -0800

#include <iostream>
#include <vector>
#include <queue>

typedef std::pair<int, int> PII;

class Solution {
    int abs(std::vector<int>& a, std::vector<int>& b) {
        return std::abs(a[0] - b[0]) + std::abs(a[1] - b[1]);
    }
    
public:
    int minCostConnectPoints(std::vector<std::vector<int>>& points) {
        int n = points.size();
        int sum = 0;
        std::vector<int> visited(n, false);
        std::priority_queue<PII, std::vector<PII>, std::greater<PII>> pq;
        pq.push({0, 0});
        
        while (!pq.empty()) {
            int w = pq.top().first;
            int u = pq.top().second;
            pq.pop();
            
            if (visited[u]) {
                continue;
            }
            visited[u] = true;
            sum += w;
            
            for (int v = 0; v < n; ++v) {
                if (visited[v]) {
                    continue;
                }
                w = abs(points[u], points[v]);
                pq.push({w, v});
            }
        }
        
        return sum;
    }
};

Leetcode-1591

Mon, 01 Dec 2025 01:30:04 -0800

#include <iostream>
#include <vector>
#include <queue>

struct Color {
    int x1 = 60;
    int x2 = -1;
    int y1 = 60;
    int y2 = -1;
    
    void insert(int x, int y) {
        x1 = std::min(x1, x);
        x2 = std::max(x2, x);
        y1 = std::min(y1, y);
        y2 = std::max(y2, y);
    }
    
    bool contains(int x, int y) {
        if (x < x1 || x > x2) {
            return false;
        }
        if (y < y1 || y > y2) {
            return false;
        }
        return true;
    }
};

class Solution {
public:
    bool isPrintable(std::vector<std::vector<int>>& targetGrid) {
        int num = 60;
        int maxn = -1;
        int m = targetGrid.size();
        int n = targetGrid[0].size();
        std::vector<Color> colors(num);
        
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                int c = targetGrid[i][j] - 1;
                maxn = std::max(c, maxn);
                colors[c].insert(i, j);
            }
        }
        ++maxn;
        
        std::vector<std::vector<int>> adj(maxn, std::vector<int>(maxn, false));
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                int c = targetGrid[i][j] - 1;
                for (int d = 0; d < maxn; ++d) {
                    if (colors[d].contains(i, j)) {
                        adj[d][c] = true;
                    }
                }
            }
        }
        
        int cnt = 0;
        std::vector<int> inDegree(maxn, 0);
        for (int i = 0; i < maxn; ++i) {
            for (int j = 0; j < maxn; ++j) {
                if (adj[i][j] && i != j) {
                    ++inDegree[j];
                }
            }
        }
        
        std::queue<int> q;
        for (int i = 0; i < maxn; ++i) {
            if (inDegree[i] == 0) {
                q.push(i);
            }
        }
        
        while (!q.empty()) {
            int i = q.front();
            q.pop();
            ++cnt;
            for (int j = 0; j < maxn; ++j) {
                if (!adj[i][j] || i == j) {
                    continue;
                }
                --inDegree[j];
                if (inDegree[j] == 0) {
                    q.push(j);
                }
            }
        }
        
        return cnt == maxn;
    }
};

Leetcode-1610

Fri, 19 Dec 2025 00:47:29 -0800

1610. Maximum Number of Visible Points

You are given an array points, an integer angle, and your location, where location = [pos_x, pos_y] and points[i] = [x_i, y_i] both denote integral coordinates on the X-Y plane.

Initially, you are facing directly east from your position. You cannot move from your position, but you can rotate. In other words, pos_x and pos_y cannot be changed. Your field of view in degrees is represented by angle, determining how wide you can see from any given view direction. Let d be the amount in degrees that you rotate counterclockwise. Then, your field of view is the inclusive range of angles [d - angle/2, d + angle/2].

(Video demonstration present in original context showing a field of view rotating around a central point)

You can see some set of points if, for each point, the angle formed by the point, your position, and the immediate east direction from your position is in your field of view.

There can be multiple points at one coordinate. There may be points at your location, and you can always see these points regardless of your rotation. Points do not obstruct your vision to other points.

Return the maximum number of points you can see.

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>

class Solution {
public:
    int visiblePoints(std::vector<std::vector<int>>& points, int angle, std::vector<int>& location) {
        int n = points.size();
        if (angle >= 360) {
            return n;
        }
        
        std::vector<double> angles;
        angles.reserve(2 * n);
        int res = 0;
        for (auto& point : points) {
            if (point[0] == location[0] && point[1] == location[1]) {
                ++res;
                --n;
            }
            else {
                angles.push_back(getAngle(point, location));
            }
        }
        if (n == 0) {
            return res;
        }
        ++res;
        
        
        std::sort(angles.begin(), angles.end());
        for (int i = 0; i < n; ++i) {
            angles.push_back(angles[i] + 360);
        }
        
        int left = 0;
        int max_num = 0;
        for (int right = 0; right < 2 * n; ++right) {
            while (angle < angles[right] - angles[left]) {
                ++left;
            }
            max_num = std::max(max_num, right - left);
        }
        
        return max_num + res;
    }
    
private:
    double getAngle(std::vector<int>& dist, std::vector<int>& origin) {
        double theta = std::atan2(dist[1] - origin[1], dist[0] - origin[0]);
        theta = theta * 180 / M_PI + 180;
        return theta;
    }
};

Leetcode-1631

Tue, 23 Dec 2025 15:04:33 -0800

Time complexity: $O(MN\log MN)$

#include <iostream>
#include <vector>
#include <queue>
#include <functional>

typedef std::pair<int, std::pair<int, int>> PIPII;

class Solution {
public:
    int minimumEffortPath(std::vector<std::vector<int>>& heights) {
        int m = heights.size();
        int n = heights[0].size();
        std::vector<std::vector<int>> visited(m, std::vector<int>(n, 0));
        std::vector<std::vector<int>> dist(m, std::vector<int>(n, 0x3fff'ffff));
        
        int dirs[4][2] = { {0, 1}, {1, 0}, {-1, 0}, {0, -1} };
        std::priority_queue<PIPII, std::vector<PIPII>, std::greater<PIPII>> pq;
        pq.push({0, {0, 0}});
        
        while (!pq.empty()) {
            int d = pq.top().first;
            int x = pq.top().second.first;
            int y = pq.top().second.second;
            pq.pop();
            if (d > dist[x][y]) {
                continue;
            }
            if (x == m - 1 && y == n - 1) {
                return d;
            }
            
            for (auto& dir : dirs) {
                int xx = x + dir[0];
                int yy = y + dir[1];
                if (xx >= 0 && xx < m && yy >= 0 && yy < n && !visited[xx][yy]) {
                    int nd = std::max(d, std::abs(heights[xx][yy] - heights[x][y]));
                    if (nd < dist[xx][yy]) {
                        dist[xx][yy] = nd;
                        pq.push({nd, {xx, yy}});
                    }
                }
            }
        }
        
        return -1;
    }
};

Leetcode-1642

Tue, 23 Dec 2025 14:51:27 -0800

Time complexity: $O(n\log k)$

#include <iostream>
#include <vector>
#include <queue>

class Solution {
public:
    int furthestBuilding(std::vector<int>& heights, int bricks, int ladders) {
        int n = heights.size();
        std::priority_queue<int, std::vector<int>, std::greater<int>> pq;
        
        for (int i = 0; i < n - 1; ++i) {
            int diff = heights[i + 1] - heights[i];
            if (diff > 0) {
                pq.push(diff);
                if (pq.size() > ladders) {
                    bricks -= pq.top();
                    pq.pop();
                }
                if (bricks < 0) {
                    return i;
                }
            }
        }
        return n - 1;
    }
};

Leetcode-1648

Tue, 23 Dec 2025 14:55:45 -0800

Time complexity: $O(n\log n)$

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

const int M = 1'000'000'007;

class Solution {
public:
    int maxProfit(std::vector<int>& inventory, int orders) {
        std::sort(inventory.begin(), inventory.end(), std::greater<int>());
        long long n = inventory.size();
        inventory.push_back(0);
        
        long long sum = 0;
        for (int i = 0; i < n; ++i) {
            long long diff = inventory[i] - inventory[i + 1];
            long long add = cal(inventory[i], inventory[i + 1]);
            long long num = diff * (i + 1);
            if (num < orders) {
                orders -= num;
                sum += add * (i + 1);
            }
            else {
                long long new_diff = orders / (i + 1);
                long long new_num = orders % (i + 1);
                sum += cal(inventory[i], inventory[i] - new_diff) * (i + 1);
                sum += new_num * (inventory[i] - new_diff);
                break;
            }
        }
        
        return sum % M;
    }
    
private:
    long long cal(long long a, long long b) {
        return (a + b + 1) * (a - b) / 2;
    }
};

Leetcode-1658

Fri, 19 Dec 2025 00:45:07 -0800

1658. Minimum Operations to Reduce X to Zero

You are given an integer array nums and an integer x. In one operation, you can either remove the leftmost or the rightmost element from the array nums and subtract its value from x. Note that this modifies the array for future operations.

Return the minimum number of operations to reduce x *to exactly 0 if it is possible, otherwise, return -1*.

Example 1:

Input: nums = [1,1,4,2,3], x = 5 Output: 2 Explanation: The optimal solution is to remove the last two elements to reduce x to zero.

Example 2:

Input: nums = [5,6,7,8,9], x = 4 Output: -1

Example 3:

Input: nums = [3,2,20,1,1,3], x = 10 Output: 5 Explanation: The optimal solution is to remove the last three elements and the first two elements (5 operations in total) to reduce x to zero.

Constraints:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^4
1 <= x <= 10^9

#include <iostream>
#include <vector>

class Solution {
public:
    int minOperations(std::vector<int>& nums, int x) {
        int target = -x;
        int n = nums.size();
        for (int num : nums) {
            target += num;
        }
        if (target < 0) {
            return -1;
        }
        else if (target == 0) {
            return n;
        }
        
        int max_interval = 0, cur = nums[0];
        int a = 0, b = 1;
        while (true) {
            if (cur > target) {
                cur -= nums[a];
                ++a;
                continue;
            }
            if (cur == target) {
                max_interval = std::max(max_interval, b - a);
            }
            if (b >= n) {
                break;
            }
            else {
                cur += nums[b];
                ++b;
            }
        }
        if (cur == target) {
            max_interval = std::max(max_interval, n - a);
        }
        
        if (max_interval) {
            return n - max_interval;
        }
        return -1;
    }
};

Leetcode-1695

Fri, 19 Dec 2025 00:42:01 -0800

1695. Maximum Erasure Value

You are given an array of positive integers nums and want to erase a subarray containing unique elements. The score you get by erasing the subarray is equal to the sum of its elements.

Return the maximum score you can get by erasing exactly one subarray.

An array b is called to be a subarray of a if it forms a contiguous subsequence of a, that is, if it is equal to a[l],a[l+1],...,a[r] for some (l,r).

Example 1:

Input: nums = [4,2,4,5,6] Output: 17 Explanation: The optimal subarray here is [2,4,5,6].

Example 2:

Input: nums = [5,2,1,2,5,2,1,2,5] Output: 8 Explanation: The optimal subarray here is [5,2,1] or [1,2,5].

Constraints:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^4

#include <iostream>
#include <vector>

class Solution {
public:
    int maximumUniqueSubarray(std::vector<int>& nums) {
        int max_score = 0, score = 0;
        int seen[10001] = { 0 };
        int n = nums.size();
        for (int a = 0, b = 0; b < n; ++b) {
            while (seen[nums[b]] != 0) {
                score -= nums[a];
                seen[nums[a]] = 0;
                ++a;
            }
            seen[nums[b]] = 1;
            score += nums[b];
            max_score = std::max(max_score, score);
        }
        return max_score;
    }
};

Leetcode-1760

Tue, 23 Dec 2025 15:02:50 -0800

Time complexity: $O(n\log M)$

#include <iostream>
#include <vector>

class Solution {
public:
    int minimumSize(std::vector<int>& nums, int maxOperations) {
        int left = 1, right = 0;
        for (int n : nums) {
            right = std::max(n, right);
        }
        
        for (int mid = (left + right) / 2; right >= left;) {
            if (check(nums, maxOperations, mid)) {
                right = mid - 1;
            }
            else {
                left = mid + 1;
            }
            mid = (left + right) / 2;
        }
        
        return left;
    }
    
private:
    bool check(std::vector<int>& nums, int maxOperations, int num) {
        for (int n : nums) {
            maxOperations -= (n - 1) / num;
            if (maxOperations < 0) {
                return false;
            }
        }
        return true;
    }
};

Leetcode-1774

Fri, 26 Dec 2025 21:42:48 -0800

Time complexity: $O(mn)$

#include <iostream>
#include <vector>
#include <cmath>

class Solution {
public:
    int closestCost(std::vector<int>& baseCosts, std::vector<int>& toppingCosts, int target) {
        int m = std::max(target * 2, baseCosts[0] + 1);
        std::vector<int> dp(m);
        
        for (int c : baseCosts) {
            if (c < m) {
                dp[c] = 1;
            }
        }
        
        for (int c : toppingCosts) {
            for (int i = m - 1; i >= c; --i) {
                dp[i] |= dp[i - c];
            }
            for (int i = m - 1; i >= c; --i) {
                dp[i] |= dp[i - c];
            }
        }
        
        int min_val = 0x7fff'ffff, price;
        for (int i = 0; i < m; ++i) {
            if (dp[i] && min_val > std::abs(i - target)) {
                min_val = std::abs(i - target);
                price = i;
            }
        }
        
        return price;
    }
};

Leetcode-1802

Tue, 23 Dec 2025 14:48:30 -0800

Time complexity: $O(1)$

#include <iostream>
#include <cmath>

class Solution {
public:
    int maxValue(int n, int idx, int maxSum) {
        idx = std::max(idx, n - idx - 1);
        long long R = 2 * idx + 1 - n;
        long long h = idx + 1;
        long long sum = h * h - (R * (R + 1)) / 2;
        if (maxSum >= sum) {
            return h + (maxSum - sum) / n;
        }
        
        h = n - idx;
        sum = h * h + (idx - h + 1);
        if (sum > maxSum) {
            return 1 + (int)std::sqrt(maxSum - n);
        }
        else {
            // r=h+idx-n
            // h^2+(idx-h+1)-r(r+1)/2<=maxSum
            long long b = 2 * n - 2 * idx - 3;
            long long c = 2ll * idx + 2 - (long long)(idx - n) * (idx - n + 1) - 2ll * maxSum;
            return (int)((-b + (long long)std::sqrt(b * b - 4 * c)) / 2);
        }
    }
};

Leetcode-1810

Wed, 26 Nov 2025 01:41:04 -0800

/**
 * // This is the GridMaster's API interface.
 * // You should not implement it, or speculate about its implementation
 * class GridMaster {
 *   public:
 *     bool canMove(char direction);
 *     int move(char direction);
 *     boolean isTarget();
 * };
 */
 
 typedef std::pair<int, int> PII;
 typedef std::pair<int, PII> PIPII;
 
 const int INF = 0x3fff'ffff;

class Solution {
    std::string DIRS = "UDLR";
    std::string BDIR = "DURL";
    const int dx[4] = { -1, 1, 0, 0 };
    const int dy[4] = { 0, 0, -1, 1 };
    
    int grid[201][201] = { 0 };
    bool visited[201][201] = { 0 };
    PII start = { 100, 100 };
    PII target = { -1, -1 };
    
    void dfs(int x, int y, GridMaster& master) {
        if (master.isTarget()) {
            target.first = x;
            target.second = y;
        }
        visited[x][y] = true;
        for (int i = 0; i < 4; ++i) {
            int xx = x + dx[i];
            int yy = y + dy[i];
            char dir = DIRS[i];
            char bdr = BDIR[i];
            if (!visited[xx][yy] && master.canMove(dir)) {
                grid[xx][yy] = master.move(dir);
                dfs(xx, yy, master);
                grid[x][y] = master.move(bdr);
            }
            else if (!visited[xx][yy]) {
                grid[xx][yy] = -1;
            }
        }
    }
public:
    int findShortestPath(GridMaster& master) {
        std::vector<std::vector<int>> dist(201, std::vector<int>(201, INF));
        std::priority_queue<PIPII, std::vector<PIPII>, std::greater<PIPII>> pq;
        dfs(start.first, start.second, master);
        if (target.first == -1) {
            return -1;
        }
        pq.push({0, start});
        dist[start.first][start.second] = 0;
        while (!pq.empty()) {
            int d = pq.top().first;
            int x = pq.top().second.first;
            int y = pq.top().second.second;
            pq.pop();
            if (d > dist[x][y]) {
                continue;
            }
            for (int i = 0; i < 4; ++i) {
                int xx = x + dx[i];
                int yy = y + dy[i];
                if (!visited[xx][yy] || grid[xx][yy] < 0) {
                    continue;
                }
                if (dist[xx][yy] > dist[x][y] + grid[xx][yy]) {
                    dist[xx][yy] = dist[x][y] + grid[xx][yy];
                    pq.push({dist[xx][yy], {xx, yy}});
                }
            }
        }
        if (dist[target.first][target.second] != INF) {
            return dist[target.first][target.second];
        }
        return -1;
    }
};

Leetcode-1818

Tue, 23 Dec 2025 14:16:51 -0800

Time complexity: $O(N\log n)$

#include <iostream>
#include <vector>
#include <algorithm>

const int M = 1'000'000'007;

class Solution {
public:
    int minAbsoluteSumDiff(vector<int>& nums1, vector<int>& nums2) {
        long long sum = 0;
        int n = nums1.size();
        std::vector<std::pair<int, int>> nums(n);
        for (int i = 0; i < n; ++i) {
            int diff = std::abs(nums2[i] - nums1[i]);
            sum += diff;
            nums[i].first = nums2[i];
            nums[i].second = diff;
        }
        
        std::sort(nums.begin(), nums.end());
        std::sort(nums1.begin(), nums1.end());
        
        int max_diff = 0, new_diff;
        for (int i = 0, j = 0; i < n; ++i) {
            int num2 = nums[i].first;
            int diff = nums[i].second;
            while (j < n - 1 && nums1[j] < num2) {
                ++j;
            }
            new_diff = std::abs(nums1[j] - num2);
            if (j) {
                new_diff = std::min(new_diff, std::abs(nums1[j - 1] - num2));
            }
            max_diff = std::max(max_diff, diff - new_diff);
        }
        
        return (sum - max_diff) % M;
    }
};

Leetcode-1874

Mon, 15 Dec 2025 01:07:27 -0800

1874. Minimize Product Sum of Two Arrays

Difficulty: Medium

The product sum of two equal-length arrays a and b is equal to the sum of a[i] * b[i] for all 0 <= i < a.length (0-indexed).

For example, if a = [1,2,3,4] and b = [5,2,3,1], the product sum would be 1*5 + 2*2 + 3*3 + 4*1 = 22.

Given two arrays nums1 and nums2 of length n, return *the minimum product sum if you are allowed to rearrange the order of the elements in nums1*.

Example 1:

Input: nums1 = [5,3,4,2], nums2 = [4,2,2,5]

Output: 40

Explanation: We can rearrange nums1 to become [3,5,4,2]. The product sum of [3,5,4,2] and [4,2,2,5] is 3*4 + 5*2 + 4*2 + 2*5 = 40.

Example 2:

Input: nums1 = [2,1,4,5,7], nums2 = [3,2,4,8,6]

Output: 65

Explanation: We can rearrange nums1 to become [5,7,4,1,2]. The product sum of [5,7,4,1,2] and [3,2,4,8,6] is 5*3 + 7*2 + 4*4 + 1*8 + 2*6 = 65.

###Constraints:* n == nums1.length == nums2.length

1 <= n <= 10^5
1 <= nums1[i], nums2[i] <= 100

#include <iostream>
#include <vector>

class Solution {
public:
    int minProductSum(std::vector<int>& nums1, std::vector<int>& nums2) {
        int cnt1[101] = { 0 };
        int cnt2[101] = { 0 };
        for (auto& num : nums1) {
            ++cnt1[num];
        }
        for (auto& num: nums2) {
            ++cnt2[num];
        }
        
        int n = nums1.size();
        int sum = 0;
        int a = 1, b = 100;
        for (int i = 0; i < n; ++i) {
            while (!cnt1[a]) {
                ++a;
            }
            while (!cnt2[b]) {
                --b;
            }
            sum += a * b;
            --cnt1[a];
            --cnt2[b];
        }
        return sum;
    }
};

Leetcode-1888

Wed, 17 Dec 2025 23:43:04 -0800

1888. Minimum Number of Flips to Make the Binary String Alternating

You are given a binary string s. You are allowed to perform two types of operations on the string in any sequence:

Type-1: Remove the character at the start of the string s and append it to the end of the string.
Type-2: Pick any character in s and flip its value, i.e., if its value is '0' it becomes '1' and vice-versa.

Return the minimum number of type-2 operations you need to perform such that s becomes alternating.

The string is called alternating if no two adjacent characters are equal.

For example, the strings "010" and "1010" are alternating, while the string "0100" is not.

Example 1:

Input: s = "111000" Output: 2 Explanation: Use the first operation two times to make s = "100011". Then, use the second operation on the third and sixth elements to make s = "101010".

Example 2:

Input: s = "010" Output: 0 Explanation: The string is already alternating.

Example 3:

Input: s = "1110" Output: 1 Explanation: Use the second operation on the second element to make s = "1010".

#include <iostream>
#include <cstring>

class Solution {
public:
    int minFlips(std::string s) {
        int n = s.length();
        int num1 = 0, num2 = 0, k = 0;
        for (int i = 0; i < n; ++i) {
            if (s[i] == k + '0') {
                ++num1;
            }
            else {
                ++num2;
            }
            k = 1 - k;
        }
        int min1 = num1;
        int min2 = num2;
        if (n % 2 == 0) {
            return std::min(min1, min2);
        }
        
        for (int i = 0; i < n; ++i) {
            if (s[i] == k + '0') {
                --num2;
                ++num1;
            }
            else {
                --num1;
                ++num2;
            }
            k = 1 - k;
            min1 = std::min(min1, num1);
            min2 = std::min(min2, num2);
        }
        return std::min(min1, min2);
    }
};

Leetcode-1898

Tue, 23 Dec 2025 14:46:52 -0800

Time complexity: $O(n\log K)$

#include <iostream>
#include <cstring>
#include <vector>

class Solution {
public:
    int maximumRemovals(std::string s, std::string p, std::vector<int>& removable) {
        int n = s.length(), m = removable.size();
        mask_.resize(n, 0x3fff'ffff);
        for (int i = 0; i < m; ++i) {
            mask_[removable[i]] = i;
        }
        
        int left = 0, right = std::min(m, n - (int)p.length());
        for (int mid = (left + right) / 2; left <= right;) {
            if (check(s, p, mid)) {
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
            mid = (left + right) / 2;
        }
        
        return right;
    }
    
private:
    bool check(std::string& s, std::string& p, int k) {
        int n = s.length();
        int m = p.length();
        int a = 0;
        
        for (int i = 0; i < n; ++i) {
            if (mask_[i] >= k && s[i] == p[a]) {
                ++a;
                if (a == m) {
                    return true;
                }
            }
        }
        return false;
    }
    
    std::vector<int> mask_;
};

Leetcode-1937

Fri, 26 Dec 2025 16:50:34 -0800

Time complexity: $O(n)$

#include <iostream>
#include <vector>

class Solution {
public:
    long long maxPoints(vector<vector<int>>& points) {
        int m = points.size();
        int n = points[0].size();
        std::vector<long long> dp(n);
        std::vector<long long> tmp(n);
        
        long long maxe;
        for (int i = 0; i < m; ++i) {
            std::swap(tmp, dp);
            maxe = 0x8000'0000'0000'0000;
            for (int j = 0; j < n; ++j) {
                maxe = std::max(maxe, tmp[j] + j);
                dp[j] = std::max(dp[j], maxe + points[i][j] - j);
            }
            maxe = 0x8000'0000'0000'0000;
            for (int j = n - 1; j >= 0; --j) {
                maxe = std::max(maxe, tmp[j] - j);
                dp[j] = std::max(dp[j], maxe + points[i][j] + j);
            }
        }
        
        long long max_score = 0;
        for (long long i : dp) {
            max_score = std::max(max_score, i);
        }
        return max_score;
    }
};

Leetcode-2039

Thu, 27 Nov 2025 02:24:57 -0800

#include <iostream>
#include <vector>
#include <queue>

const int INF = 0x3fff'ffff;

class Solution {
public:
    int networkBecomesIdle(std::vector<std::vector<int>>& edges, std::vector<int>& patience) {
        int n = patience.size();
        std::vector<int> dist(n, INF);
        std::vector<std::vector<int>> adj(n);
        for (auto& e : edges) {
            adj[e[0]].push_back(e[1]);
            adj[e[1]].push_back(e[0]);
        }
        
        std::queue<int> q;
        dist[0] = 0;
        q.push(0);
        while (!q.empty()) {
            int u = q.front();
            int d = dist[u];
            q.pop();
            for (auto& v : adj[u]) {
                if (dist[v] == INF) {
                    dist[v] = d + 1;
                    q.push(v);
                }
            }
        }
        
        int res = 0;
        for (int i = 1; i < n; ++i) {
            res = std::max(res, (2 * dist[i] - 1) / patience[i] * patience[i] + 2 * dist[i] + 1);
        }
        return res;
    }
};

Leetcode-2064

Tue, 23 Dec 2025 14:57:24 -0800

Time complexity: $O(m\log N)$

#include <iostream>
#include <vector>

class Solution {
public:
    int minimizedMaximum(int n, std::vector<int>& quantities) {
        int m = quantities.size();
        int left = 1, right = 0;
        for (int i : quantities) {
            right = std::max(right, i);
        }
        
        n -= m;
        if (n == 0) {
            return right;
        }
        
        for (int mid = (left + right) / 2; right >= left;) {
            if (check(mid, n, quantities)) {
                right = mid - 1;
            }
            else {
                left = mid + 1;
            }
            mid = (left + right) / 2;
        }
        
        return left;
    }
    
private:
    bool check(int x, int n, std::vector<int>& quantities) {
        for (int i : quantities) {
            n -= (i - 1) / x;
            if (n < 0) {
                return false;
            }
        }
        return true;
    }
};

Leetcode-2080

Tue, 23 Dec 2025 14:10:22 -0800

Time complexity: $O(\log n)$ for each query operation.

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>

class RangeFreqQuery {
public:
    RangeFreqQuery(std::vector<int>& arr) {
        for (int i = 0; i < arr.size(); ++i) {
            map[arr[i]].push_back(i);
        }
    }
    
    int query(int left, int right, int value) {
        if (left > right) {
            return 0;
        }
        
        auto& v = map[value];
        auto it1 = std::lower_bound(v.begin(), v.end(), left);
        auto it2 = std::lower_bound(v.begin(), v.end(), right + 1);
        return it2 - it1;
    }
    
private:
    std::map<int, std::vector<int>> map;
};

/**
 * Your RangeFreqQuery object will be instantiated and called as such:
 * RangeFreqQuery* obj = new RangeFreqQuery(arr);
 * int param_1 = obj->query(left,right,value);
 */

Leetcode-2101

Wed, 26 Nov 2025 02:11:04 -0800

#include <iostream>
#include <vector>

class Solution {
    bool det(std::vector<std::vector<int>>& bombs, int a, int b) {
        long long x = bombs[a][0] - bombs[b][0];
        long long y = bombs[a][1] - bombs[b][1];
        long long r = bombs[a][2];
        return x * x + y * y <= r * r;
    }
        
public:
    int maximumDetonation(std::vector<std::vector<int>>& bombs) {
        int n = bombs.size();
        std::vector<std::vector<bool>> dist(n, std::vector<bool>(n, false));
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                if (i != j) {
                    dist[i][j] = det(bombs, i, j);
                }
            }
        }
        
        for (int k = 0; k < n; ++k) {
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n; ++j) {
                    if (i != j && dist[i][k] && dist[k][j]) {
                        dist[i][j] = true;
                    }
                }
            }
        }
        
        int res = 0;
        for (int i = 0; i < n; ++i) {
            int cnt = 0;
            for (int j = 0; j < n; ++j) {
                cnt += dist[i][j];
            }
            res = std::max(res, cnt);
        }
        return res + 1;
    }
};

Leetcode-2115

Sun, 30 Nov 2025 02:44:38 -0800

#include <iostream>
#include <cstring>
#include <unordered_map>
#include <vector>
#include <queue>

class Solution {
    std::unordered_map<int, std::string> int_to_str;
    std::unordered_map<std::string, int> str_to_int;
    int cnt = -1;
    
    int insert(const std::string& name) {
        if (str_to_int.count(name)) {
            return str_to_int[name];
        }
        ++cnt;
        int_to_str[cnt] = name;
        str_to_int[name] = cnt;
        return cnt;
    }
    
    int get(const std::string& str) {
        return str_to_int[str];
    }
    
    std::string get(int id) {
        return int_to_str[id];
    }
    
public:
    std::vector<string> findAllRecipes(std::vector<std::string>& recipes, std::vector<std::vector<std::string>>& ingredients, std::vector<std::string>& supplies) {
        std::queue<int> q;
        for (auto& name : supplies) {
            q.push(insert(name));
        }
        for (auto& name : recipes) {
            insert(name);
        }
        for (auto& ingredient : ingredients) {
            for (auto& name : ingredient) {
                insert(name);
            }
        }
        
        int V = cnt + 1;
        std::vector<std::vector<int>> adj(V);
        std::vector<int> isRecipe(V, 0);
        int m = recipes.size();
        for (int i = 0; i < m; ++i) {
            int u = get(recipes[i]);
            isRecipe[u] = true;
            for (auto& name : ingredients[i]) {
                adj[get(name)].push_back(u);
            }
        }
        
        std::vector<int> inDegree(V, 0);
        for (int u = 0; u < V; ++u) {
            for (int v : adj[u]) {
                ++inDegree[v];
            }
        }
        
        std::vector<std::string> res;
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            if (isRecipe[u]) {
                res.push_back(get(u));
            }
            
            for (int v : adj[u]) {
                --inDegree[v];
                if (inDegree[v] == 0) {
                    q.push(v);
                }
            }
        }
        return res;
    }
};

Leetcode-2156

Wed, 17 Dec 2025 23:47:26 -0800

2156. Find Substring With Given Hash Value

The hash of a 0-indexed string s of length k, given integers p and m, is computed using the following function:

Where val(s[i]) represents the index of s[i] in the alphabet from val('a') = 1 to val('z') = 26.

You are given a string s and the integers power, modulo, k, and hashValue. Return sub, the first substring of s of length k such that hash(sub, power, modulo) == hashValue.

The test cases will be generated such that an answer always exists.

A substring is a contiguous non-empty sequence of characters within a string.

Example 1:

Input: s = "leetcode", power = 7, modulo = 20, k = 2, hashValue = 0 Output: "ee" Explanation: The hash of “ee” can be computed to be hash(“ee”, 7, 20) = (5 * 1 + 5 * 7) \pmod{20} = 40 \pmod{20} = 0. “ee” is the first substring of length 2 with hashValue 0. Hence, we return “ee”.

Example 2:

Input: s = "fbxzaad", power = 31, modulo = 100, k = 3, hashValue = 32 Output: "fbx" Explanation: The hash of “fbx” can be computed to be hash(“fbx”, 31, 100) = (6 * 1 + 2 * 31 + 24 * 31^2) \pmod{100} = 23132 \pmod{100} = 32. The hash of “bxz” can be computed to be hash(“bxz”, 31, 100) = (2 * 1 + 24 * 31 + 26 * 31^2) \pmod{100} = 25732 \pmod{100} = 32. “fbx” is the first substring of length 3 with hashValue 32. Hence, we return “fbx”. Note that “bxz” also has a hash of 32 but it appears later than “fbx”.

#include <iostream>
#include <cstring>

class Solution {
public:
    std::string subStrHash(std::string s, int power, int modulo, int k, int hashValue) {
        long long sum = 0, opt = 1;
        int n = s.length() - k;
        int res = n;
        for (int i = k - 1; i >= 0; --i) {
            sum = (sum * power + val(s[i + n])) % modulo;
            opt = (opt * power) % modulo;
        }
        
        for (int i = n - 1; i >= 0; --i) {
            sum = (sum * power + val(s[i])) % modulo;
            sum = (sum + modulo - val(s[i + k]) * opt % modulo) % modulo;
            if (sum == hashValue) {
                res = i;
            }
        }
        
        return s.substr(res, k);
    }
    
private:
    inline int val(char c) {
        return c - 'a' + 1;
    }
};

Leetcode-2187

Tue, 23 Dec 2025 14:20:30 -0800

Time complexity: $O(n\log M)$

#include <iostream>
#include <vector>

class Solution {
public:
    long long minimumTime(std::vector<int>& time, int totalTrips) {
        int n = time.size();
        if (n == 1) {
            return (long long)time[0] * totalTrips;
        }
        
        long long left, right, mid, sum = 0;
        int min_time = 0x3fff'ffff;
        for (int i : time) {
            min_time = std::min(i, min_time);
        }
        right = (long long)totalTrips * min_time + 1;
        left = (right - 1) / n;
        
        for (long long mid = (left + right) / 2; right > left; mid = (left + right) / 2) {
            if (maxTrips(time, mid, totalTrips)) {
                right = mid;
            }
            else {
                left = mid + 1;
            }
        }
        
        return left;
    }
    
private:
    bool maxTrips(std::vector<int>& time, long long t, int totalTrips) {
        int trips = 0;
        for (int i : time) {
            trips += t / i;
            if (trips >= totalTrips) {
                return true;
            }
        }
        return false;
    }
};

Leetcode-2226

Tue, 23 Dec 2025 14:38:55 -0800

Time complexity: $O(n\log M)$

#include <iostream>
#include <vector>

class Solution {
public:
    int maximumCandies(std::vector<int>& candies, long long k) {
        int left = 1, right = 0;
        for (int c : candies) {
            right = std::max(right, c);
        }
        
        for (int mid = (left + right) / 2; right >= left;) {
            if (check(candies, k, mid)) {
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
            mid = (left + right) / 2;
        }
        
        if (check(candies, k, left)) {
            return left;
        }
        return right;
    }
    
private:
    bool check(std::vector<int>& candies, long long k, int num) {
        for (int c : candies) {
            k -= c / num;
        }
        return k <= 0;
    }
};

Leetcode-2300

Tue, 23 Dec 2025 14:10:01 -0800

Time complexity: $O(N\log n+M\log m)$

#include <iostream>
#include <vector>
#include <algorithm>

class Solution {
public:
    std::vector<int> successfulPairs(std::vector<int>& spells, std::vector<int>& potions, long long success) {
        std::sort(potions.begin(), potions.end());
        int n = potions.size(), mid;
        for (int& spell : spells) {
            long long target = (success - 1) / spell + 1;
            int a = 0, b = n - 1;
            while (b > a) {
                mid = (a + b) / 2;
                if (potions[mid] >= target) {
                    b = mid;
                }
                else {
                    a = mid + 1;
                }
            }
            spell = (n - a) * (potions[a] >= target);
        }
        return spells;
    }
};

Leetcode-2392

Sun, 30 Nov 2025 22:08:06 -0800

#include <iostream>
#include <vector>
#include <queue>

class Solution {
    std::vector<int> tp_idx(int n, std::vector<std::vector<int>>& cond) {
        std::vector<std::vector<int>> adj(n);
        for (auto& e : cond) {
            adj[e[0] - 1].push_back(e[1] - 1);
        }
        
        std::vector<int> tpres;
        std::vector<int> inDegree(n, 0);
        for (int u = 0; u < n; ++u) {
            for (int v : adj[u]) {
                ++inDegree[v];
            }
        }
        
        std::queue<int> q;
        for (int i = 0; i < n; ++i) {
            if (inDegree[i] == 0) {
                q.push(i);
            }
        }
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            tpres.push_back(u);
            
            for (int v : adj[u]) {
                --inDegree[v];
                if (inDegree[v] == 0) {
                    q.push(v);
                }
            }
        }
        
        if (tpres.size() != n) {
            return {};
        }
        std::vector<int> res(n);
        for (int i = 0; i < n; ++i) {
            res[tpres[i]] = i;
        }
        return res;
    }
        
public:
    std::vector<std::vector<int>> buildMatrix(int k, std::vector<std::vector<int>>& rowConditions, std::vector<std::vector<int>>& colConditions) {
        std::vector<int> xs = tp_idx(k, rowConditions);
        std::vector<int> ys = tp_idx(k, colConditions);
        if (xs.size() == 0 || ys.size() == 0) {
            return {};
        }
        std::vector<std::vector<int>> res(k, std::vector<int>(k, 0));
        for (int i = 0; i < k; ++i) {
            res[xs[i]][ys[i]] = i + 1;
        }
        return res;
    }
};

Leetcode-2439

Tue, 23 Dec 2025 20:14:07 -0800

Time complexity: $O(|nums|)$

#include <iostream>
#include <vector>

class Solution {
public:
    int minimizeArrayValue(std::vector<int>& nums) {
        int i = 0;
        long long max_num = 0;
        long long sum = 0;
        for (int n : nums) {
            sum += n;
            ++i;
            if (sum) {
                max_num = std::max(max_num, (sum - 1) / i + 1);
            }
        }
        return max_num;
    }
};

Leetcode-2513

Tue, 23 Dec 2025 20:22:55 -0800

Time complexity: $O(1)$

#include <iostream>
#include <numeric>

class Solution {
public:
    int minimizeSet(int divisor1, int divisor2, int uniqueCnt1, int uniqueCnt2) {
        long long divisor0 = (long long)divisor1 / std::gcd(divisor1, divisor2) * divisor2;
        int a = (uniqueCnt1 - 1) / (divisor1 - 1) + uniqueCnt1;
        int b = (uniqueCnt2 - 1) / (divisor2 - 1) + uniqueCnt2;
        int c = (uniqueCnt1 + uniqueCnt2 - 1) / (divisor0 - 1) + uniqueCnt1 + uniqueCnt2;
        return std::max(c, std::max(a, b));
    }
};

Leetcode-2517

Tue, 23 Dec 2025 14:10:01 -0800

Time complexity: $O(n\log n(\log m-\log n))$

#include <iostream>
#include <vector>
#include <algorithm>

class Solution {
public:
    int maximumTastiness(std::vector<int>& price, int k) {
        int n = price.size();
        std::sort(price.begin(), price.end());
        int left = 0, right = (price.back() - price[0]) / (k - 1);
        
        while (right >= left) {
            int mid = (left + right) / 2;
            if (check(price, k, mid, n)) {
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
        }
        
        return right;
    }
    
private:
    bool check(std::vector<int>& price, int k, int min_diff, int n) {
        if (!min_diff) {
            return n >= k;
        }
        
        int prev = price[0], i = 0;
        while (--k) {
            i = std::lower_bound(price.begin() + i, price.end(), prev + min_diff) - price.begin();
            if (i >= n) {
                return false;
            }
            prev = price[i];
        }
        return true;
    }
};

Leetcode-2518

Mon, 29 Dec 2025 12:29:47 -0800

Time complexity: $O(nk)$

#include <iostream>
#include <vector>

const int M = 1'000'000'007;

class Solution {
public:
    int countPartitions(std::vector<int>& nums, int k) {
        long long sum = 0;
        for (int num : nums) {
            sum += num;
        }
        if (sum < 2 * k) {
            return 0;
        }
        
        int dp[1001] = { 0 };
        int res = 1;
        dp[0] = 2;
        
        for (int num : nums) {
            res *= 2;
            if (res >= M) {
                res -= M;
            }
            for (int i = k - 1; i >= num; --i) {
                if (dp[i - num]) {
                    dp[i] += dp[i - num];
                    if (dp[i] >= M) {
                        dp[i] -= M;
                    }
                }
            }
        }
        
        for (int i : dp) {
            res -= i;
            if (res < 0) {
                res += M;
            }
        }
        
        return res;
    }
};

Leetcode-2524

Wed, 17 Dec 2025 23:56:12 -0800

2524. Maximum Frequency Score of a Subarray

You are given an integer array nums and a positive integer k.

The frequency score of an array is the sum of the distinct values in the array raised to the power of their frequencies, taking the sum modulo 10^9 + 7.

For example, the frequency score of the array [5,4,5,7,4,4] is (4^3 + 5^2 + 7^1) modulo (10^9 + 7) = 96.

Return the maximum frequency score of a subarray of size k in nums. You should maximize the value under the modulo and not the actual value.

A subarray is a contiguous part of an array.

Example 1:

Input: nums = [1,1,1,2,1,2], k = 3 Output: 5 Explanation: The subarray [2,1,2] has a frequency score equal to 5. It can be shown that it is the maximum frequency score we can have.

Example 2:

Input: nums = [1,1,1,1,1,1], k = 4 Output: 1 Explanation: All the subarrays of length 4 have a frequency score equal to 1.

Constraints:

1 <= k <= nums.length <= 10^5
1 <= nums[i] <= 10^6

#include <iostream>
#include <vector>
#include <map>

const int M = 1000000007;

class Solution {
public:
    int maxFrequencyScore(std::vector<int>& nums, int k) {
        std::unordered_map<int, int> map;
        int n = nums.size();
        k = std::min(n, k);
        long long sum = 0;
        for (int i = 0; i < k; ++i) {
            sum = (sum + diff(map, nums[i])) % M;
            ++map[nums[i]];
        }
        long long max_sum = sum;
        
        for (int i = k; i < n; ++i) {
            --map[nums[i - k]];
            sum = (sum + M - diff(map, nums[i - k]) + diff(map, nums[i])) % M;
            ++map[nums[i]];
            max_sum = std::max(max_sum, sum);
        }
        return max_sum;
    }
    
private:
    long long pow_(long long base, long long exp_, long long mod) {
        long long res = 1;
        base = base % mod;
        while (exp_ > 0) {
            if (exp_ % 2 == 1) {
                res = (res * base) % mod;
            }
            base = (base * base) % mod;
            exp_ /= 2;
        }
        return res;
    }
    
    int diff(std::unordered_map<int, int>& map, int num) {
        long long diff;
        if (map[num] == 0) {
            diff = num % M;
        }
        else {
            diff = (M - pow_(num, map[num], M) + pow_(num, map[num] + 1, M)) % M;
        }
        return diff;
    }
};

Leetcode-2533

Thu, 25 Dec 2025 22:29:02 -0800

Time complexity: $O(maxLength)$

#include <iostream>
#include <vector>

const int M = 1'000'000'007;

class Solution {
public:
    int goodBinaryStrings(int minLength, int maxLength, int oneGroup, int zeroGroup) {
        std::vector<int> dp(maxLength + 1, 0);
        if (zeroGroup > oneGroup) {
            std::swap(zeroGroup, oneGroup);
        }
        
        int n = std::min(maxLength + 1, oneGroup + zeroGroup);
        for (int i = 0; i < n; i += zeroGroup) {
            dp[i] = 1;
        }
        dp[oneGroup] += 1;
        
        for (int i = oneGroup + 1; i <= maxLength; ++i) {
            dp[i] = (dp[i - zeroGroup] + dp[i - oneGroup]) % M;
        }
        
        long long res = 0;
        for (int i = minLength; i <= maxLength; ++i) {
            res += dp[i];
        }
        
        return res % M;
    }
};

Leetcode-2560

Tue, 23 Dec 2025 20:15:44 -0800

Time complexity: $O(n\log M)$

#include <iostream>
#include <vector>

class Solution {
public:
    int minCapability(std::vector<int>& nums, int k) {
        int left = 0x3fff'ffff, right = 0;
        for (int n : nums) {
            left = std::min(left, n);
            right = std::max(right, n);
        }
        
        for (int mid = (left + right) / 2; right >= left; ) {
            if (check(nums, k, mid)) {
                right = mid - 1;
            }
            else {
                left = mid + 1;
            }
            mid = (right + left) / 2;
        }
        
        return left;
    }
    
private:
    bool check(std::vector<int>& nums, int k, int max_num) {
        int last = false;
        for (int n : nums) {
            if (last || n > max_num) {
                last = false;
            }
            else {
                last = true;
                --k;
                if (k == 0) {
                    return true;
                }
            }
        }
        return false;
    }
};

Leetcode-2576

Tue, 23 Dec 2025 14:44:56 -0800

Time complexity: $O(n)$

#include <iostream>
#include <vector>
#include <algorithm>

class Solution {
public:
    int maxNumOfMarkedIndices(std::vector<int>& nums) {
        int n = nums.size();
        std::sort(nums.begin(), nums.end());
        
        int a = 0;
        for (int b = (n + 1) / 2; b < n; ++b) {
            if (nums[b] >= 2 * nums[a]) {
                ++a;
            }
        }
        
        return a * 2;
    }
};

Leetcode-2585

Mon, 29 Dec 2025 15:15:09 -0800

Time complexity: $O(target\cdot\sum(count))$

#include <iostream>
#include <vector>

const int M = 1'000'000'007;

class Solution {
public:
    int waysToReachTarget(int target, std::vector<std::vector<int>>& types) {
        std::vector<int> dp(target + 1);
        dp[0] = 1;
        for (auto& type : types) {
            int m = type[1];
            for (int i = target; i >= m; --i) {
                for (int c = 1; c <= type[0]; ++c) {
                    int j = i - c * m;
                    if (j >= 0) {
                        dp[i] = (dp[i] + dp[j]) % M;
                    }
                }
            }
        }
        return dp.back();
    }
};

Leetcode-2594

Tue, 23 Dec 2025 14:35:03 -0800

Time complexity: $O(n\log M)$

#include <iostream>
#include <vector>
#include <cmath>

class Solution {
public:
    long long repairCars(std::vector<int>& ranks, int cars) {
        int n = ranks.size();
        long long left = 1, right = 0x3fff'ffff;
        for (long long r : ranks) {
            right = std::min(right, r);
        }
        right *= (long long)cars * cars;
        
        for (long long mid = (left + right); right > left;) {
            if (check(ranks, cars, mid)) {
                right = mid;
            }
            else {
                left = mid + 1;
            }
            mid = (left + right) / 2;
        }
        
        return left;
    }
    
private:
    bool check(std::vector<int>& ranks, int cars, long long time) {
        for (int r : ranks) {
            cars -= (int)std::sqrt(time / r);
            if (cars <= 0) {
                return true;
            }
        }
        return false;
    }
};

Leetcode-2742

Mon, 29 Dec 2025 12:31:31 -0800

Time complexity: $O(n^2)$

#include <iostream>
#include <vector>

const int INF = 0x3fff'ffff;

class Solution {
public:
    int paintWalls(std::vector<int>& cost, std::vector<int>& time) {
        int n = cost.size();
        std::vector<int> dp(n + 1, INF);
        dp[0] = 0;
        int j;
        
        for (int i = 0; i < n; ++i) {
            for (j = n; j > time[i]; --j) {
                dp[j] = std::min(dp[j], dp[j - time[i] - 1] + cost[i]);
            }
            for (; j > 0; --j) {
                dp[j] = std::min(dp[j], cost[i]);
            }
        }
        
        return dp.back();
    }
};

Leetcode-2781

Fri, 19 Dec 2025 00:53:08 -0800

2781. Length of the Longest Valid Substring

You are given a string word and an array of strings forbidden.

A string is called valid if none of its substrings are present in forbidden.

Return *the length of the longest valid substring of the string word*.

A substring is a contiguous sequence of characters in a string, possibly empty.

Example 1:

Input: word = "cbaaaabc", forbidden = ["aaa","cb"] Output: 4 Explanation: There are 11 valid substrings in word: “c”, “b”, “a”, “ba”, “aa”, “bc”, “baa”, “aab”, “ab”, “abc” and “aabc”. The length of the longest valid substring is 4. It can be shown that all other substrings contain either “aaa” or “cb” as a substring.

Example 2:

Input: word = "leetcode", forbidden = ["de","le","e"] Output: 4 Explanation: There are 11 valid substrings in word: “l”, “t”, “c”, “o”, “d”, “tc”, “co”, “od”, “tco”, “cod”, and “tcod”. The length of the longest valid substring is 4. It can be shown that all other substrings contain either “de”, “le”, or “e” as a substring.

Constraints:

1 <= word.length <= 10^5
word consists only of lowercase English letters.
1 <= forbidden.length <= 10^5
1 <= forbidden[i].length <= 10
forbidden[i] consists only of lowercase English letters.

#include <iostream>
#include <cstring>
#include <vector>
#include <queue>

struct Node {
    Node* c[26];
    bool isEnd;
    
    Node() {
        isEnd = false;
        for (int i = 0; i < 26; ++i) {
            c[i] = nullptr;
        }
    }
};

class Solution {
public:
    int longestValidSubstring(std::string word, std::vector<std::string>& forbidden) {
        root = new Node();
        for (string& word : forbidden) {
            insert(word);
        }
        
        int n = word.length(), left = 0, max_len = 0;
        std::queue<std::pair<int, Node*>> q;
        for (int i = 0; i < n; ++i) {
            int idx = word[i] - 'a';
            int q_size = q.size();
            while (q_size--) {
                int start = q.front().first;
                Node* curr = q.front().second;
                q.pop();
                if (start < left) {
                    continue;
                }
                if (curr->c[idx] != nullptr) {
                    Node* next = curr->c[idx];
                    if (next->isEnd) {
                        left = std::max(left, start + 1);
                    }
                    else {
                        q.push({start, next});
                    }
                }
            }
            
            if (root->c[idx] != nullptr) {
                Node* next = root->c[idx];
                if (next->isEnd) {
                    left = std::max(left, i + 1);
                }
                else {
                    q.push({i, next});
                }
            }
            
            max_len = std::max(max_len, i - left + 1);
        }
        return max_len;
    }
    
private:
    void insert(std::string& word) {
        Node* node = root;
        for (char c : word) {
            int idx = c - 'a';
            if (node->c[idx] == nullptr) {
                node->c[idx] = new Node();
            }
            node = node->c[idx];
        }
        node->isEnd = true;
    }
    
    Node* root;
};

Leetcode-2787

Fri, 26 Dec 2025 16:57:47 -0800

Time complexity: $O(n^{1+\frac{1}{x}})$

#include <iostream>
#include <cmath>

const int M = 1'000'000'007;

class Solution {
public:
    int numberOfWays(int n, int x) {
        long long dp[301] = { 0 };
        dp[0] = 1;
        
        for (int i = 1; i <= n; ++i) {
            int b = std::pow(i, x);
            if (b > n) {
                break;
            }
            for (int c = n; c >= b; --c) {
                dp[c] += dp[c - b];
            }
        }
        
        return dp[n] % M;
    }
};

Leetcode-2812

Tue, 23 Dec 2025 14:10:01 -0800

Time complexity: $O(n^2\log n)$

#include <iostream>
#include <vector>
#include <queue>
#include <cmath>

class Solution {
public:
    int maximumSafenessFactor(std::vector<std::vector<int>>& grid) {
        if (grid[0][0] || grid.back().back()) {
            return 0;
        }
        
        int n = grid.size();
        std::vector<std::vector<int>> factor(n, std::vector<int>(n, 0x7fff'ffff));
        std::queue<std::pair<int, std::pair<int, int>>> q;
        
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j]) {
                    q.push({0, {i, j}});
                    factor[i][j] = 0;
                }
            }
        }
        
        int dirs[4][2] = { {1, 0}, {0, 1}, {-1, 0}, {0, -1} };
        while (!q.empty()) {
            int f = q.front().first;
            int x = q.front().second.first;
            int y = q.front().second.second;
            q.pop();
            if (f > factor[x][y]) {
                continue;
            }
            
            ++f;
            for (auto& dir : dirs) {
                int xx = x + dir[0];
                int yy = y + dir[1];
                if (xx < 0 || xx >= n || yy < 0 || yy >= n) {
                    continue;
                }
                if (f < factor[xx][yy]) {
                    factor[xx][yy] = f;
                    q.push({f, {xx, yy}});
                }
            }
        }
        
        std::priority_queue<std::pair<int, std::pair<int, int>>> pq;
        std::vector<std::vector<int>> visited(n, std::vector<int>(n, 0));
        pq.push({factor[0][0], {0, 0}});
        visited[0][0] = factor[0][0];
        
        while (!pq.empty()) {
            int f = pq.top().first;
            int x = pq.top().second.first;
            int y = pq.top().second.second;
            if (x == n - 1 && y == n - 1) {
                return f;
            }
            pq.pop();
            if (f < visited[x][y]) {
                continue;
            }
            for (auto& dir : dirs) {
                int xx = x + dir[0];
                int yy = y + dir[1];
                if (xx < 0 || xx >= n || yy < 0 || yy >= n) {
                    continue;
                }
                int nf = std::min(f, factor[xx][yy]);
                if (nf > visited[xx][yy]) {
                    visited[xx][yy] = nf;
                    pq.push({nf, {xx, yy}});
                }
            }
        }
        
        return 0;
    }
};

Leetcode-2841

Wed, 17 Dec 2025 02:40:00 -0800

2841. Maximum Sum of Almost Unique Subarray

You are given an integer array nums and two positive integers m and k.

Return the maximum sum out of all almost unique subarrays of length k of nums. If no such subarray exists, return 0.

A subarray of nums is almost unique if it contains at least m distinct elements.

A subarray is a contiguous non-empty sequence of elements within an array.

Example 1:

Input: nums = [2,6,7,3,1,7], m = 3, k = 4 Output: 18 Explanation: There are 3 almost unique subarrays of size k = 4. These subarrays are [2, 6, 7, 3], [6, 7, 3, 1], and [7, 3, 1, 7]. Among these subarrays, the one with the maximum sum is [2, 6, 7, 3] which has a sum of 18.

Example 2:

Input: nums = [5,9,9,2,4,5,4], m = 1, k = 3 Output: 23 Explanation: There are 5 almost unique subarrays of size k. These subarrays are [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5], and [4, 5, 4]. Among these subarrays, the one with the maximum sum is [5, 9, 9] which has a sum of 23.

Example 3:

Input: nums = [1,2,1,2,1,2,1], m = 3, k = 3 Output: 0 Explanation: There are no subarrays of size k = 3 that contain at least m = 3 distinct elements in the given array [1,2,1,2,1,2,1]. Therefore, no almost unique subarrays exist, and the maximum sum is 0.

#include <iostream>
#include <vector>
#include <map>

class Solution {
public:
    long long maxSum(std::vector<int>& nums, int m, int k) {
		int n = nums.size();
		if (n < k || k < m) {
			return 0;
		}
		
		int unique_num = 0;
        long long sum = 0;
		std::unordered_map<int, int> map;
		for (int i = 0; i < k; ++i) {
			if (map[nums[i]] == 0) {
				++unique_num;
			}
			++map[nums[i]];
			sum += nums[i];
		}
		
		long long max_sum = 0;
		if (unique_num >= m) {
			max_sum = sum;
		}
		
		for (int i = k; i < n; ++i) {
			--map[nums[i - k]];
			if (map[nums[i - k]] == 0) {
				--unique_num;
			}
			sum -= nums[i - k];
			
			if (map[nums[i]] == 0) {
				++unique_num;
			}
			++map[nums[i]];
			sum += nums[i];
			
			if (unique_num >= m) {
				max_sum = std::max(max_sum, sum);
			}
		}
		
		return max_sum;
    }
};

Leetcode-2902

Wed, 31 Dec 2025 10:26:41 -0800

Time complexity: $O(nr)$

#include <iostream>
#include <vector>
#include <cstring>
#include <unordered_map>
#include <queue>

const int M = 1'000'000'007;

class Solution {
public:
    int countSubMultisets(std::vector<int>& nums, int l, int r) {
        std::vector<int> dp(r + 1, 0);
        std::unordered_map<int, int> occ;
        
        for (int num : nums) {
            ++occ[num];
        }
        
        dp[0] = 1;
        for (auto& pair : occ) {
            if (!pair.first) {
                continue;
            }
            int offset = (1 + pair.second) * pair.first;
            std::queue<int> q;
            for (int i = 0; i <= r; ++i) {
                if (i + offset <= r) {
                    q.push(dp[i]);
                }
                if (i >= pair.first) {
                    dp[i] = (dp[i] + dp[i - pair.first]) % M;
                }
                if (i >= offset) {
                    dp[i] = (dp[i] + M - q.front()) % M;
                    q.pop();
                }
            }
        }
        
        long long res = 0;
        for (int i = l; i <= r; ++i) {
            res += dp[i];
        }
        
        return (res * (occ[0] + 1)) % M;
    }
};

Leetcode-2915

Fri, 26 Dec 2025 16:55:46 -0800

Time complexity: $O(target\cdot|nums|)$

#include <iostream>
#include <vector>

class Solution {
public:
    int lengthOfLongestSubsequence(std::vector<int>& nums, int target) {
        std::vector<int> dp(target + 1, -1);
        dp[0] = 0;
        
        for (int num : nums) {
            for (int i = target; i >= num; --i) {
                if (dp[i - num] >= 0) {
                    dp[i] = std::max(dp[i - num] + 1, dp[i]);
                }
            }
        }
        
        return dp.back();
    }
};

Leetcode-2953

Wed, 17 Dec 2025 23:53:14 -0800

2953. Count Complete Substrings

You are given a string word and an integer k.

A substring s of word is complete if:

Each character in s occurs exactly k times.
The difference between two adjacent characters is at most 2. That is, for any two adjacent characters c1 and c2 in s, the absolute difference in their positions in the alphabet is at most 2.

Return the number of complete substrings of word.

A substring is a non-empty contiguous sequence of characters in a string.

Example 1:

Input: word = "igigee", k = 2 Output: 3 Explanation: The complete substrings where each character appears exactly twice and the difference between adjacent characters is at most 2 are: igigee, igigee, igigee.

Example 2:

Input: word = "aaabbbccc", k = 3 Output: 6 Explanation: The complete substrings where each character appears exactly three times and the difference between adjacent characters is at most 2 are: aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc, aaabbbccc.

Constraints:

1 <= word.length <= 10^5
word consists only of lowercase English letters.
1 <= k <= word.length

#include <iostream>
#include <cstring>

class Solution {
public:
    int countCompleteSubstrings(std::string word, int k) {
        int n = word.length(), res = 0;
        int left = 0;
        for (int right = 1; right < n; ++right) {
            if (std::abs(word[right] - word[right - 1]) > 2) {
                res += countComplete(word.substr(left, right - left), k);
                left = right;
            }
        }
        res += countComplete(word.substr(left, n - left), k);
        return res;
    }

private:
    bool isComplete(int* times, int k) {
        for (int i = 0; i < 26; ++i) {
            if (times[i] && times[i] != k) {
                return false;
            }
        }
        return true;
    }
    
    int countComplete(std::string word, int k) {
        int n = word.size(), num = 0;
        int maxw = std::min(n, 26 * k);
        for (int w = k; w <= maxw; w += k) {
            int times[26] = { 0 };
            for (int i = 0; i < w; ++i) {
                ++times[word[i] - 'a'];
            }
            num += isComplete(times, k);
            for (int i = w; i < n; ++i) {
                ++times[word[i] - 'a'];
                --times[word[i - w] - 'a'];
                num += isComplete(times, k);
            }
        }
        return num;
    }
};

Leetcode-2959

Tue, 25 Nov 2025 23:36:44 -0800

#include <iostream>
#include <vector>
#include <algorithm>

const int INF = 0x3fff'ffff;

class Solution {
public:
    int numberOfSets(int n, int maxDistance, std::vector<std::vector<int>>& roads) {
        int res = 0, num = (1 << n);
        bool opened[1024] = { 0 };
        std::vector<std::vector<int>> dist(n, std::vector<int>(n, INF));
        
        for (int mask = 0; mask < num; ++mask) {
            for (int i = 0; i < n; ++i) {
                opened[i] = (mask & (1 << i)) == 0;
            }
            for (auto& ln : dist) {
                std::fill(ln.begin(), ln.end(), INF);
            }
            for (auto& e : roads) {
                if (opened[e[0]] && opened[e[1]]) {
                    dist[e[0]][e[1]] = std::min(dist[e[0]][e[1]], e[2]);
                    dist[e[1]][e[0]] = std::min(dist[e[1]][e[0]], e[2]);
                }
            }
            
            for (int k = 0; k < n; ++k) {
                if (!opened[k]) {
                    continue;
                }
                for (int i = 0; i < n; ++i) {
                    if (!opened[i]) {
                        continue;
                    }
                    for (int j = 0; j < n; ++j) {
                        if (!opened[i]) {
                            continue;
                        }
                        dist[i][j] = std::min(dist[i][j], dist[i][k] + dist[k][j]);
                    }
                }
            }
            
            ++res;
            for (int ij = 0; ij < n * n; ++ij) {
                if (!opened[ij / n] || !opened[ij % n]) {
                    continue;
                }
                if (ij / n == ij % n) {
                    continue;
                }
                if (dist[ij / n][ij % n] > maxDistance) {
                    --res;
                    std::cout << mask << " " << ij << std::endl;
                    break;
                }
            }
        }
        return res;
    }
};

Leetcode-2968

Fri, 19 Dec 2025 00:50:12 -0800

2968. Apply Operations to Maximize Frequency Score

You are given a 0-indexed integer array nums and an integer k.

You can perform the following operation on the array at most k times:

Choose any index i from the array and increase or decrease nums[i] by 1.

The score of the final array is the frequency of the most frequent element in the array.

Return the maximum score you can achieve.

The frequency of an element is the number of occurrences of that element in the array.

Example 1:

Input: nums = [1,2,6,4], k = 3 Output: 3 Explanation: We can do the following operations on the array:

Choose i = 0, and increase the value of nums[0] by 1. The resulting array is [2,2,6,4].

Choose i = 3, and decrease the value of nums[3] by 1. The resulting array is [2,2,6,3].

Choose i = 3, and decrease the value of nums[3] by 1. The resulting array is [2,2,6,2]. The element 2 is the most frequent in the final array so our score is 3. It can be shown that we cannot achieve a better score.

Example 2:

Input: nums = [1,4,4,2,4], k = 0 Output: 3 Explanation: We cannot apply any operations so our score will be the frequency of the most frequent element in the original array, which is 3.

Constraints:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
0 <= k <= 10^14

#include <iostream>
#include <vector>
#include <algorithm>

class Solution {
public:
    int maxFrequencyScore(std::vector<int>& nums, long long k) {
        int n = nums.size();
        std::sort(nums.begin(), nums.end());
        int res = 0, left = 0;
        long long cur = 0;
        
        for (int right = 0; right < n; ++right) {
            cur += nums[right] - nums[(left + right) / 2];
            while (cur > k) {
                cur += nums[left];
                ++left;
                cur -= nums[(left + right) / 2];
            }
            res = std::max(res, right - left);
        }
        return res + 1;
    }
};

Leetcode-2976

Mon, 24 Nov 2025 12:40:24 -0800

#include <iostream>
#include <cstring>
#include <vector>

const int INF = 0x3fff'ffff;

class Solution {
public:
    long long minimumCost(std::string source, std::string target, std::vector<char>& original, std::vector<char>& changed, std::vector<int>& cost) {
        std::vector<std::vector<int>> dist(26, std::vector<int>(26, INF));
        for (int i = 0; i < original.size(); ++i) {
            dist[original[i] - 'a'][changed[i] - 'a'] = std::min(dist[original[i] - 'a'][changed[i] - 'a'], cost[i]);
        }
        
        for (int k = 0; k < 26; ++k) {
            for (int i = 0; i < 26; ++i) {
                for (int j = 0; j < 26; ++j) {
                    if (i != j && dist[i][k] < INF && dist[k][j] < INF) {
                        dist[i][j] = std::min(dist[i][j], dist[i][k] + dist[k][j]);
                    }
                }
            }
        }
        
        long long int res = 0;
        for (int i = 0; i < source.length(); ++i) {
            if (source[i] == target[i]) {
                continue;
            }
            int cost = dist[source[i] - 'a'][target[i] - 'a'];
            if (cost < INF) {
                res += cost;
            }
            else {
                return -1;
            }
        }
        return res;
    }
};

Leetcode-2982

Tue, 23 Dec 2025 14:42:38 -0800

Time complexity: $O(n)$

#include <iostream>
#include <cstring>

class Solution {
public:
    int maximumLength(std::string s) {
        int n = s.length();
        int cnt = 0;
        int cnts[26][3] = { 0 };
        for (int i = 0; i < n; ++i) {
            ++cnt;
            if (i + 1 == n || s[i] != s[i + 1]) {
                int idx = s[i] - 'a';
                for (int j = 0; j < 3; ++j) {
                    if (cnts[idx][j] < cnt) {
                        for (int k = 2; k > j; --k) {
                            cnts[idx][k] = cnts[idx][k - 1];
                        }
                        cnts[idx][j] = cnt--;
                    }
                }
                cnt = 0;
            }
        }
        
        int res = 0;
        for (int i = 0; i < 26; ++i) {
            res = std::max(res, cnts[i][2]);
        }
        return res == 0 ? -1 : res;
    }
};

Leetcode-2998

Sat, 29 Nov 2025 19:39:10 -0800

#include <iostream>
#include <queue>
#include <vector>

const int INF = 0x3fff'ffff;

int div_11(int x) {
    int y = x / 11;
    if (x == y * 11) {
        return y;
    }
    return 0;
}

int div_5(int x) {
    int y = x / 5;
    if (x == y * 5) {
        return y;
    }
    return 0;
}

int plus_1(int x) {
    return ++x;
}

int minus_1(int x) {
    return --x;
}

class Solution {
public:
    int minimumOperationsToMakeEqual(int x, int y) {
        if (x <= y) {
            return y - x;
        }
        int nmax = x * 11, tmp;
        int (*fcns[])(int) = { div_11, div_5, minus_1, plus_1 };
        std::vector<int> dist(nmax + 1, INF);
        std::queue<int> q;
        q.push(x);
        dist[x] = 0;
        while (true) {
            int u = q.front();
            q.pop();
            for (auto& f : fcns) {
                int v = f(u);
                if (v < 1 || v > nmax) {
                    continue;
                }
                if (v == y) {
                    return dist[u] + 1;
                }
                if (dist[v] == INF) {
                    dist[v] = dist[u] + 1;
                    q.push(v);
                }
            }
        }
        return -1;
    }
};

Leetcode-3082

Mon, 29 Dec 2025 12:24:00 -0800

Time complexity: $O(nk)$

#include <iostream>
#include <vector>

const int M = 1'000'000'007;

class Solution {
public:
    int sumOfPower(std::vector<int>& nums, int k) {
        std::vector<long long> dp(k + 1);
        dp[0] = 1;
        
        for (int num : nums) {
            for (int i = k; i >= 0; --i) {
                if (i >= num) {
                    if (dp[i] || dp[i - num]) {
                        dp[i] = (dp[i] * 2 + dp[i - num]) % M;
                    }
                }
                else if (dp[i]) {
                    dp[i] = dp[i] * 2 % M;
                }
            }
        }
        
        return dp.back();
    }
};

Leetcode-3143

Tue, 23 Dec 2025 14:53:48 -0800

Time complexity: $O(n)$

#include <iostream>
#include <vector>
#include <cstring>

class Solution {
public:
    int maxPointsInsideSquare(std::vector<std::vector<int>>& points, std::string s) {
        int n = points.size();
        std::vector<std::pair<int, int>> dist(n);
        for (int i = 0; i < n; ++i) {
            dist[i].first = std::max(std::abs(points[i][0]), std::abs(points[i][1]));
            dist[i].second = s[i] - 'a';
        }
        std::sort(dist.begin(), dist.end());
        
        int visited[26] = { 0 };
        int last = -1, max_idx = 0;
        int m = std::min(26, n);
        for (int i = 0; i < m; ++i) {
            if (visited[dist[i].second] == 0) {
                visited[dist[i].second] = 1;
                if (dist[i].first != last) {
                    max_idx = i;
                    last = dist[i].first;
                }
            }
            else {
                if (dist[i].first != last) {
                    return i;
                }
                return max_idx;
            }
        }
        return m;
    }
};

Leetcode-3180

Fri, 26 Dec 2025 21:35:39 -0800

Time complexity: $O(mn)$

#include <iostream>
#include <vector>
#include <algorithm>

class Solution {
public:
    int maxTotalReward(std::vector<int>& rewardValues) {
        std::sort(rewardValues.begin(), rewardValues.end());
        int n = rewardValues.size();
        int m = rewardValues.back();
        std::vector<int> dp(2 * m);
        
        dp[0] = 1;
        for (int i : rewardValues) {
            for (int j = 2 * i - 1; j >= i; --j) {
                dp[j] |= dp[j - i];
            }
        }
        
        for (int i = 2 * m - 1; i >= 0; --i) {
            if (dp[i]) {
                return i;
            }
        }
        
        return -1;
    }
};

Leetcode-3181

Mon, 29 Dec 2025 12:36:39 -0800

Time complexity: $O(nk)$

#include <iostream>
#include <vector>
#include <algorithm>
#include <bitset>

class Solution {
public:
    int maxTotalReward(vector<int>& rewardValues) {
        int n = rewardValues.size();
        std::sort(rewardValues.begin(), rewardValues.end());
        rewardValues.erase(std::unique(rewardValues.begin(), rewardValues.end()), rewardValues.end());
        
        const int k = 50000 * 2;
        std::bitset<k> dp;
        
        dp[0] = 1;
        for (int r : rewardValues) {
            int shift = k - r;
            dp |= ((dp << shift) >> shift) << r;
        }
        
        for (int i = k - 1; i >= 0; --i) {
            if (dp[i]) {
                return i;
            }
        }
        
        return 0;
    }
};

Leetcode-3183

Mon, 29 Dec 2025 15:13:13 -0800

Time complexity: $O(1)$

#include <iostream>

const int M = 1'000'000'007;

class Solution {
public:
    int numberOfWays(int n) {
        if (n < 4) {
            return g(n);
        }
        if (n < 8) {
            return (g(n) + g(n - 4)) % M;
        }
        return ((g(n) + g(n - 4)) % M + g(n - 8)) % M;
    }
    
    int g(int n) {
        long long k = n / 6;
        long long res = (k + 1) * (2 * (n / 2) - 3 * k + 2) / 2;
        return res % M;
    }

    /*
    int f(int n) {
        return n / 2 + 1;
    }
    
    int g(int n) {
        int k = n / 6;
        int sum = 0;
        for (int i = 0; i <= k; ++i) {
            sum = (sum + f(n - i * 6)) % M;
        }
        return sum;
    }
    
    int h(int n) {
        if (n < 4) {
            return g(n);
        }
        if (n < 8) {
            return (g(n) + g(n - 4)) % M;
        }
        return ((g(n) + g(n - 4)) % M + g(n - 8)) % M;
    }
    */
};
};

Leetcode-3243

Thu, 27 Nov 2025 01:30:07 -0800

#include <iostream>
#include <vector>
#include <numeric>

class Solution {
public:
    std::vector<int> shortestDistanceAfterQueries(int n, std::vector<std::vector<int>>& queries) {
        int m = queries.size();
        std::vector<int> dp(n);
        std::iota(dp.begin(), dp.end(), 0);
        std::vector<std::vector<int>> adj(n);
        std::vector<int> res(m);
        
        for (int i = 0; i < m; ++i) {
            adj[queries[i][1]].push_back(queries[i][0]);
            if (dp[queries[i][0]] + 1 < dp[queries[i][1]]) {
               dp[queries[i][1]] = dp[queries[i][0]] + 1;
               for (int j = queries[i][1] + 1; j < n; ++j) {
                   dp[j] = std::min(dp[j], dp[j - 1] + 1);
                   for (auto& k : adj[j]) {
                       dp[j] = std::min(dp[j], dp[k] + 1);
                   }
               }
            }
            res[i] = dp.back();
        }        
        return res;
    }
};

Leetcode-3281

Wed, 24 Dec 2025 19:43:56 -0800

Time complexity: $O(n(\log M-\log n))$

#include <iostream>
#include <vector>
#include <algorithm>

class Solution {
public:
    int maxPossibleScore(std::vector<int>& start, int d) {
        std::sort(start.begin(), start.end());
        int n = start.size();
        long long left = 0, right = (start.back() - start[0] + d) / (n - 1) + 1;
        
        while (right >= left) {
            long long mid = (left + right) / 2;
            long long prev = start[0];
            bool valid = true;
            for (int i = 1; i < n; ++i) {
                prev = std::max(prev + mid, (long long)start[i]);
                if (prev - start[i] > d) {
                    valid = false;
                    break;
                }
            }
            
            if (valid) {
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
        }
        
        return right;
    }
};

Leetcode-3287

Mon, 29 Dec 2025 12:34:31 -0800

Time complexity: $O(nk)$

#include <iostream>
#include <vector>

class Solution {
public:
    int maxValue(std::vector<int>& nums, int k) {
        int A[400][128] = { 0 }, AA[201][128] = { 0 };
        int B[400][128] = { 0 }, BB[201][128] = { 0 };
        AA[0][0] = BB[0][0] = true;
        
        int n = nums.size();
        for (int i = 0; i < nums.size(); ++i) {
            for (int j = std::min(k - 1, i + 1); j >= 0; --j) {
                for (int c = 0; c < 128; ++c) {
                    if (AA[j][c]) {
                        AA[j + 1][nums[i] | c] = true;
                    }
                    if (BB[j][c]) {
                        BB[j + 1][nums[n - i - 1] | c] = true;
                    }
                }
            }
            
            for (int c = 0; c < 128; ++c) {
                if (AA[k][c]) {
                    A[i][c] = true;
                }
                if (BB[k][c]) {
                    B[i][c] = true;
                }
            }
        }
        
        int res = 0;
        for (int i = k - 1; i < n - k; ++i) {
            for (int c1 = 0; c1 < 128; ++c1) {
                if (!A[i][c1]) {
                    continue;
                }
                for (int c2 = 0; c2 < 128; ++c2) {
                    if (B[n - i - 2][c2]) {
                        res = std::max(c1 ^ c2, res);
                    }
                }
            }
        }
        
        return res;
    }
};

Leetcode-3290

Wed, 31 Dec 2025 10:33:54 -0800

Time complexity: $O(n)$

#include <iostream>
#include <vector>

class Solution {
public:
    long long maxScore(std::vector<int>& a, std::vector<int>& b) {
        long long sum[5] = { 0, 
            (long long)0xC000'0000'0000'0001, (long long)0xC000'0000'0000'0001,
            (long long)0xC000'0000'0000'0001, (long long)0xC000'0000'0000'0001
        };
        
        int n = b.size();
        for (int i = 0; i < n; ++i) {
            for (int j = 3; j >=0; --j) {
                sum[j + 1] = std::max(sum[j + 1], sum[j] + (long long)a[j] * b[i]);
            }
        }
        
        return sum[4];
    }
};

Leetcode-3333

Mon, 29 Dec 2025 15:17:32 -0800

Time complexity: $O(nk)$

#include <iostream>
#include <cstring>

const int M = 1'000'000'007;

class Solution {
public:
    int possibleStringCount(std::string word, int k) {
        long long tot = 1;
        int len = 0;
        char prev = word[0];
        dp[0] = 1;
        int cnt = 0;
        
        for (char c : word) {
            if (c == prev) {
                ++len;
            }
            else {
                tot = (tot * len) % M;
                ++cnt;
                if (cnt < k) {
                    process(len, k);
                }
                len = 1;
                prev = c;
            }
        }
        tot = (tot * len) % M;
        if (cnt >= k) {
            return tot;
        }
        
        process(len, k);
        for (int i : dp) {
            tot = (tot + M - i) % M;
        }
        
        return tot;
    }
    
private:
    void process(int len, int k) {
        std::swap(dp, tmp);
        dp[0] = 0;
        for (int i = 1; i < k; ++i) {
            dp[i] = (dp[i - 1] + tmp[i - 1]) % M;
            if (i - len > 0) {
                dp[i] = (dp[i] + M - tmp[i - len - 1]) % M;
            }
        }
    }
    
    int dp[2001] = { 0 }, tmp[2001];
};

Leetcode-3363

Fri, 26 Dec 2025 16:52:05 -0800

Time complexity: $O(n^2)$

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

class Solution {
public:
    int maxCollectedFruits(std::vector<std::vector<int>>& fruits) {
        int n = fruits.size();
        int sum = 0;
        for (int i = 0; i < n; ++i) {
            sum += fruits[i][i];
            fruits[i][i] = 0;
        }
        
        std::vector<int> dp(n + 2, 0x8000'0000);
        std::vector<int> tmp(n + 2);
        dp[n] = fruits[0].back();
        for (int i = 1; i < n; ++i) {
            std::swap(dp, tmp);
            for (int j = 1; j <= n; ++j) {
                dp[j] = std::max(std::max(tmp[j - 1], tmp[j]), tmp[j + 1]) + fruits[i][j - 1];
            }
        }
        sum += dp[n];
        
        std::fill(dp.begin(), dp.end(), 0x8000'0000);
        dp[n] = fruits.back()[0];
        for (int i = 1; i < n; ++i) {
            std::swap(dp, tmp);
            for (int j = 1; j <= n; ++j) {
                dp[j] = std::max(std::max(tmp[j - 1], tmp[j]), tmp[j + 1]) + fruits[j - 1][i];
            }
        }
        sum += dp[n];
        
        return sum;
    }
};

Leetcode-3381

Thu, 25 Dec 2025 22:31:55 -0800

Time complexity: $O(n)$

#include <iostream>
#include <vector>
#include <cmath>

class Solution {
public:
    long long maxSubarraySum(std::vector<int>& nums, int k) {
        int n = nums.size();
        std::vector<long long> dp(n);
        long long diff = 0;
        for (int i = 0; i < k; ++i) {
            diff += nums[i];
        }
        long long max_sum = dp[k - 1] = diff;
        
        for (int i = k; i < n; ++i) {
            diff += nums[i] - nums[i - k];
            dp[i] = std::max(dp[i - k], 0ll) + diff;
            max_sum = std::max(max_sum, dp[i]);
        }
        
        return max_sum;
    }
};

Leetcode-3399

Tue, 23 Dec 2025 20:19:38 -0800

Time complexity: $O(n\log n)$

#include <iostream>
#include <cstring>
#include <set>

class Solution {
public:
    int minLength(std::string s, int numOps) {
        int cnt0 = 0, cnt1 = 0, k = 0;
        for (char c : s) {
            k = 1 - k;
            if (k == c - '0') {
                ++cnt0;
            }
            else {
                ++cnt1;
            }
        }
        if (cnt0 <= numOps || cnt1 <= numOps) {
            return 1;
        }
        
        int n = s.length();
        int left = 2, right = n;
        for (int mid = (left + right) / 2; right >= left; ) {
            if (check(s, numOps, mid)) {
                right = mid - 1;
            }
            else {
                left = mid + 1;
            }
            mid = (left + right) / 2;
        }
        return left;
    }
    
private:
    int check(std::string& s, int numOps, int sublen) {
        int curlen = 0;
        char prev = s[0];
        for (char c : s) {
            if (c == prev) {
                ++curlen;
            }
            else {
                numOps -= curlen / (sublen + 1);
                curlen = 1;
                prev = c;
            }
        }
        numOps -= curlen / (sublen + 1);
        return numOps >= 0;
    }
};

Leetcode-3439

Wed, 17 Dec 2025 23:39:26 -0800

3439. Reschedule Meetings for Maximum Free Time I

You are given an integer eventTime denoting the duration of an event, where the event occurs from time t = 0 to time t = eventTime.

You are also given two integer arrays startTime and endTime, each of length n. These represent the start and end time of n non-overlapping meetings, where the ith meeting occurs during the time [startTime[i], endTime[i]].

You can reschedule at most k meetings by moving their start time while maintaining the same duration, to maximize the longest continuous period of free time during the event.

The relative order of all the meetings should stay the same and they should remain non-overlapping.

Return the maximum amount of free time possible after rearranging the meetings.

Note that the meetings can not be rescheduled to a time outside the event.

#include <iostream>
#include <vector>

class Solution {
public:
    int maxFreeTime(int eventTime, int k, std::vector<int>& startTime, std::vector<int>& endTime) {
        int n = startTime.size();
        startTime.push_back(eventTime);
        k = std::min(k, n);
        
        int cur_total = 0;
        for (int i = 0; i < k; ++i) {
            cur_total += endTime[i] - startTime[i];
        }
        int max_interval = startTime[k] - cur_total;
        
        for (int i = k; i < n; ++i) {
            cur_total += startTime[i - k]; // cur_total - (endTime[i - k] - startTime[i - k]) + endTime[i - k];
            cur_total += endTime[i] - startTime[i];
            max_interval = std::max(max_interval, startTime[i + 1] - cur_total);
            cur_total -= endTime[i - k];
        }
        
        return max_interval;
    }
};

Leetcode-3459

Fri, 26 Dec 2025 16:53:49 -0800

Time complexity: $O(mn)$

#include <iostream>
#include <vector>

class Solution {
public:
    int lenOfVDiagonal(std::vector<std::vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        
        std::memset(lens, 0, sizeof(lens));
        // lens.resize(m, std::vector<std::vector<std::pair<int, int>>>(n, std::vector<std::pair<int, int>>(4, std::pair<int, int>({0, 0}))));
        int max_len = 0;
        
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == 1) {
                    for (int k = 0; k < 4; ++k) {
                        max_len = std::max(max_len, DFS(grid, m, n, i, j, k, 1));
                    }
                }
            }
        }
        
        return max_len;
    }
    
private:
    int DFS(std::vector<std::vector<int>>& grid, int m, int n, int i, int j, int k, int t) {
        int ii = i + dirs[k][0];
        int jj = j + dirs[k][1];
        if (!lens[i][j][k].first) {
            lens[i][j][k].first = 1;
            if (ii >= 0 && ii < m && jj >= 0 && jj < n && (grid[i][j] * 2 - 3) * (grid[ii][jj] - 1) < 0) {
                lens[i][j][k].first += DFS(grid, m, n, ii, jj, k, 0);
            }
        }
        
        if (t) {
            if (!lens[i][j][k].second) {
                lens[i][j][k].second = 1;
                if (ii >= 0 && ii < m && jj >= 0 && jj < n && (grid[i][j] * 2 - 3) * (grid[ii][jj] - 1) < 0) {
                    lens[i][j][k].second += DFS(grid, m, n, ii, jj, k, 1);
                }
                lens[i][j][k].second = std::max(lens[i][j][k].second, DFS(grid, m, n, i, j, (k + 1) % 4, 0));
            }
            return lens[i][j][k].second;
        }
        else {
            return lens[i][j][k].first;
        }
    }
    
    std::pair<int, int> lens[500][500][4];
    const int dirs[4][2] = { {1, 1}, {1, -1}, {-1, -1}, {-1, 1} };
};

Leetcode-3489

Fri, 26 Dec 2025 21:39:29 -0800

Time complexity: $O(mnq)$

#include <iostream>
#include <vector>

class Solution {
public:
    int minZeroArray(std::vector<int>& nums, std::vector<std::vector<int>>& queries) {
        int res = 0;
        for (int i = 0; i < nums.size(); ++i) {
            int num = nums[i];
            if (!num) {
                continue;
            }
            
            std::vector<int> dp(num + 1);
            dp[0] = 1;
            for (int k = 0; k < queries.size(); ++k) {
                if (i < queries[k][0] || i > queries[k][1]) {
                    continue;
                }
                for (int j = num; j >= queries[k][2]; --j) {
                    dp[j] |= dp[j - queries[k][2]];
                }
                if (dp.back()) {
                    res = std::max(res, k + 1);
                    break;
                }
            }
            if (!dp.back()) {
                return -1;
            }
        }
        return res;
    }
};

Leetcode-3600

Sun, 07 Dec 2025 02:14:49 -0800

#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
#include <queue>

class UnionFind {
public:
    explicit UnionFind(int n) {
        parent_.resize(n);
        rank_.resize(n, 0);
        std::iota(parent_.begin(), parent_.end(), 0);
        count_ = n;
    }
    
    int Find(int x) {
        if (parent_[x] != x) {
            parent_[x] = Find(parent_[x]);
        }
        return parent_[x];
    }
    
    bool Union(int x, int y) {
        int root_x = Find(x);
        int root_y = Find(y);
        if (root_x == root_y) {
            return false;
        }
        
        if (rank_[root_x] < rank_[root_y]) {
            parent_[root_x] = root_y;
        }
        else if (rank_[root_x] > rank_[root_y]) {
            parent_[root_y] = root_x;
        }
        else {
            parent_[root_y] = root_x;
            ++rank_[root_x];
        }
        
        --count_;
        return true;
    }
    
    int getCount() const {
        return count_;
    }

private:
    std::vector<int> parent_;
    std::vector<int> rank_;
    int count_;
};

bool comp(std::vector<int>& A, std::vector<int>& B) {
    return A[3] > B[3] || (A[3] == B[3] && A[2] > B[2]);
}

class Solution {    
public:
    int maxStability(int n, std::vector<std::vector<int>>& edges, int k) {
        std::sort(edges.begin(), edges.end(), comp);
        UnionFind uf(n);
        
        int MinMust = 0x3fff'ffff;
        std::priority_queue<int> pq, pq2;
        
        for (auto& e : edges) {
            if (uf.Union(e[0], e[1])) {
                if (e[3] == 1) {
                    MinMust = std::min(MinMust, e[2]);
                }
                else {
                    pq.push(-e[2]);
                    if (uf.getCount() == 1) {
                        break;
                    }
                }
            }
            else if (e[3] == 1) {
                return -1;
            }
        }
        
        if (uf.getCount() != 1) {
            return -1;
        }
        if (pq.empty()) {
            return MinMust;
        }
        
        for (int i = 0; i < k && !pq.empty(); ++i) {
            int s = pq.top() * 2;
            pq.pop();
            pq2.push(s);
        }
        
        int MinOther = 0x3fff'ffff;
        if (!pq.empty()) {
            MinOther = std::min(-pq.top(), MinOther);
        }
        if (!pq2.empty()) {
            MinOther = std::min(-pq2.top(), MinOther);
        }
        
        return std::min(MinOther, MinMust);
    }
};

Leetcode-3603

Thu, 25 Dec 2025 22:33:29 -0800

Time complexity: $O(mn)$

#include <iostream>
#include <vector>
#include <cmath>

class Solution {
public:
    long long minCost(int m, int n, std::vector<std::vector<int>>& waitCost) {
        std::vector<long long> dp(n);
        dp[0] = 1;
        
        for (int j = 1; j < n; ++j) {
            dp[j] = dp[j - 1] + j + 1 + waitCost[0][j];
        }
        
        for (int i = 1; i < m; ++i) {
            dp[0] += i + 1 + waitCost[i][0];
            for (int j = 1; j < n; ++j) {
                dp[j] = std::min(dp[j], dp[j - 1]) + (i + 1) * (j + 1) + waitCost[i][j];
            }
        }
        
        return dp.back() - waitCost.back().back();
    }
};

Leetcode-3605

Tue, 23 Dec 2025 20:21:05 -0800

Time complexity: $O(n\log n)$

#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
#include <cmath>

class Solution {
public:
    int minStable(std::vector<int>& nums, int maxC) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        
        int logN = std::log2(n) + 1;
        std::vector<std::vector<int>> st(n, std::vector<int>(logN));
        for (int i = 0; i < n; ++i) {
            st[i][0] = nums[i];
        }
        for (int j = 1; j < logN; ++j) {
            for (int i = 0; i + (1 << j) <= n; ++i) {
                st[i][j] = std::gcd(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
            }
        }
        
        auto GCD = [&](int L, int R) {
            int len = R - L + 1;
            int k = std::log2(len);
            return std::gcd(st[L][k], st[R - (1 << k) + 1][k]);
        };
        
        int left = 1, right = n;
        for (int mid = (left + right) / 2; right >= left; ) {
            bool valid = true;
            int ops = 0, i = 0;
            
            while (i <= n - mid) {
                int cm = GCD(i, i + mid - 1);
                if (cm > 1) {
                    ++ops;
                    if (ops > maxC) {
                        valid = false;
                        break;
                    }
                    i += mid;
                }
                else {
                    ++i;
                }
            }
            
            if (valid) {
                right = mid - 1;
            }
            else {
                left = mid + 1;
            }
            mid = (left + right) / 2;
        }
        
        return right;
    }
};

Leetcode-3610

Mon, 29 Dec 2025 15:11:40 -0800

Time complexity: $O(mn)$

#include <iostream>
#include <vector>
#include <string>

int primes[] = {
    2, 3, 5, 7, 11, 13, 17, 19,
    23, 29, 31, 37, 41, 43, 47, 53,
    59, 61, 67, 71, 73, 79, 83, 89,
    97, 101, 103, 107, 109, 113, 127, 131,
    137, 139, 149, 151, 157, 163, 167, 173,
    179, 181, 191, 193, 197, 199, 211, 223,
    227, 229, 233, 239, 241, 251, 257, 263,
    269, 271, 277, 281, 283, 293, 307, 311,
    313, 317, 331, 337, 347, 349, 353, 359,
    367, 373, 379, 383, 389, 397, 401, 409,
    419, 421, 431, 433, 439, 443, 449, 457,
    461, 463, 467, 479, 487, 491, 499, 503,
    509, 521, 523, 541, 547, 557, 563, 569,
    571, 577, 587, 593, 599, 601, 607, 613,
    617, 619, 631, 641, 643, 647, 653, 659,
    661, 673, 677, 683, 691, 701, 709, 719,
    727, 733, 739, 743, 751, 757, 761, 769,
    773, 787, 797, 809, 811, 821, 823, 827,
    829, 839, 853, 857, 859, 863, 877, 881,
    883, 887, 907, 911, 919, 929, 937, 941,
    947, 953, 967, 971, 977, 983, 991, 997,
    1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049,
    1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097,
    1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163,
    1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223,
    1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283,
    1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321,
    1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423,
    1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459,
    1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511,
    1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571,
    1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619,
    1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693,
    1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747,
    1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811,
    1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877,
    1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949,
    1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003,
    2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069,
    2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129,
    2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203,
    2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267,
    2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311,
    2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377,
    2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423,
    2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503,
    2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579,
    2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657,
    2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693,
    2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741,
    2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801,
    2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861,
    2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939,
    2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011,
    3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079,
    3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167,
    3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221,
    3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301,
    3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347,
    3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413,
    3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491,
    3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541,
    3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607,
    3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671,
    3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727,
    3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797,
    3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863,
    3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923,
    3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003,
    4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057,
    4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129,
    4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211,
    4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259,
    4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337,
    4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409,
    4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481,
    4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547,
    4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621,
    4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673,
    4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751,
    4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813,
    4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909,
    4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967,
    4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011,
    5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087,
    5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167,
    5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233,
    5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309,
    5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399,
    5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443,
    5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507,
    5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573,
    5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653,
    5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711,
    5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791,
    5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849,
    5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897,
    5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007,
    6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073,
    6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133,
    6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211,
    6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271,
    6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329,
    6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379,
    6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473,
    6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563,
    6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637,
    6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701,
    6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779,
    6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833,
    6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907,
    6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971,
    6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027,
    7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121,
    7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207,
    7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253,
    7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349,
    7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457,
    7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517,
    7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561,
    7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621,
    7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691,
    7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757,
    7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853,
    7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919,
};

class Solution {
public:
    int minNumberOfPrimes(int n, int m) {
        unsigned int dp[1001];
        std::memset(dp, 0xff, sizeof(dp));
        dp[0] = 0;
        for (int i = 0; i < m; ++i) {
            int p = primes[i];
            for (int j = p; j <= n; ++j) {
                if (dp[j - p] < dp[j]) {
                    dp[j] = dp[j - p] + 1;
                }
            }
        }
        return dp[n];
    }
};

Leetcode-3613

Tue, 23 Dec 2025 15:00:14 -0800

Time complexity: $O(m\log m)$

#include <iostream>
#include <vector>
#include <numeric>

struct DSU {
    DSU(int n) {
        count_ = n;
        parent_.resize(n, 0);
        std::iota(parent_.begin(), parent_.end(), 0);
        size_.resize(n, 1);
    }
    
    int find(int a) {
        if (a != parent_[a]) {
            parent_[a] = find(parent_[a]);
        }
        return parent_[a];
    }
    
    int unite(int a, int b) {
        int root_a = find(a);
        int root_b = find(b);
        
        if (root_a != root_b) {
            if (size_[root_b] > size_[root_a]) {
                std::swap(root_b, root_a);
            }
            --count_;
            parent_[root_b] = root_a;
            size_[root_a] += size_[root_b];
        }
        
        return count_;
    }
    
private:
    std::vector<int> parent_;
    std::vector<int> size_;
    int count_;
};

class Solution {
public:
    int minCost(int n, std::vector<std::vector<int>>& edges, int k) {
        std::sort(edges.begin(), edges.end(), [](std::vector<int>& a, std::vector<int>& b) {
            return a[2] < b[2];
        });
        
        int m = edges.size();
        DSU dsu(n);
        for (int i = 0; i < m; ++i) {
            if (dsu.unite(edges[i][0], edges[i][1]) == k) {
                return edges[i][2];
            }
        }
        
        return 0;
    }
};

Leetcode-3620

Wed, 24 Dec 2025 19:45:26 -0800

Time complexity: $O(|E|\log v\log w)$

#include <iostream>
#include <vector>
#include <queue>
#include <numeric>
#include <algorithm>

class Solution {
public:
    int findMaxPathScore(std::vector<std::vector<int>>& edges, std::vector<bool>& online, long long k) {
        int n = online.size();
        if (n == 1) {
            return 0;
        }
        
        int left = 0x7fff'ffff, right = 0, res = -1;
        std::vector<std::vector<std::pair<int, long long>>> adj(n);
        std::vector<long long> dist(n);
        
        for (auto& e : edges) {
            if (!online[e[0]] || !online[e[1]]) {
                continue;
            }
            left = std::min(left, e[2]);
            right = std::max(right, e[2]);
            adj[e[0]].push_back({e[1], e[2]});
        }
        if (left == 0x7fff'ffff && right == 0) {
            return -1;
        }
        
        while (right >= left) {
            int mid = (left + right) / 2;
            bool valid = false;
            std::priority_queue<std::pair<long long, int>, std::vector<std::pair<long long, int>>, std::greater<std::pair<long long, int>>> pq;
            
            std::fill(dist.begin(), dist.end(), 0x7fff'ffff'ffff'ffff);
            dist[0] = 0;
            
            pq.push({0, 0});
            
            while (!pq.empty()) {
                long long d = pq.top().first;
                int u = pq.top().second;
                if (u == n - 1) {
                    valid = true;
                    break;
                }
                pq.pop();
                if (d > dist[u]) {
                    continue;
                }
                for (auto& e : adj[u]) {
                    if (e.second < mid) {
                        continue;
                    }
                    long long nd = d + e.second;
                    if (nd > k || nd >= dist[e.first]) {
                        continue;
                    }
                    pq.push({nd, e.first});
                    dist[e.first] = nd;
                }
            }
            
            if (valid) {
                res = mid;
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
        }
        
        return res;
    }
};

Leetcode-3639

Tue, 23 Dec 2025 14:30:40 -0800

Time complexity: $O(n\log M)$

#include <iostream>
#include <vector>
#include <cstring>

class Solution {
public:
    int minTime(std::string s, std::vector<int>& order, int k) {
        if (!k) {
            return 0;
        }
        
        int n = s.length();
        long long max_k = ((long long)n * (n + 1)) / 2;
        if (max_k < k) {
            return -1;
        }
        else if (max_k == k) {
            return n - 1;
        }
        
        str_.resize(n, 0);
        int left = 1, right = n;
        for (int mid = (left + right) / 2; right > left;) {
            if (check(order, k, mid)) {
                right = mid;
            }
            else {
                left = mid + 1;
            }
            mid = (left + right) / 2;
        }
        
        return left - 1;
    }
    
private:
    bool check(std::vector<int>& order, int k, int t) {
        int n = str_.size();
        for (int i = 0; i < t; ++i) {
            str_[order[i]] = t;
        }
        
        int cnt = 0, last = -1;
        
        for (int i = 0; i < n; ++i) {
            if (str_[i] == t) {
                last = i;
            }
            cnt += last + 1;
            if (cnt >= k) {
                return true;
            }
        }
        
        return false;
    }
    
    std::vector<int> str_;
};

Leetcode-3665

Fri, 26 Dec 2025 16:31:58 -0800

Time complexity: $O(mn)$

#include <iostream>
#include <vector>
#include <cmath>

const int M = 1'000'000'007;

class Solution {
public:
    int uniquePaths(std::vector<std::vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        std::vector<std::pair<int, int>> dp(n); // {right, down}
        
        dp[0] = {0, 1};
        for (int j = 1; j < n; ++j) {
            dp[j] = {1, 0};
            if (grid[0][j]) {
                break;
            }
        }
        
        for (int i = 1; i < m; ++i) {
            if (grid[i - 1][0]) {
                dp[0] = {0, 0};
            }
            for (int j = 1; j < n; ++j) {
                dp[j] = {grid[i][j - 1] ? dp[j - 1].second : (dp[j - 1].first + dp[j - 1].second) % M, grid[i - 1][j] ? dp[j].first : (dp[j].first + dp[j].second) % M};
            }
        }
        
        return (dp.back().first + dp.back().second) % M;
    }
};

Leetcode-3679

Wed, 17 Dec 2025 23:36:06 -0800

3679. Minimum Discards to Balance Inventory

You are given two integers w and m, and an integer array arrivals, where arrivals[i] is the type of item arriving on day i (days are 1-indexed).

Items are managed according to the following rules:

Each arrival may be kept or discarded; an item may only be discarded on its arrival day.
For each day i, consider the window of days [max(1, i - w + 1), i] (the w most recent days up to day i):
For any such window, each item type may appear at most m times among kept arrivals whose arrival day lies in that window.
If keeping the arrival on day i would cause its type to appear more than m times in the window, that arrival must be discarded.

Return the minimum number of arrivals to be discarded so that every w-day window contains at most m occurrences of each type.

Example 1:

Input: arrivals = [1,2,1,3,1], w = 4, m = 2 Output: 0

Explanation:

On day 1, Item 1 arrives; the window contains no more than m occurrences of this type, so we keep it.
On day 2, Item 2 arrives; the window of days 1 - 2 is fine.
On day 3, Item 1 arrives, window [1, 2, 1] has item 1 twice, within limit.
On day 4, Item 3 arrives, window [1, 2, 1, 3] has item 1 twice, allowed.
On day 5, Item 1 arrives, window [2, 1, 3, 1] has item 1 twice, still valid.

There are no discarded items, so return 0.

Example 2:

Input: arrivals = [1,2,3,3,3,4], w = 3, m = 2 Output: 1

Explanation:

On day 1, Item 1 arrives. We keep it.
On day 2, Item 2 arrives, window [1, 2] is fine.
On day 3, Item 3 arrives, window [1, 2, 3] has item 3 once.
On day 4, Item 3 arrives, window [2, 3, 3] has item 3 twice, allowed.
On day 5, Item 3 arrives, window [3, 3, 3] has item 3 three times, exceeds limit, so the arrival must be discarded.
On day 6, Item 4 arrives, window [3, 4] is fine.

Item 3 on day 5 is discarded, and this is the minimum number of arrivals to discard, so return 1.

#include <iostream>
#include <vector>
#include <map>

class Solution {
public:
    int minArrivalsToDiscard(std::vector<int>& arrivals, int w, int m) {
        int num = 0;
        int n = arrivals.size();
        w = std::min(n, w);
        
        std::unordered_map<int, int> map;
        for (int i = 0; i < w; ++i) {
            if (map[arrivals[i]] < m) {
                ++map[arrivals[i]];
            }
            else {
                ++num;
                arrivals[i] = 0;
            }
        }
        
        for (int i = w; i < n; ++i) {
            --map[arrivals[i - w]];
            if (map[arrivals[i]] < m) {
                ++map[arrivals[i]];
            }
            else {
                ++num;
                arrivals[i] = 0;
            }
        }
        
        return num;
    }
};

Leetcode-3685

Thu, 25 Dec 2025 22:27:07 -0800

Time complexity: $O(nk)$

#include <iostream>
#include <vector>
#include <algorithm>

class Solution {
public:
    std::vector<bool> subsequenceSumAfterCapping(std::vector<int>& nums, int k) {
        int n = nums.size();
        std::sort(nums.begin(), nums.end());
        std::vector<bool> res(n, false);
        std::vector<int> dp(k + 1, 0);
        dp[0] = 1;
        
        int ptr = 0;
        for (int x = 1; x <= n; ++x) {
            while (ptr < n && nums[ptr] <= x) {
                for (int j = k; j >= nums[ptr]; --j) {
                    dp[j] |= dp[j - nums[ptr]];
                }
                ++ptr;
            }
            
            int m = n - ptr;
            for (int j = 0; j <= m; ++j) {
                if (j * x > k) {
                    break;
                }
                if (dp[k - j * x]) {
                    res[x - 1] = true;
                    break;
                }
            }
        }
        
        return res;
    }
};

Leetcode-3710

Tue, 23 Dec 2025 14:10:01 -0800

Time complexity: $O(n^2\log M)$

#include <iostream>
#include <vector>
#include <queue>
#include <cmath>

class Solution {
public:
    int maxPartitionFactor(std::vector<std::vector<int>>& points) {
        int n = points.size();
        if (n == 2) {
            return 0;
        }
        
        std::vector<std::vector<int>> graph(n, std::vector<int>(n, 0x7fff'ffff));
        int left = 0, right = 0;
        for (int i = 0; i < n - 1; ++i) {
            for (int j = i + 1; j < n; ++j) {
                graph[i][j] = graph[j][i] = mdist(points[i], points[j]);
                right = std::max(graph[i][j], right);
            }
        }
        
        while (right >= left) {
            int mid = (left + right) / 2;
            if (check(graph, n, mid)) {
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
        }
        
        return right;
    }
    
private:
    bool check(std::vector<std::vector<int>>& graph, int n, int minDist) {
        std::vector<int> visited(n, 0);
        std::queue<int> q;
        for (int i = 0; i < n; ++i) {
            if (visited[i]) {
                continue;
            }
            visited[i] = 1;
            q.push(i);
            while (!q.empty()) {
                int u = q.front();
                q.pop();
                for (int v = 0; v < n; ++v) {
                    if (graph[u][v] >= minDist) {
                        continue;
                    }
                    if (visited[v] == 0) {
                        visited[v] = -visited[u];
                        q.push(v);
                    }
                    else if (visited[v] == visited[u]) {
                        return false;
                    }
                }
            }
        }
        return true;
    }
    
    int mdist(std::vector<int>& a, std::vector<int>& b) {
        return std::abs(a[0] - b[0]) + std::abs(a[1] - b[1]);
    }
};

Leetcode-3742

Thu, 25 Dec 2025 22:34:55 -0800

Time complexity: $O(mnk)$

#include <iostream>
#include <vector>
#include <cmath>

class Solution {
public:
    int maxPathScore(std::vector<std::vector<int>>& grid, int k) {
        int m = grid.size();
        int n = grid[0].size();
        std::vector<std::vector<int>> dp(n, std::vector<int>(k + 1, -1));
        int diff = (grid[0][0] != 0);
        if (k >= diff) {
            dp[0][grid[0][0]] = grid[0][0];
        }
        else {
            return -1;
        }
        
        for (int j = 1; j < n; ++j) {
            diff = (grid[0][j] != 0);
            for (int c = diff; c <= k; ++c) {
                if (dp[j - 1][c - diff] >= 0) {
                    dp[j][c] = grid[0][j] + dp[j - 1][c - diff];
                }
                else {
                    dp[j][c] = -1;
                }
            }
        }
        
        for (int i = 1; i < m; ++i) {
            diff = (grid[i][0] != 0);
            for (int c = k; c >= diff; --c) {
                if (dp[0][c - diff] >= 0) {
                    dp[0][c] = grid[i][0] + dp[0][c - diff];
                }
                else {
                    dp[0][c] = -1;
                }
            }
            if (diff) {
                dp[0][0] = -1;
            }
            
            for (int j = 1; j < n; ++j) {
                diff = (grid[i][j] != 0);
                for (int c = k; c >= diff; --c) {
                    int prev = std::max(dp[j - 1][c - diff], dp[j][c - diff]);
                    if (prev >= 0) {
                        dp[j][c] = grid[i][j] + prev;
                    }
                    else {
                        dp[j][c] = -1;
                    }
                }
                if (diff) {
                    dp[j][0] = -1;
                }
            }
        }
        
        int res = -1;
        for (int c = 0; c <= k; ++c) {
            res = std::max(dp.back()[c], res);
        }
        return res;
    }
};

Leetcode-3963

Thu, 25 Dec 2025 22:27:07 -0800

Time complexity: $O(n)$

#include <iostream>
#include <vector>
#include <cmath>

class Solution {
public:
    int climbStairs(int n, std::vector<int>& costs) {
        std::vector<int> dp(n + 1);
        for (int i = 1; i <= n; ++i) {
            int jmp = 0x7fff'ffff;
            for (int j = 1; j <= 3; ++j) {
                if (i >= j) {
                    jmp = std::min(jmp, j * j + dp[i - j]);
                }
            }
            dp[i] = jmp + costs[i - 1];
        }
        return dp.back();
    }
};

Hello World

Sun, 06 Mar 2022 00:00:00 +0000

Welcome to Hugo theme Stack. This is your first post. Edit or delete it, then start writing!

For more information about this theme, check the documentation: https://stack.jimmycai.com/

Want a site like this? Check out hugo-theme-stack-stater

Photo by Pawel Czerwinski on Unsplash