In this problem, we should find the substring with a fixed length that meets the following conditions.

• The substring should use only 1 character.

• The character placed right before and after the substring must not be the same as the character in the substring. It means that if there is a substring whose range is [l,r], then s[l-1] and s[r+1] must not be the character of s[l].

This is very easy because the length of the input string is really short. You can generate all possible substrings of length K and check if it is made with only 1 character. I used sorting to check this. After that, check if the same character exists before and after the substring.

class Solution {
public:
    bool hasSpecialSubstring(string s, int k) {
        for (int i = 0; i < s.size()-k+1; ++i) {
            string sub = s.substr(i, k);
            sort(sub.begin(), sub.end());
            if (sub[0] == sub.back() && (i-1 < 0 || s[i-1] != sub[0]) &&  (i + k >= s.size() || s[i+k] != sub[0])) return true;
        }
        return false;
    }
};

Problem 2: Eat Pizzas!

We should find the maximum weight we can get after eating all the pizzas. No matter how we eat the pizza daily, we only get the maximum or the second maximum based on the day's index.

This problem is easy if you find the greedy solution where you can greedily choose the maximum on the odd day and the second largest on the even days. However you should ensure that this algorithm really works in this problem.

Here’s why the greedy algorithm works.

• Let’s say there are piazzas like [1,2,3,4,5,6,7,8,9,10,11,12] (sorted order).

• On the first day, we can choose a maximum of 12. (We should eat the three lightest pizzas together.) Then we only have [4,5,6,7,8,9,10,11]

• On the second day, we choose the second largest one, 10. Then, we should choose 11 to make 10 the second largest. So, we only have [6,7,8,9].

• On the third day, we gained 9 because it was the maximum weight.

  • However, if we choose [4,5,9,10] to achieve weight 9, we can achieve 11 on the third day.

  • It means that If there are three values [X, Y, Z] where X <= Y <= Z, then we can choose (X, Y) or (X, Z).

    • If we choose Y on the even-numbered day, then it will be (X, Y)

    • Otherwise, (X, Z).

  • X + Z is always larger than X + Y. Therefore, to get the maximum number, we should choose the odd-numbered day first.

So, we can choose the largest (total days + 1 / 2) weights first for the odd-numbered day, and then the second largest one for (total days / 2) times.

class Solution {
public:
    long long maxWeight(vector<int>& pizzas) {
        const int n = (int)pizzas.size();
        sort(pizzas.rbegin(), pizzas.rend());
        int days = n / 4;
        int idx = 0;
        long long sum = 0LL;
        for (int i = 0; i < (days+1) / 2; ++i) {
            sum += pizzas[idx++];
        }
        
        for (int i = 0; i < days / 2; ++i) {
            sum += pizzas[++idx];
            ++idx;
        }
        return sum;
    }
};

Problem 3: Select K Disjoint Special Substrings

In this problem, one character should be in only one substring. If we choose the substring from the index [l, r], every character between them should not exist outside the range.

Fortunately, we have a maximum of 26 characters, so we can check all substrings that start with every character.

• Get the start and end position of every character.

• Sort the intervals based on the start.

• Iterate the character from the one that appears at the latest. This is for the number of possible disjoint substrings after the current index.

  • For example, if the last index of the substring starting with index i is j, then we can get (dp[j+1] + 1) substrings. To get dp[j+1], we should calculate it before visiting the current index. So, we should iterate from the last.

• Every character has its start and end index. However, the end index should be changed if another character has a more extensive index than the end index. Also, if there is a character that should start before the current start index, then we can skip the current character because it will be checked later.

  • For example, if the substring is “BABEAE” and the current character is A, the start index is 1, and the end index is 4.

  • However, E is between [1,4] and appears again after the end index of A. So, we should extend the end index to 5.

  • In this case, the character B exists between [1,4] and B should start before index 1. So, we have to skip to get the answer with a substring that begins with A because it is impossible.

This algorithm takes only O(26 * N) times because, for every character, we only iterate the input string at once.

class Solution {
public:
    bool maxSubstringLength(string s, int k) {
        vector<pair<int,int>> intervals(26, {-1, -1});
        const int n = (int)s.size();
        for (int i = 0; i < n; ++i) {
            int j = s[i]-'a';
            intervals[j].second = i;
            if (intervals[j].first == -1) intervals[j].first = i;
        }
        vector<pair<int,int>> arr;
        for (int i = 0; i < intervals.size(); ++i) {
            if (intervals[i].first != -1) arr.push_back(intervals[i]);
        }
        sort(arr.begin(), arr.end());
        vector<int> dp(arr.size()+1, 0);
        int ans = 0;
        for (int i = arr.size()-1; i >= 0; --i) {
            dp[i] = max(dp[i], dp[i+1]);
            int l = arr[i].first, r = arr[i].second;            
            int end = r;
            bool flag = true;
            for (int j = l+1; j < r; ++j) {
                int ns = intervals[s[j]-'a'].first, ne = intervals[s[j]-'a'].second;
                if (ns < l) {
                    flag = false;
                    break;
                }
                r = max(r, ne);
            }
            if (flag && r - l + 1 < s.size()) {
                int idx = lower_bound(arr.begin(), arr.end(), make_pair(r, r)) - arr.begin();
                dp[i] = max(dp[i], dp[idx] + 1);
            }
            ans = max(ans, dp[i]);
        }
        return ans >= k;
    }
};

Problem 4: Length of Longest V-Shaped Diagonal Segment

In this problem, we should find the most extended length that can be made with a 1,2,0,2,0 sequence. Unlike the typical DFS problem, we should move in a diagonal direction. Also, we can change the direction to one way and at most once.

The solution is basically the same as for the typical DFS problem. However, before proceeding, we should consider the following two cases.

• Choose the same direction.

• Choose to take a 90-degree clockwise turn. In this case, we should not change the direction before.

• The value difference between the current and the following positions should be 2 for both cases.

So, for every position (x, y), we can keep track of the direction and the changed times. With this information, we can make all the possible moves.

However, if the grid size increases, we might visit the same position with the same condition more than once. So, we can use memoization to save the previous result and then return if we visit again. This can be possible because we have at most 500 * 500 * 4 * 2 cases. (500 - m, 500 - n, 4 - direction, 2 - the number of turns)

We don’t need to keep track of the previous visit during DFS because we cannot go back because we cannot change the direction 180 degrees. We cannot change the direction twice, so revisiting the same node within the single DFS traverse is impossible.

class Solution {
public:
    int dx[4] = {1,1,-1,-1};
    int dy[4] = {1,-1,-1,1};
    int dp[501][501][4][2];
    bool pos(int x, int y, int nx, int ny, vector<vector<int>> & grid) {
        return nx >= 0 && ny >= 0 && nx < grid.size() && ny < grid[0].size() && abs(grid[x][y] - grid[nx][ny]) == 2;
    }

    int dfs(vector<vector<int>> & grid, int x, int y, int d, int changed) {
        if (dp[x][y][d][changed] != -1) return dp[x][y][d][changed];
        // follow the direction
        int ans = 1;
        if (pos(x, y, x + dx[d], y + dy[d], grid)) {
            ans = max(ans, dfs(grid, x + dx[d], y + dy[d], d, changed) + 1);
        }
        // change the direction
        if (changed == 0) {
            int nd = (d + 1) % 4;
            if (pos(x, y, x + dx[nd], y + dy[nd], grid)) {
                ans = max(ans, dfs(grid, x + dx[nd], y + dy[nd], nd, changed+1) + 1);
            }
        }
        return dp[x][y][d][changed] = ans;
    }
    int lenOfVDiagonal(vector<vector<int>>& grid) {
        const int n = (int)grid.size();
        const int m = (int)grid[0].size();
        int ans = 0;
        memset(dp, -1, sizeof(dp));
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (grid[i][j] == 1) {
                    ans = max(ans, 1);
                    for (int k = 0; k < 4; ++k) {
                        int nx = i + dx[k], ny = j + dy[k];
                        if (nx < 0 || ny < 0 || nx >= n || ny >= m || grid[nx][ny] != 2) continue;
                        ans = max(ans, dfs(grid, nx, ny, k, 0) + 1);
                    }
                }
            }
        }
        return ans;
    }
};

In the problem, we should find the common ancestor of p and q. Unlike in typical LCA problems, BST is used here, so we can take advantage of it.

• If the current node is larger than p and q, it cannot be the ancestor. The right ancestor will be in the left tree.

• If the current node is smaller than p and q, the answer should be in the right tree.

• Otherwise, the current value should be the lowest common ancestor because one might be on the left and the other on the right. (Or the current node can be one of p and q)

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        while(true) {
            if(root->val < p->val && root->val < q->val) root = root->right;
            else if (root->val > p->val && root->val > q->val) root = root->left;
            else break;
        }
        return root;
    }
};

Problem2: Lowest Common Ancestor of a Binary Tree

Now, we should find the LCA from Binary Tree. This is not the BST, so we cannot decide which child node will contain the answer. It means that we should find the left and right child together.

The important thing is to determine which case can be the ancestor. Let’s say we already checked the left and right nodes.

• If both the left and right nodes find something, the current node should be the common ancestor.

• If not, there are two cases.

  • 1) Find p or q, not both.

  • 2) Find nothing.

  • In both cases, the current node may be either p or q. If so, we can return it. The current node will be the answer if it is the first case. In the second case, the current node will indicate to the parent that it finds p or q.

• If the current node is not p and q, then we can return the found node from the result of the left and right nodes.

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == nullptr) return nullptr;

        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);

        if ((left != nullptr && right != nullptr) || root == p || root == q) {
            return root;
        }

        return left == nullptr ? right : left;
    }
};

Problem3: Lowest Common Ancestor of Deepest Leaves

In this problem, we should find the LCA of deepest leaves. If there are more than 1 leaves that have the deepest depth, we should find the LCA for all of them. This is tricky, even though we search with DFS, we cannot know if it is the deepest leaves or not.

So, when we search the left and right nodes, we should get the deepest depth information as well. If the deepest depth of left tree is larger than that of right tree, then we should return LCA of left tree. It’s because the right tree must not be the answer. Of course, in this case, we are unsure that the LCA from left tree is the correct answer. There might be another LCA that has deeper depth.

• To make the logic work, we should return the empty node’s depth with -1. This will work because if left node is empty and the right node is not, right node’s depth is always larger than that of the left node.

If the depth of left and right nodes are equal, then we should return the current node as the LCA. If it is the leaf node, then left and right node depth will be same and the value is -1. In this case, we should return the current depth to let parent know the deepest depth it has.

class Solution {
public:
    pair<TreeNode*, int> findLCADeepestLeaves(TreeNode* root, int depth) {
        if (root == nullptr) return {nullptr,  -1};

        auto left = findLCADeepestLeaves(root->left, depth + 1);
        auto right = findLCADeepestLeaves(root->right, depth + 1);

        if (left.second == right.second) {
            return {root, left.second == -1 ? depth : left.second };
        }
        return left.second < right.second ? right : left;
    }

    TreeNode* lcaDeepestLeaves(TreeNode* root) {
        return findLCADeepestLeaves(root, 0).first;
    }
};

Problem4: Lowest Common Ancestor of a Binary Tree II

This problem is a bit harder one than problem2. It’s because p or q might not be in the tree. We should return the LCA if and only if we find both of them in the tree.

Basic logic is the same as the problem2, but I added the boolean value that indicates returned node is the LCA. If it is false, then the node is just one of p or q, not the LCA.

If one of the left or right node found the answer, then we can return it. Unless, we should check the current node can be the answer.

• If both left node and right node finds the LCA but those are not the answer, then p and q is found from different child. So the LCA of them is the current node.

• If one of them finds the LCA and the current node is either p or q, then it also means that the current node is LCA.

• In those two cases, the current node is the answer, so we should return true for the second return value.

Even though the current node is not the LCA, it can be one of p or q. If not, then the current node is useless, so return the non-empty node between left and right. (Both can be null, but it’s okay)

class Solution {
public:
    pair<TreeNode*, bool> lowestCommonAncestorHelper(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (!root) return {nullptr, false};

        auto left = lowestCommonAncestorHelper(root->left, p, q);
        auto right = lowestCommonAncestorHelper(root->right, p, q);
        if ((left.first != nullptr && right.first != nullptr) || ((root == p || root == q) && (left.first != nullptr || right.first != nullptr))) {
            return {root, true};
        }

        if (left.second) return left;
        if (right.second) return right;

        if (root == p || root == q) return {root, false};

        return left.first == nullptr ? right : left;
    }

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        auto answer = lowestCommonAncestorHelper(root, p, q);
        return answer.second ? answer.first : nullptr;
    }
};

Problem5: Lowest Common Ancestor of a Binary Tree III

In this problem, we don’t know the root and only p and q are provided. However, each node has the parent infromation. So we can find the parent if we keep following the parent node.

To find the LCA, we can look through all parents of p and q.

• Store all parents of p, including p itself until it reach to the root node.

• Find the LCA by checking if the parent of q exists.

• If nothing is found, then return nullptr.

class Solution {
public:
    Node* lowestCommonAncestor(Node* p, Node * q) {
        unordered_set<Node*> parents;
        while(p != nullptr) {
            parents.insert(p);
            p = p->parent;
        }
        while(q != nullptr) {
            if (parents.find(q) != parents.end()) return q;
            q = q->parent;
        }
        return nullptr;
    }
};

This problem can be solved without storing the parent information. No matter where p and q is located in the tree, they have each own depth from the root node. If the depth is equal, then we can simply iterate the parent one by one until both get the same parent.

However, the problem happens when the depth is different. Let’s seem the following graph.

• If p and q moves to each parent at the same speed, then the shorter one will arrive at the root node first. In this case, p is the shorter one and it will iterate A + B times. q also iterates A + B times. It is the C - A far from the root.

• p is now starting again from original q position. Then it should iterate C times more to get to the LCA. However, before iterating C, q will arrive at the root node after C - A iteration. p also moves C - A times so it will be A far from the LCA.

• if q starts from original p postion, both of them should move A times. In conclustion, both p and q moves A + B + C times to get to the LCA node.

class Solution {
public:
    Node* lowestCommonAncestor(Node* p, Node * q) {
        Node* l = p;
        Node* r = q;
        while(l != r) {
            l = l->parent == nullptr ? q : l->parent;
            r = r->parent == nullptr ? p : r->parent;
        }
        return l;
    }
};

Problem6: Lowest Common Ancestor of a Binary Tree IV

In this problem, we should find the LCA of multiple nodes. We can find all LCA one by one, but it will take too long time if array size is big. However, if you try to find the LCA with this method, then you will get one possible optimization idea.

Let’s assume that we find the LCA of A and B. (let’s call it X) If we want to find LCA of A,B,C, then we can find the LCA of X and C.

What if C is located in the child tree of X? In this case, we don’t need to consider C. It means that if we find a node, then we don’t need to think about the LCA of other nodes that are located in the child tree. So, we just can return the current node as the LCA.

So, the basic logic is mostly the same as the problem 2. One thing different is that, if the current node is in the list of nodes that we have to find, then we just can return the current node ans the LCA, no matter what result of left or right.

class Solution {
public:
    TreeNode* lowestCommonAncestorHelper(TreeNode* root, unordered_set<TreeNode*> & s) {
        if (root == nullptr) return nullptr;

        TreeNode* left = lowestCommonAncestorHelper(root->left, s);
        TreeNode* right = lowestCommonAncestorHelper(root->right, s);

        if ((left != nullptr && right != nullptr) || s.find(root) != s.end()) {
            return root;
        }

        return left == nullptr ? right : left;
    }

    TreeNode* lowestCommonAncestor(TreeNode* root, vector<TreeNode*> &nodes) {
        unordered_set<TreeNode*> s;
        for (auto & node: nodes) s.insert(node);

        return lowestCommonAncestorHelper(root, s);
    }
};

Solution

In this problem, we should find the minimum possible partitions that can divide the input string into multiple(or single) substring(s). The same character should not be in each substring.

We should create a substring containing as many characters as possible. Otherwise, we might need more partitions to split the duplicated characters. Thus, a greedy algorithm simply works here.

class Solution {
public:
    int partitionString(string s) {
        int n = (int)s.size();
        int ans = 1;
        vector<int> cnt(26, 0);
        for (int i = 0; i < n; ++i) {
            if (cnt[s[i]-'a'] == 1) {
                ++ans;
                fill(cnt.begin(), cnt.end(), 0);
            }
            cnt[s[i]-'a']++;
        }
        return ans;
    }
};

Then, why does the greedy algorithm work here?

Let’s say that we get the answer without using a greedy algorithm. There are two partitions: A and B.

• A partition can contain more characters in the B partitions. If not, then we already solved it with a greedy algorithm.

• A partition can contain some characters or all characters in the B partitions. It means that a greedy solution gets the same or fewer partitions. So, the greedy algorithm works here.

Solution

In this problem, we should find all factors that meet n % i == 0. Before getting all possible factors, we are unsure if there is a kth number. The easy solution is to check all possible numbers if n is divisible by that number. The input size is too small, so we can solve this problem with O(N) time complexity.

class Solution {
public:
    int kthFactor(int n, int k) {
        for (int i = 1; i <= n; ++i) {
            if (n % i == 0) --k;
            if (k == 0) return i;
        }
        return -1;
    }
};

However, this solution won’t pass if the size of N becomes large. To make it more effective, we should consider the divisor's aspect. When a number X can divide the number N, then we know that N/X is also the divisor of N. For example, if we know that 3 is the divisor of 15, 5 is also the divisor of 15 automatically.

Then, we don’t need to check all numbers smaller than N. We only need to check until ceil(sqrt(N)). It’s because that sqrt(N) * sqrt(N) = N. If the previous sqrt(N) is larger, the later sqrt(N) should be smaller. It was already checked before we checked sqrt(N).

class Solution {
public:
    int kthFactor(int n, int k) {
        vector<int> ans;
        for (int i = 1; i * i <= n; ++i) {
            if (n % i == 0) ans.push_back(i);
            if (n % i == 0 && i != n / i) ans.push_back(n/i);
        }
        sort(ans.begin(), ans.end());
        k--;
        return ans.size() > k ? ans[k] : -1;
    }
};

Solution

In the problem, we should find all possible ways to close the branches. All the branches that survive must be connected to each other, and the distance between them should be no longer than the maximum distance.

The maximum input of n is 10, so there are only 1024 states to select the survived branches. Also, we should find all the shortest paths from each branch to the others. It will take N*NlogN times to detect whether the current state is valid. So, it will be O(2^N * N^2logN). This value is really low even with N = 10.

• Iterates all possible ways to select the survived branches.

• Iterates all survived branches as the starting branch to find the shortest path to other branches.

• Check if there is any case that one branch cannot connect to the other branch. If there is any, then this cannot be possible.

#include <vector>
#include <unordered_map>
#include <queue>
using namespace std;

class Solution {
public:
    int numberOfSets(int n, int maxDistance, vector<vector<int>>& roads) {
        unordered_map<int, vector<pair<int, int>>> graph;

        // Build adjacency list representation of the graph
        for (const auto& road : roads) {
            int u = road[0], v = road[1], w = road[2];
            graph[u].push_back({v, w});
            graph[v].push_back({u, w});
        }

        int validSets = 1; // At least one valid set (empty set)
        
        // Iterate over all subsets of branches (bitmasking)
        for (int mask = 1; mask < (1 << n); ++mask) {
            vector<int> openBranches;

            // Extract the branches that are open in this subset
            for (int j = 0; j < n; ++j) {
                if (mask & (1 << j)) { // Check if branch `j` is included
                    openBranches.push_back(j);
                }
            }

            bool isValid = true;

            // Run Dijkstra's algorithm for each branch in the subset
            for (auto& startNode : openBranches) {
                vector<int> dist(n, -1); // Distance array initialized to -1
                dist[startNode] = 0;

                priority_queue<pair<int, int>> pq;
                pq.push({0, startNode}); // {distance, node}

                while (!pq.empty()) {
                    auto [negDistance, node] = pq.top();
                    pq.pop();
                    int currDistance = -negDistance; // Convert back to positive distance

                    // If this path is not optimal, skip
                    if (dist[node] != -1 && dist[node] < currDistance) continue;

                    // Relax edges
                    for (auto& [neighbor, weight] : graph[node]) {
                        if (mask & (1 << neighbor)) { // Only consider nodes in the subset
                            int newDistance = currDistance + weight;
                            if ((dist[neighbor] == -1 || dist[neighbor] > newDistance) && newDistance <= maxDistance) {
                                dist[neighbor] = newDistance;
                                pq.push({-newDistance, neighbor}); // Push with negative distance for min-heap
                            }
                        }
                    }
                }

                // Check if all selected branches are reachable
                for (auto& branch : openBranches) {
                    if (dist[branch] == -1) {
                        isValid = false;
                        break;
                    }
                }

                if (!isValid) break;
            }

            if (isValid) validSets++; // Count this subset if it's valid
        }

        return validSets;
    }
};

Time Complexity Analysis

• Generating subsets: O(2^n) (Iterating over all subsets)

• Dijkstra's Algorithm: O(nlog⁡n) per subset (Priority queue operations)

• Checking All Subsets: O(n) in worst case

Thus, the overall complexity is O(2^n⋅n^2⋅log n), making this approach feasible only for small n (typically n≤20).

In this problem, we need to sort the diagonals. First, we should sort the numbers of bottom-left matrix in the non-increasing order. To sort the diagonals, we can start the first index of each row. And then we can move row + 1, col + 1 to get all values in the same diagonal. After sorting the values, then reassign the values to the matrix with the same logic.

For the top-right matrix, we can start the first index of each column except for the first column. First column will be calculated in the bottom-left case. The logic is the same as the bottom-left case.

class Solution {
public:
    vector<vector<int>> sortMatrix(vector<vector<int>>& grid) {
        int n = grid.size();

        // Sort diagonals in bottom-left (including middle diagonal) in non-increasing order
        for (int i = n - 1; i >= 0; --i) {
            int row = i, col = 0;
            vector<int> diagonal;

            // Extract diagonal elements
            while (row < n && col < n) {
                diagonal.push_back(grid[row][col]);
                row++, col++;
            }

            // Sort in descending order
            sort(diagonal.rbegin(), diagonal.rend());

            // Put sorted values back into the matrix
            row = i, col = 0;
            for (int val : diagonal) {
                grid[row++][col++] = val;
            }
        }

        // Sort diagonals in top-right in non-decreasing order
        for (int i = 1; i < n; ++i) {
            int row = 0, col = i;
            vector<int> diagonal;

            // Extract diagonal elements
            while (row < n && col < n) {
                diagonal.push_back(grid[row][col]);
                row++, col++;
            }

            // Sort in ascending order
            sort(diagonal.begin(), diagonal.end());

            // Put sorted values back into the matrix
            row = 0, col = i;
            for (int val : diagonal) {
                grid[row++][col++] = val;
            }
        }

        return grid;
    }
};

Time Complexity Analysis

• Extracting diagonals: O(n)per diagonal.

• Sorting diagonals: O(nlog⁡n) per diagonal.

• Placing elements back: O(n) per diagonal.

• There are approximately 2n−1 diagonals.

Thus, the total complexity is O(n2log⁡n).

Problem2: Assign Elements to Groups with Constraints

In this problem, we should assign the divisible elements to the value in the groups. We cannot check all elements to all values because the number of groups and elements is 10^5. It should be TLE.

I remove the duplicated elements by choosing only earlier one. Also, I sorted the group values to reduce the search range after getting unique values. I can store the indexes of each value with the hashmap. When I should find the divisible values with the element, find the lower_bound from the distinct value array. This only cost O(logN).

To reduce the time complexity, I calculated the element value 1, because it will be applied to all groups by default.

class Solution {
public:
    vector<int> assignElements(vector<int>& groups, vector<int>& elements) {
        unordered_map<int, vector<int>> groupToIndices;
        
        // Store indices of each group size
        for (int i = 0; i < groups.size(); ++i) {
            groupToIndices[groups[i]].push_back(i);
        }

        // Extract unique group sizes and sort them
        vector<int> sortedGroups;
        for (auto &entry : groupToIndices) {
            sortedGroups.push_back(entry.first);
        }
        sort(sortedGroups.begin(), sortedGroups.end());

        // Track the smallest index for each element in elements
        unordered_map<int, int> elementIndex;
        for (int i = elements.size() - 1; i >= 0; --i) {
            elementIndex[elements[i]] = i; // Store the smallest index for each element
        }

        // Map to store the smallest valid element index for each group
        unordered_map<int, int> bestAssignment;
        
        // Iterate over each element and check its multiples in sortedGroups
        for (auto &[element, index] : elementIndex) {
            int multiple = element;
            while (multiple > 1) {
                auto it = lower_bound(sortedGroups.begin(), sortedGroups.end(), multiple);
                if (it == sortedGroups.end()) break; // No more valid groups

                if (*it == multiple && (bestAssignment.count(multiple) == 0 || bestAssignment[multiple] > index)) {
                    bestAssignment[*it] = index; // Store the smallest index
                }
                multiple += element;
            }
        }

        // Initialize answer array with -1 (default unassigned state)
        vector<int> result(groups.size(), -1);
        
        // Special case: If '1' is present in elements, assign its index to all groups
        if (elementIndex.count(1) > 0) {
            fill(result.begin(), result.end(), elementIndex[1]);
        }

        // Assign best matching element indices to corresponding groups
        for (auto &[groupSize, assignedIndex] : bestAssignment) {
            for (auto &groupIndex : groupToIndices[groupSize]) {
                if (result[groupIndex] == -1 || result[groupIndex] > assignedIndex) {
                    result[groupIndex] = assignedIndex;
                }
            }
        }
        
        return result;
    }
};

Time Complexity Analysis

• Sorting the unique group sizes: O(Glog⁡G)(where G is the number of unique group sizes).

• Traversing elements and populating els: O(E)

• Checking divisibility using a sieve-like approach: O(Elog⁡G).

• Final assignment process: O(G).

Thus, the overall complexity is approximately O(Elog⁡G+Glog⁡G), which is efficient.

Problem3: Count Substrings Divisible By Last Digit

In this problem, we should find the substring that is divisible by the last digit. The string size is too long, so that we cannot check all substrings within the limited time.

In this case, we can only find the substring by calculating the remainder. Let’s say dp[i] means the number of substrings whose remainder is i in the current index. If we move to the next index, then every substring will become X * 10 + (next value). It means that every remainders should be recalculated by (X * 10 + next value) % divisor.

• For example, if we divide the substring “124” by 3, then the remainder will be 1.

• If the substring is “1243”, which is the 124 * 10 + 3, then the remainder will be (1 * 10 + 3) % 3 == 1. It means that If calculate the next remainder with current value x, then we can find the divisible substring counts with dp[0].

If the current value is the divisor, then we should add dp[0] to answer.

class Solution {
public:
    long long countSubstrings(string s) {
        long long totalCount = 0; // Stores the total valid substrings count
        
        // Iterate over possible last digits (1 to 9)
        for (int divisor = 1; divisor <= 9; ++divisor) {
            vector<long long> dp(divisor, 0LL); // DP array to track remainders

            // Iterate over the string to form substrings
            for (char c : s) {
                int currentDigit = c - '0'; // Convert char to int
                vector<long long> newDP(divisor, 0LL); // Temporary DP array

                // Update DP table for substrings ending at this digit
                for (int remainder = 0; remainder < divisor; ++remainder) {
                    int newRemainder = (remainder * 10 + currentDigit) % divisor;
                    newDP[newRemainder] += dp[remainder]; // Carry forward counts
                }

                // Count single-digit substrings
                newDP[currentDigit % divisor]++;
                
                // Update DP table
                dp = newDP;

                // If the substring ending here is divisible by its last digit, count it
                if (currentDigit == divisor) {
                    totalCount += dp[0];
                }
            }
        }
        
        return totalCount;
    }
};

Time Complexity Analysis

• Outer Loop: Iterate over digits 1 to 9 → O(9)=O(1) (constant).

• Inner Loop: Traverse the string of length n → O(n).

• Modular DP Update: Runs in O(9) time for each character.

Thus, the total complexity is O(n), which is optimal for this problem.

Problem4: Maximize the Minimum Game Score

In this problem, we should find the maximum of minimum possible value after, at most, m moves. In this problem, if you can make all points to K within m moves, then you can say that all points are over K-1, K-2, etc. So, we can simply check if random X is okay for the answer. If yes, we only need to check the values above X. Otherwise, check those below X.

Then, we need to solve the problem of whether it is possible to make all values larger than or equal to X if X is given. Now the X is given, we can calculate how many times we should visit every index.

• cnt[i] = (X + points[i] -1) / points[i]

Now, we can visit the index i greedily. No matter how far you go from i, you should visit the current index(i) at cnt[i] times. In this problem you should visit all indexes to get back to the index i and every move counts. So, we just can visit the current cnt[i] times first, then we can go to the next index.

• To visit index i, we can start from the previous index. [move i-1 to i]

• And then, we should go to the next index and get back to the current as many times as needed. [move i to i+1 and move i+1 to i] * (cnt[i]-1 times).

  • We already visit once from the previous index, so we just need the cnt[i] - 1 times visit more.

  • In this case, we should reduce the cnt[i+1] by (cnt[i]-1).

• If cnt[i] ==0 , even though we don’t need to visit more, then we need to move to i to visit the i+1 index.

  • However, if the cnt[i] == 0 and the i == n-1, which means that we don’t need any more visit after i, then we can stop moving.

class Solution {
public:
    // Helper function to check if a given minimum value can be achieved
    bool isPossible(vector<int>& points, long long targetValue, int maxMoves) {
        int n = points.size();
        vector<long long> requiredUpdates(n);
        long long totalMoves = 0;

        // Calculate how many times each index needs to be updated to reach targetValue
        for (int i = 0; i < n; ++i) {
            requiredUpdates[i] = (targetValue + points[i] - 1) / points[i]; // Ceiling division

            // If previous index was updated, adjust current index accordingly
            if (i > 0 && requiredUpdates[i - 1] > 0) {
                totalMoves += 2 * requiredUpdates[i - 1] - 1;
                requiredUpdates[i] = max(0LL, requiredUpdates[i] - (requiredUpdates[i - 1] - 1));
            } 
            // Otherwise, if we are in the middle of the array, count a move
            else if (i > 0 && i != n - 1) {
                totalMoves++;
            }
        }

        // Handle last index separately
        if (requiredUpdates[n - 1] > 0) {
            totalMoves += requiredUpdates[n - 1] * 2;
            if (requiredUpdates[n - 2] > 0) {
                totalMoves--; // Reduce one move if second last index was updated
            }
        }

        return totalMoves <= maxMoves; // Check if we can achieve the target value within maxMoves
    }

    // Binary search to find the maximum possible minimum value
    long long maxScore(vector<int>& points, int m) {
        long long left = 1, right = 1e15, answer = 0;

        while (left <= right) {
            long long mid = left + (right - left) / 2;

            // Check if it's possible to maintain a minimum score of 'mid'
            if (isPossible(points, mid, m)) {
                answer = mid; // Store the valid answer
                left = mid + 1; // Try for a higher minimum value
            } else {
                right = mid - 1; // Reduce the search space
            }
        }
        
        return answer; // Maximum minimum possible value
    }
};

Time Complexity Analysis

• Binary Search: Runs in O(log 1e15) ≈ O(50)

• Greedy Checking Function (pos): Iterates over n elements → O(n)

• Total Complexity: O(nlog⁡1e15)≈ O(n⋅50) → O(n) in practical cases.

Solution

In this problem, we should find the shortest path from 0 to n-1 and all edges that can be used as the shortest path.

If you track all the paths while getting the shortest path, this problem seems complicated. We are not sure the current path is the shortest path until we reach the Node n-1.

However, we know that Dijkstra’s algorithm returns the shortest path to all nodes from the starting node. It means that if we get all shortest paths from Node 0 to all nodes, then we can detect the edge from that node is used as the shortest path by comparing the dist[currentNode] + cost == dist[targetNode].

For example,

• The shortest path to Node 1 costs 5.

• And the shortest path to Node 2 costs 7.

• Then, if the edge connecting Node 1 and Node 2 costs 2, it can be used as the shortest path to Node 2.

  • If it costs more than 2, it must not be the shortest path because there is another way to get to Node 2.

We should iterate from the destination to determine whether the edge can be used. We wouldn’t know the following possible nodes from the start. If we find the possible nodes from the destination, we can get all possible edges to those nodes similarly.

class Solution {
public:
    vector<bool> findAnswer(int n, vector<vector<int>>& edges) {
        // Step 1: Build the graph as an adjacency list
        unordered_map<int, vector<pair<int, int>>> graph;
        for (int i = 0; i < edges.size(); ++i) {
            int u = edges[i][0], v = edges[i][1];
            graph[u].push_back({v, i}); // Store {neighbor, edge index}
            graph[v].push_back({u, i});
        }

        // Step 2: Use Dijkstra's algorithm to find shortest distances from node 0
        vector<int> dist(n, 1e9);  // Initialize distances with a large value
        dist[0] = 0;
        
        // Min-heap (priority queue) for Dijkstra's algorithm
        priority_queue<pair<int, int>> pq;
        pq.push({0, 0});  // {distance, node}

        while (!pq.empty()) {
            auto current = pq.top();
            pq.pop();
            int d = -current.first;  // Convert back to positive distance
            int node = current.second;

            // Ignore outdated distances (optimization)
            if (dist[node] < d) continue;

            // Explore neighbors
            for (auto &neighborData : graph[node]) {
                int neighbor = neighborData.first;
                int edgeIndex = neighborData.second;
                int cost = edges[edgeIndex][2];  // Edge weight

                // Relaxation step: Update shortest distance if a better path is found
                if (dist[neighbor] > d + cost) {
                    dist[neighbor] = d + cost;
                    pq.push({-dist[neighbor], neighbor});  // Push with negative for min-heap behavior
                }
            }
        }

        // Step 3: Backtrack from node n-1 to find edges used in shortest paths
        vector<bool> answer(edges.size(), false);
        vector<bool> seen(n, false);
        
        queue<int> q;
        q.push(n - 1);
        seen[n - 1] = true;

        while (!q.empty()) {
            int node = q.front();
            q.pop();

            // Traverse backwards to find shortest path edges
            for (auto &neighborData : graph[node]) {
                int neighbor = neighborData.first;
                int edgeIndex = neighborData.second;
                int cost = edges[edgeIndex][2];

                // If the edge belongs to a shortest path
                if (dist[neighbor] + cost == dist[node]) {
                    answer[edgeIndex] = true;
                    if (!seen[neighbor]) {
                        seen[neighbor] = true;
                        q.push(neighbor);
                    }
                }
            }
        }

        return answer;
    }
};

Time Complexity Analysis

• Graph Construction: O(m), where m is the number of edges.

• Dijkstra’s Algorithm: O((n + m) log n), since each node and edge are processed at most once in a priority queue.

• Backtracking using BFS: O(n + m), since each node and edge are visited once.

Overall Complexity: O((n + m) log n), which is efficient for large graphs.

Solution

In this problem, we should find the second minimum shortest path to the destination. If the problem wants the minimum shortest path, it would be solved with Dijkstra's algorithm. However, we should do more to find the second one.

One thing we can do is to put all possible paths until we reach the destination twice at different times. Unlike Dijkstra’s algorithm, we don’t need to compare the minimum times to get to the next vertex. If we use min-heap, the answer will be returned as expected.

The solution above takes too long because it contains too many duplicates to reach each vertex. So, we reduce the duplication to make it faster.

If we get to the vertex X at time Y, then we don’t need to revisit X with time Y because the answer after that will be the same. For example, if the minimum path from 1 to N is 1 → 4 → N and we visited vertex 4 at time 10. Then, we don’t need to revisit vertex 4 at time 10 from vertice other than 1 because even though the routes are different, time to N will be the same.

So, we can remove the case where we visited the vertex X with the time Y. Also, we only need to get the second minimum, meaning we don’t need to get the third minimum time to visit each vertex.

class Solution {
public:
    // Adjacency list representation of the graph
    unordered_map<int, vector<int>> graph;

    int secondMinimum(int n, vector<vector<int>>& edges, int time, int change) {   
        // Build the graph from the given edge list
        for (auto & edge : edges) {
            graph[edge[0]].push_back(edge[1]);
            graph[edge[1]].push_back(edge[0]);
        }

        // Priority queue for Dijkstra-like traversal (min-heap)
        priority_queue<pair<int, int>> pq;
        pq.push({0, 1});  // {travel time, node}

        // Store up to two shortest arrival times at each node
        vector<vector<int>> arrivalTimes(n + 1);
        arrivalTimes[1].push_back(0);  // Start at node 1 with time 0

        while (!pq.empty()) { 
            auto current = pq.top();
            pq.pop();
            int travelTime = -current.first;  // Negating since we use max-heap simulation
            int node = current.second;

            // If we reach the destination and recorded the second arrival time, return it
            if (node == n && arrivalTimes[node].size() == 2) {
                return arrivalTimes[node].back();
            }

            // Handle traffic signal: Wait if the light is red
            if ((travelTime / change) % 2 == 1) {
                travelTime = change * ((travelTime / change) + 1);  // Wait until green
            }

            // Explore all adjacent nodes
            for (auto & neighbor : graph[node]) {
                int newTime = travelTime + time;

                // If the neighbor already has two recorded times, ignore
                if (arrivalTimes[neighbor].size() > 1) continue;

                // Ensure we record two **distinct** times per node
                if (!arrivalTimes[neighbor].empty() && arrivalTimes[neighbor].back() == newTime) continue;

                // Store new travel time and push to queue
                arrivalTimes[neighbor].push_back(newTime);
                pq.push({-newTime, neighbor});  // Use negative to simulate min-heap
            }
        }

        return -1;  // Should never be reached if a second minimum path exists
    }
};

Time Complexity Analysis:

• Graph Construction: O(E), where E is the number of edges.

• Priority Queue Operations:

  • Each node can be pushed into the queue at most twice (O(2N log N) ~ O(N log N)).

  • Each edge is processed at most twice (O(2E)).

• Overall Complexity: O((N + E) log N), which is efficient for large graphs.

To get the correct answer, we should find the character that appears most at odd times and the one that appears least at even times.

So, I iterate the input string and record the frequency for all characters. Then, I calculate the maximum odd frequency and minimum even frequency. In this case, we cannot use characters that are not shown.

class Solution {
public:
    int maxDifference(string s) {
        vector<int> cnt(26, 0);
        for (auto &c:s)cnt[c-'a']++;
        int maxOdd = 0, minEven = 1e9;
        for (auto & x:cnt) {
            if (x == 0) continue;
            if (x % 2 == 0) minEven = min(minEven, x);
            else maxOdd = max(maxOdd, x);
        }
        return maxOdd - minEven;
    }
};

[Problem 2] Maximum Manhattan Distance After K Changes

In this problem, we should find the maximum Manhattan distance from (0, 0). We can calculate the Manhattan distance by [X1 - X0| + [Y1 - Y0|. If we want it to be maximum, we should minimize the opposite moves, such as N-S and W-E.

So, we can simply choose a maximum of one from N/S and one from W/E. Then, we can change the direction at most K from both minimum directions.

• For example, N = 6, S = 4, E = 5, W = 2, K = 5

  • Then, we can choose N and E.

  • We change 4 S to 4 N and 1 W to 1 E (Total K times).

  • Then it became N= 10, S = 0, E = 6, W = 1, so the answer is 15.

We should check the answer at each index. The maximum can be found in the middle of the moves.

class Solution {
public:
    int maxDistance(string S, int k) {
        int n = 0, w = 0, s = 0, e = 0, ans = 0;
        for (auto & c:S) {
            if (c == 'N') n++;
            else if (c == 'W') w++;
            else if (c == 'S') s++;
            else e++;

            int curr = max(n, s) + max(w, e), minus = min(n, s) + min(w, e);
            int changed = min(minus, k);
            minus -= changed;
            curr += changed;
            curr -= minus;
            ans = max(ans, curr);
        }
        return ans;
    }
};

[Problem 3] Minimum Increments for Target Multiples in an Array

In this problem, we should find the minimum increments to meet the condition. The critical point is that we only can increase the element. By this restriction, we can calculate the minimum value to make nums[i] to be the multiple of targets[j].

However, we don’t know which number will be the multiple of which target. Also, one number can be the multiple of two different targets. We cannot consider all of these cases one by one.

Fortunately, we only have at most 4 targets. It means that if we calculate all the cases that nums[i] cover, it is at most 2^4 = 16. So, it is fast enough to iterate all cases for each index i of nums.

I precalculated the Least Common Multiple for each target combination to get the minimum increment faster. I record the state to find which targets are covered. If all targets are covered before iterating all nums, then return 0. If iterating all numbers finished before covering all targets, return an invalid value.

I also used memoization to skip the duplicated case.

class Solution {
public:
    int n, m;
    unordered_map<int, long long> mp;
    int dp[50001][1<<4];
    long long func(vector<int> & nums, vector<int> & target, int i, int state) {
        if (state == (1<<m) - 1) {
            return 0;
        }
        if (i == n) {
            return 1e9;
        }

        if (dp[i][state] != -1) return dp[i][state];
        
        long long ans = 1e9;
        for (int x = 0; x < (1 << m); ++x) {
            long long l = mp[x];
            long long diff = ((nums[i] + l-1) / l) * l - nums[i];
            ans = min(ans, func(nums, target, i+1, state | x) + diff);
        }

        return dp[i][state] = ans;
    }

    int minimumIncrements(vector<int>& nums, vector<int>& target) {
        n = (int)nums.size();
        m = (int)target.size();
        memset(dp, -1,sizeof(dp));
        mp[0] = 1;
        for (int x = 1; x < (1 << m); ++x) {
            vector<long long> a;
            for (int j = 0; j < m; ++j) {
                if (x & (1 << j)) {
                    a.push_back(target[j]);
                }
            }
            long long l = a[0];
            for (int i = 1; i < a.size(); ++i) {
                l = l * a[i] / gcd(l, a[i]);
            }
            mp[x] = l;
        }

        return func(nums, target, 0, 0);
    }
};

[Problem 4] Maximum Difference Between Even and Odd Frequency II

We should find the maximum difference between odd frequency and even frequency. This problem is the hard version of problem 1. The reason why the first problem is easy is that the size of the string is fixed. We only need to care about the frequency of each character.

However, we can't use the same strategy in this problem because we don’t know the size. If we fix the size, we should iterate every character of the input string for each possible size larger than K. If K == 1, then it should take O((26) * N^2) times. So, this won’t work.

Fortunately, we know that there are only 5 characters that can be shown in the input string. We don’t know which one will be the answer, but the answer case will use only 2 characters: One for the odd frequency and one for the even frequency. Also, there are only 20 possible combinations. Assuming the characters for counting and getting the answer within O(N) or O(NlogN) time complexity, iterating 20 times wouldn’t be the problem.

So, I tried to consider the case when only two characters exist. Let’s ignore the size of substring K.

How to calculate the frequency for a range query.

To get the correct answer, we should find the exact case where an odd frequency character should appear at odd times and an even frequency character should appear at even times. But we are not sure if index i will meet the conditions. We should remove the character from the start if it does not meet. In short, we should calculate the count for each character within the range of [left, right].

To calculate it faster, I precalculate the prefix sum, which contains the frequency data of the odd-frequency character and the even-frequency character within [0, i]. To find out the counting status of [i, j], we can simply subtract the prefixSum[i-1] from the prefixSum[j].

How can we ensure the proper case for the answer?

Now, we should find the right index i where [i, j] is the possible case for the answer. It means that when we iterate the input string, we should find the left index that will meet the condition. This is pretty complex.

What I thought of was the following conditions:

• We have already set the odd-frequency character and even-frequency character, and my goal is to find the case where an odd-frequency character appears at odd times, and the even-frequency character appears at even times.

• If both characters appear at even times at index i, I should find the left index where an odd-frequency character appears at odd times and the even-frequency character appears at even times.

  • For example, both characters appear 6 times at index i. If we found the j where j < i and odd-frequency character appeared 3 times and even-frequency character appeared 2 times.

  • If we remove the characters [0,j] from [0, i], then [j+1, i] will meet the condition because odd-frequency appeared 3 times(6 - 3), and even-frequency appeared 4 times(6 -2).

• In short, we can record each counting status at each index i and then find the correct index for the right counting status type.

  • There will be four different statuses.

    • (Odd, Even) = odd-frequency appears odd times, even-frequency appears even times,

    • (Even, Even) = odd-frequency appears even times, even-frequency appears even times,

    • (Odd, Odd) = odd-frequency appears odd times, even-frequency appears odd times,

    • (Even, Odd) = odd-frequency appears even times, even-frequency appears odd times,

  • To get the (Odd, Even) case, we can find the correct status for removal.

    • (Odd, Even) - (Even, Even) = (Odd, Even)

    • (Even, Even) - (Odd, Even) = (Odd, Even)

    • (Odd, Odd) - (Even, Odd) = (Odd, Even)

    • (Even, Odd) - (Odd, Odd) = (Odd, Even)

• This can be implemented by recording the types at each index i and enqueuing them to each type queue. We can then find the index j for removal from the matching status type queue at index i.

  • If (Odd, Even) is at index i, find the index from the (Even, Even) queue.

How can we ensure the size of the substring?

To ensure the size of the substring, we can use a pointer to follow the index to keep the size of the substring and enqueue the value for each type of queue. We cannot calculate the answer before we enqueue the value to the queue. This means we should ensure that the enqueued items are okay to get the answer.

So, if the i—(left index) >= K meets, we can enqueue the left index item to the queue and then move the left index to the right.

class Solution {
public:
    int func(string & s, int k, char & oddChar, char & evenChar) {
        const int n = (int)s.size();
        vector<vector<int>> cnt(n, vector<int>(2));
        int oddCharCnt = 0, evenCharCnt = 0;
        vector<int> T(n);
        for (int i = 0; i < n; ++i) {
            if (s[i] == oddChar) oddCharCnt++;
            else if (s[i] == evenChar) evenCharCnt++;
            cnt[i][0] = oddCharCnt, cnt[i][1] = evenCharCnt;
            if (oddCharCnt % 2 == 0 && evenCharCnt % 2 == 1) T[i] = 0;
            else if (oddCharCnt % 2 == 0 && evenCharCnt % 2 == 0) T[i] = 1;
            else if (oddCharCnt % 2 == 1 && evenCharCnt % 2 == 0) T[i] = 2;
            else T[i] = 3;
        }
        int ans = -1e9, curr = 0, l = 0;

        auto getOppositeIndex  = [&] (int t) {
            if (t == 0) return 3;
            if (t == 1) return 2;
            if (t == 2) return 1;
            return 0;
        };

        auto isPossible = [&] (int i, int j) {
            int oddCharCnt = cnt[i][0] - (j == -1 ? 0 : cnt[j][0]);
            int evenCharCnt = cnt[i][1] - (j == -1 ? 0 : cnt[j][1]);
            return oddCharCnt > 0 && evenCharCnt > 0 && oddCharCnt % 2 == 1 && evenCharCnt % 2 == 0 && i - j >= k;
        };

        vector<int> minimumCanRemove(4, 1e9);
        queue<int> q[4];
        for (int i = 0; i < n; ++i) {
            int curr = cnt[i][0] - cnt[i][1];
            while(i - l >= k) {
                q[T[l]].push(l);
                ++l;
            }
            int oppositeType = getOppositeIndex(T[i]);
            while(!q[oppositeType].empty() && isPossible(i, q[oppositeType].front())) {
                int prevIdx = q[oppositeType].front();
                q[oppositeType].pop();
                minimumCanRemove[oppositeType] = min(minimumCanRemove[oppositeType], cnt[prevIdx][0] - cnt[prevIdx][1]);
            }
            ans = max(ans, curr - minimumCanRemove[oppositeType]);
            if (T[i] == 2 && isPossible(i, -1)) ans = max(ans, curr);
        }

        return ans;
    }

    int maxDifference(string s, int k) {
        int ans = INT_MIN;
        for (char i = '0'; i <= '4'; ++i) {
            for (char j = '0'; j <= '4'; ++j) {
                if (i == j) continue;
                ans = max(ans, func(s, k, i, j));
            }
        }
        return ans;
    }
};

A monotonic queue keeps track of elements in increasing or decreasing order, so this should be used when we don’t need to insert the elements between the elements in the queue. This means we should push the current element back to the queue after dropping the smaller or larger elements from the back to keep the order. This implies that we don’t need to use the dropped elements anymore.

Let’s solve some problems to practice a monotonic queue.

Subscribe now

Problem 1: Sliding Window Maximum

In this problem, we should find the maximum elements of a fixed window. This means we should keep track of the largest element as we iterate the elements. We should find a way to find the next largest element if we drop the current largest element.

Let’s see the example.

nums = [1, -1, 10, 2, 11, 3, 7, 5] , k = 3

• The window size is 3, so we can start getting the maximum value since we iterate at least 3 elements.

  • 1st window is [1, -1, 10]. The maximum value is 10.

  • 2nd window is [-1, 10, 2]. The maximum value is 10.

  • 3rd window is [10, 2, 11]. The maximum value is 11.

  • 4th window is [2, 11, 3]. The maximum value is 11.

  • 5th window is [11, 3, 7]. The maximum value is 11.

  • 6th window is [3, 7, 5]. The maximum value is 7.

• So, the answer should be [10, 10, 11, 11, 11, 7].

To solve the problem, we can use a monotonic queue for keeping the largest numbers.

• For every element, check if any elements in the queue are smaller than or equal to nums[i]. It’s because after we put nums[i] to the window, elements smaller than or equal to nums[i] won’t be used as the maximum value.

• Put nums[i] to the back of the monotonic queue. If the queue is empty, then nums[i] is the largest number in the window. If not, there is an element larger than nums[i].

• Check if the position of the first element in the queue is out of the window. If the largest number is out of the window, we should pop it from the queue. We can check this by adding the index(i), not the value(nums[i]) to the queue.

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> ans;
        const int n = (int)nums.size();
        deque<int> q;
        for (int i = 0; i < n; ++i) {
            while(!q.empty() && nums[q.back()] <= nums[i]) {
                q.pop_back();
            }
            q.push_back(i);
            while(!q.empty() && q.front() < i-k+1) {
                q.pop_front();
            }
            if (i >= k-1) {
                ans.push_back(nums[q.front()]);
            }
        }
        return ans;
    }
};

Problem2: K Empty Slots

In this problem, you should find the minimum number of days when two bulbs are turned on and all bulbs between them are turned off.

This problem seems tricky if you keep track of the bulbs’ status. We cannot track the status of every bulb between two turned-on bulbs. However, we can think of the final status of what we want to find.

What we want to find is the following situation.

• If K == 3, then [On, Off, Off, Off, On].

• If K == 0, then [On, On].

So, we can ensure this happens when the minimum number of days to turn on any of the K bulbs is later than the maximum number of days to turn on both the left and right bulbs. Based on the input, we can calculate the days to turn on each bulb.

For example, let’s assume that the array that represents the days to turn on the bulbs is [1,3,4,5,2]. It means that it takes 1 day to turn on the first bulb and 3 days to turn on the second day.

• On the first day, the bulb status is [On, Off, Off, Off, Off].

• On the second day, the bulb status is [On, Off, Off, Off, On].

• This can be proved by calculating the following condition.

  • min({arr[1], arr[2], arr[3]}) > max(arr[0], arr[4])

class Solution {
public:
    int kEmptySlots(vector<int>& bulbs, int k) {
        const int n = (int)bulbs.size();
        vector<int> on(n);
        for (int i = 0; i < n; ++i) {
            on[bulbs[i]-1] = i+1;
        }

        int ans = 1e9;
        deque<int> q;
        for (int i = 0; i < n; ++i) {
            while(!q.empty() && on[q.back()] >= on[i]) {
                q.pop_back();
            }
            q.push_back(i);
            while(!q.empty() && q.front() <= i-k) {
                q.pop_front();
            }
            if (i >= k && i-k >= 0 && i+1 < n){
                int maxOn = max(on[i-k],  on[i+1]);
                if (k == 0 || maxOn < on[q.front()]) {
                    ans = min(ans, maxOn);
                }
            }
        }
        return ans == 1e9 ? -1 : ans;
    }
};

Problem3: Minimum Number of Coins for Fruits II

We should find the minimum number of coins needed to buy all the fruits. If we buy the fruit in the index X, we can get the following (X+1) fruits for free. This might be helpful because buying expensive fruits with a small number of coins is possible.

We can use the dynamic programming technique to get the minimum number of coins at each index.

Suppose that dp[i] means the minimum number of coins needed to buy all fruits after (including) index i. Then, we make the following formula.

• dp[i] = min(dp[j] + prices[i]) for all j where i<= j <= min(i+i+2, n).

  • dp[n] should be 0. This is needed because we can buy the fruits at index i, and all fruits after i are free.

This technique works when the price length (n) is small. Here’s the question that you can try with dynamic programming.

However, in this problem, the maximum size of n is 10^5, so it is not fast enough to use dynamic programming. So, we should find another way.

Looking at the formula above, you will see that we don’t need to know all the dp[j] values. We need the minimum dp[j] within the valid window. For example, if the current index is 5, then we should know the minimum of dp[j] where 6 <= j <= 12(5 + 5 + 2).

So, we can use the monotonic queue to keep track of the minimum value of dp[j] and remove the elements outside the window before calculating the dp[i] value. To make this work, we should iterate from the back.

class Solution {
public:
    int minimumCoins(vector<int>& prices) {
        const int n = (int)prices.size();
        vector<int> dp(n+1, 0);
        deque<int> q;
        q.push_back(n);
        for (int i = n-1; i>=0; --i) {
            while(!q.empty() && q.front() > i + i + 2) q.pop_front();
            dp[i] = prices[i] + dp[q.front()];
            while(!q.empty() && dp[q.back()] >= dp[i]) {
                q.pop_back();
            }
            q.push_back(i);
        }
        return dp[0];
    }
};

Problem4: Count Non-Decreasing Subarrays After K Operations

We should find the non-decreasing subarrays after most K operations. In this case, the operation is increasing one of the elements by 1 in the subarray. This means that we should make every element bigger within the subarray.

Let’s assume that the nums = [6,3,1,2].

• If the subarray is [6,3], it should be [6,6], and the number of operations is 3.

  • To make 3 to 6 → 3 operations.

• If the subarray is [6,3,1], it should be [6,6,6], and the number of operations is 8.

  • To make 3 to 6 → 3 operations.

  • To make 1 to 6 → 5 operations.

• If the subarray is [3,1,2], it should be [3,3,3], and the number of operations is 3.

  • To make 1 to 3 → 2 operations.

  • To make 2 to 3 → 1 operations.

So, when we iterate the elements, we should know how many operations we need to make nums[i] to something. We can use the monotonic queue to store the maximum numbers within the window and add maximum number - nums[i] operations. If the current value is the maximum, the result will be 0.

If the current sum of operations is larger than K, all subarrays containing the current window are invalid. For example, if the nums = [A, B, C, D, E], and the subarray [A, B, C] is invalid. Then [A, B, C, D] and [A, B, C, D, E] are also invalid because they contain the invalid subarray. To calculate the number of invalid subarrays, we can subtract the current index from N(the size of nums).

The hard part is calculating the operations when we reduce the window size. If we find the invalid subarray, we should remove the leftmost value from the window to minimize the operations. In this case, all operation counts should be changed because some of the elements in the window are larger than the next leftmost element.

Let’s say the leftmost element index is L.

• If nums[L] <= nums[L+1], then we don’t need to re-calculate the number of operations because nothing will be changed.

• If nums[L] > nums[L+1], then we should change the number of operations.

For example, the invalid subarray is [6,3,1,5,10], and L = 0.

• Now, nums[1] (3) < num[0] (6).

• Find the next element’s index whose value is larger than or equal to nums[0]. It should be 4(nums[4] = 10).

  • Reduce all operations added from 0 <= i < 4 to make elements to 6.

• Now, reduce the window size by changing L to 1.

• We should re-calculate operations to make it non-descreasing within 1 <= i < 4.

  • Find the next element’s index whose value is larger than or equal to nums[1]. It should be 3(nums[3] = 5).

  • Add all operations to make elements to 3 within 1 <= i < 3.

  • Add all operations to make elements to 5 within 3 <= i < 4.

To calculate the operations faster, we can pre-calculate the prefixSum array and the right-closest index array to contain the index whose value is larger than or equal to the current value.

• To calculate the whole operations from L <= i <= R.

  • nums[L] * (R - L + 1) - (PrefixSum[R] - PrefixSum[L-1])

  • This calculation is only valid if the elements within the range are non-increasing.

class Solution {
public:
    long long countNonDecreasingSubarrays(vector<int>& nums, int k) {
        const int n = (int)nums.size();
        vector<long long> pref(n+1, 0LL);
        vector<int> R(n, n);
        stack<int> st;
        for (int i = 1; i <= n; ++i) {
            pref[i] += pref[i-1] + nums[i-1];
            while(!st.empty() && nums[st.top()] <= nums[i-1]) {
                R[st.top()] = i-1;
                st.pop();
            }
            st.push(i-1);
        }

        auto calc = [&] (int l, int r) {
            long long cnt = r - l + 1;
            return nums[l] * cnt - (pref[r+1] - pref[l]);
        };

        deque<int> q;
        long long tot = ((long long) n * (n + 1)) / 2;
        long long invalid = 0LL;
        int l = 0, cur = 0;
        for (int i = 0; i < n; ++i) {
            while(!q.empty() && nums[q.back()] <= nums[i]) {
                q.pop_back();
            }
            q.push_back(i);
            cur += nums[q.front()] - nums[i];
            while (cur > k) {
                invalid += n-i;
                int nx = min(R[l], i + 1);
                cur -= calc(l, nx-1);
                int j = l+1;
                while(j < nx) {
                    cur += calc(j, min(R[j], i + 1)-1);
                    j = min(R[j], i + 1);
                }
                l++;
            }
            while(!q.empty() && q.front() < l) {
                q.pop_front();
            }
        }

        return tot - invalid;
    }
};

Problem5: Shortest Subarray with Sum at Least K

In this problem, we should find the shortest subarray among subarrays where the sum of elements is larger than or equal to K.

To make it easier, we can pre-calculate the prefix sum and find the matching subarrays by calculating the prefixSum[i] - prefixSum[j]. But this algorithm takes too long because we should iterate the input array for each index i. The time complexity is O(N^2).

What we should do in the solution above is to find the maximum of j where the condition meets(prefixSum[i] - prefixSum[j] >= k). The important thing is that if we find the j, we no longer need the prefixSum[j] value. It’s because if we should use it again, then it would be from prefixSum[x] where i < x, and that can’t be the answer.

Also, we don’t need to consider the case where prefixSum[x] >= prefixSum[y] (x < y) when we find the index j. It’s because if x is possible to use, then y is also possible, and y will be used to get the correct answer as we need the shortest subarray.

So, we can use a monotonic queue to keep track of the prefixSum values in increasing order.

• If the current prefixSum[i] is smaller than the largest value in the element, then pop the last value from the queue.

• If prefixSum[i] - (smallest value from the queue) >= k, then calculate the subarray size.

  • Pop the smallest value from the queue and check if the condition meets with the next smallest value.

  • We should keep doing this until the condition is met.

  • This is because the smallest prefixSum doesn’t ensure the shortest subarray.

class Solution {
public:
    int shortestSubarray(vector<int>& nums, int k) {
        const int n = (int)nums.size();
        vector<long long> pref(n+1, 0LL);
        for (int i = 1; i <= n; ++i) {
            pref[i] = pref[i-1] + nums[i-1];
        }
        deque<int> q;
        q.push_back(0);
        int ans = 1e9;
        for (int i = 1; i <= n; ++i) {
            while(!q.empty() && pref[q.back()] >= pref[i]) {
                q.pop_back();
            }

            q.push_back(i);
            while(!q.empty() && pref[i] - pref[q.front()] >= k) {
                ans = min(ans, i - q.front());
                q.pop_front();
            }
        }
        return ans == 1e9 ? -1: ans;
    }
};

Problem6: Constrained Subsequence Sum

We should find the maximum sum of subsequences that meet the condition. The condition is simple. We cannot choose two elements consecutively where the difference between two indices is larger than K. (j - I <= k, where i < j).

This means we should find the maximum sum from the index range [i-k, i-1] to get the maximum sum in the index i. So, we can use the monotonic queue to keep track of the maximum sum in each index in decreasing order.

• We can drop the element from the front if the index is smaller than i-k.

• We need to consider that use the nums[i] itself without adding something from the queue. This is valid if the largest sum is negative.

• If the maximum sum in the current index is larger than any element in the queue, remove that element from the queue.

class Solution {
public:
    int constrainedSubsetSum(vector<int>& nums, int k) {
        const int n = (int)nums.size();
        deque<int> q;
        int ans = -1e9;
        for (int i = 0; i < n; ++i) {
            while(!q.empty() && q.front() < i-k) {
                q.pop_front();
            }

            nums[i] += (q.empty() ? 0 : max(0, nums[q.front()]));
            ans = max(ans, nums[i]);
            while(!q.empty() && nums[q.back()] <= nums[i]) {
                q.pop_back();
            }
            q.push_back(i);
        }
        return ans;
    }
};

Useful courses

• Grokking the Coding Interview: Patterns for Coding Questions

• Grokking Advanced Coding Patterns for Interviews