While HTTP/2 offers significant improvements over HTTP/1.1—such as multiplexing, header compression, and persistent connections—it also introduces new layers of complexity. Debugging real-world issues involving HTTP/2 can be pretty challenging, especially when working with proxies like Envoy that handle low-level protocol details transparently.

We also use HTTP/2 for our services to take advantage of reusable connections. This can be easily achieved using Istio, which is based on the Envoy and supports high-performance traffic handling. However, sometimes, it is tough to debug with the Envoy because it is too complicated and challenging to know/understand all the options it provides.

Situation

One day, we were told the client could not send the large file. When we tried manually, it got the following error: “upstream connect error or disconnect/reset before headers. reset reason: connection termination”. It was curious because the endpoint was okay, and the network metric seemed fine. One weird thing was that we couldn’t send the file only with the specific size limit, but we never set this limit. So, we needed to dig deeper into this situation.

1. Timeout: Sometimes, TCP or request timeout can be the reason for sending a large payload. Sending large payloads takes some time, and it could exceed the timeout. We calculated the response time to check the timeout issue, but it was not over the timeout we had set.

2. TCP window size full: HTTP/2 utilizes one TCP connection with multiple streams. Sometimes, it is possible that the connection becomes really busy, and TCP cannot receive more packets. To check this, we dumped the TCP connection and checked the TCP window size. Unfortunately, our TCP window size was large enough to receive more packets.

3. HTTP/2 per connection buffer limit size: We can set the buffer limit size of each cluster connection in Envoy, but we never set the stream buffer size(the default is 1MB). If the application could not read the data faster, this might be the limitation. So, we tried to increase the per_connection_buffer_limit_bytes value but had no effect.

4. Check the Envoy debug log: We checked the Envoy debugging log to find out what happened when we sent the large file. We found many “error sending frames: Too many frames in the outbound queue.” error messages in the log. There was an max_outbound_frames option; the connection would be terminated if the max outbound frame count exceeded this limit. I mean, TCP connection, not the stream. When we changed the max_outbound_frames value, it worked well.

Why did Envoy adopt the max_outbound_frames?

While searching for the history, I found the following security issue in the Envoy Github.

• https://github.com/envoyproxy/envoy/security/advisories/GHSA-hm8q-x6qm-xxvw

• https://github.com/envoyproxy/envoy/security/advisories/GHSA-q24r-4w7h-qv3p

• https://github.com/envoyproxy/envoy/security/advisories/GHSA-5m79-fj88-wc5m

• https://github.com/envoyproxy/envoy/security/advisories/GHSA-jhv4-f7mr-xx76

The max_outbound_frames option was adopted in 2019 when there was a ping flood issue with HTTP/2. However, there was another similar issue in 2023. Even though this was not the main reason for adopting the option, we can find why it should terminate the whole connection, not the stream, here.

There was a DoS Vulnerability related to the Rapid Reset in HTTP/2. Simply put, it was the DoS attack by sending many requests using stream with RST_STREAM frames.

RST_STREAM is used to close the stream logically within the TCP. Basically, most proxy has the default max concurrent streams per TCP connection, so many simultaneous requests would create many TCP connections. This can be detected quickly, and scale-out might mitigate the issue.

However, because of the RST_STREAM frame, the server closes the stream every time it gets the header. However, the server should create the resource to handle the header and route to other destinations if used in the proxy. It can cause a resource shortage because it consumes the CPU or network. To make matters worse, it is not easy to detect because it is proceeded within a single TCP connection.

The Google blog said we should close the TCP connection to mitigate this issue. This will prevent the malicious user from using all the server resources. Even though trying again with a new TCP connection is possible, it would be closed every time it tries.

You can find this by checking the TCP dump file. I reproduced the traffic to test this option. I made a script to regularly send the traffic with a small payload. The server will wait 30 seconds before sending the response, which means it is unnecessary to close the stream before sending the large file. Then, I sent a massive payload with the HTTP/2 protocol.

• Server: listening port 8000

• Envoy: Listening port 10000 and proxy all requests to server:8000

Here is a sample of the TCP stream. As you can see, stream 5 sent the request, and it did not get a response. (There was no 200 OK packet.) However, when I sent the heavy request with a 100MB payload, the whole TCP connection was finished because of the envoy. The FIN packet sender was the Envoy!

Why was the outbound queue increased?

The Envoy provides the HTTP Buffer filter to limit the request size. We set this filter to prevent users from sending too large files, which might affect network performance. This is also useful when the upstream cannot read the stream data.

If this filter is enabled, when the Envoy receives the frame, it holds the data inside the frame and does not send it upstream. When it gets all the payload, it passes the data upstream with a content-length header(if missing). At this moment, the nghttp2 library splits all the data into multiple frames to meet the requirements for the HTTP/2 protocol.

The HTTP/2 frame size is 16KB by default. So, nghttp2 will break the payload down to a 16KB chunk and send it as one frame. When the frame is ready, Envoy adds it to outbound_queue until the frame is well received.

However, splitting frames is way faster than sending frames upstream. This caused the outbound_queue to overflow.

Takeaways

• We should check the max_outbound_frames value when the buffer filter is enabled. Buffer filtering can be useful when you want to buffer the request inside the Envoy, but this can cause unexpected TCP termination.

• We should set the maximum number of concurrent streams in a single TCP connection to mitigate the flooding issue. Otherwise, a single TCP termination will cause bulk stream resets.

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

SSH is a Secure Shell Protocol used broadly to connect to a server. Although it is not implemented based on TLS, it is treated as secure because all packets in the TCP session are encrypted. Even though we did not set any certificate or private key for SSH, this magical communication happens automatically.

I would like to dive deep into how this magical communication can happen. By the way, I am not an expert in mathematics, so I will skip the detailed implementation or calculation about cryptography(because I can’t even understand all of them…). I don’t think you need to know all the internal formulas for software engineering.

Preparation

I prepared the packet capture to explain what happens inside the SSH protocol. I created the EC2 instance with an RSA PEM key and tried to connect to the server with the paramiko library. Paramiko is a pure Python implementation of the SSHv2 protocol, providing both client and server functionality. Even though I’m unsure if the implementation is the same as other libraries, I think it is enough to understand the overall process.

import paramiko
from io import StringIO

def main():
    client = paramiko.SSHClient()
    ip = "<ssh server ip>"
    port = 22
    keypair_file_path = "test-key.pem"

    with open(keypair_file_path, "r") as f:
        keypair = f.read()
    keypair_io = StringIO(keypair)
    key = paramiko.RSAKey.from_private_key(keypair_io)
    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    client.connect(hostname=ip, port=port, username="ec2-user", pkey=key)

    stdin, stdout, stderr = client.exec_command("ls -al")
    print(stdin, stdout, stderr)
    client.close()


if __name__ == '__main__':
    main()

Here’s the packet capture opened with Wireshark. You can see the SSHv2 in the protocol tap. Now, let’s inspect what happens step by step.

1. TCP connection

First, it is implemented over TCP. The client tries to create a TCP connection to the server. In the paramiko library, the client.connect function creates a socket if no socket is passed.

2. Version Check

Before starting the key exchange, the client and the server identify the SSH version. As you can see, it is now v2.

3. Negotiating the key exchange algorithm

The client sends the key exchange message through the TCP connection with supported and preferred key exchange algorithms.

You can find the kex(key exchange) algorithm if you check the packet inside. The client sends first, and then the server returns. If you inspect the packet in detail, you can find all the algorithms the client and server use.

If the client receives the exchange algorithm list from the server, it decides which algorithm to use. It searches for the algorithms that it prefers and that are contained in the algorithm list that the server sends. The paramiko library sets the first algorithm in the list for exchanging keys.

Here are the client's preferred key exchange algorithms. If you look at the packet from the server, you will see the curve25519-sha256@libssh.org.

3. Key Exchange with Diffie-Hellman algorithm

Now that we have decided to use the curve25519-sha256@libssh.org method, the client generates the private key to exchange with the DH algorithm. Diffie-Hellman is a key exchange algorithm usually used to safely exchange keys for generating the symmetric key. In my test environment, it is using the Elliptic Curve Diffie-Hellman Key Exchange algorithm, but normal DH works similarly.

The client and server generate the private key, a random number. The x25519 private key is a cryptographic key used in the X25519 key exchange protocol based on elliptic curve cryptography. The server just waits after generating its own private key.

On the other hand, the client sends the KEXECDH_INIT message to exchange the key with the Elliptic Curve DH method. At this time, it calculates the public key, which is a point on the elliptic curve derived from the private key. After sending a message, it waits for the KEXECDH_REPLY message.

The server, waiting for the KEXECDH_INIT packet, receives the packet from the client. The public key is included in the packet capture, but it is not encrypted yet.

Now, the server parses the packet to initiate the ECDH exchange. First, it retrieves the public key value from the packet. Then, it calculates the shared secret with its private key. Then, it generates its public key from the private key and sends it to the client.

Here’s the server's reply packet. It sends its ephemeral public key and its public host key.

The client, waiting for the rely, also tries to generate the shared secret. It retrieves the public key from the packet and computes the shared secret.

Here’s where the magic happens.

Even the calculation on the client side seems different from that on the server side because the client calculates the shared secret with its private key and the server’s public key, and the server does so with its private key and the client’s public key.

• Server: Server’s private key & Client’s public key.

• Client: Client’s private key & Server’s public key

Behind the scenes, the curve25519 algorithm contains the curve’s base point. Generating a public key from each side is the mathematical scala-multiplication of its private key and the curve's base point. This means the public key already contains the private key as the calculation.

• Server: Server’s private key & (Client’s private key & curve base point)

• Client: Client’s private key & (Server’s private key & curve base point)

In this case, both results are the same mathematically.

4. Retrieves the in & out key and IV

Both sides have the same shared secret, so they can encrypt and decrypt with the symmetric key, which is the shared secret. The client and server retrieve the Initialization Vector(IV) and the encryption key for outbound traffic. Those values are used when each encrypts the outbound packet.

You should know that they are not using the same key for inbound and outbound traffic. The code above shows that the client and server compute keys with different ID values. The order is changed for the inbound traffic.

_active_inbound method is called when it gets a NEW_KEYS message. As you can see, IDs used in the client for outbound are the same as those used in the server for inbound.

• Client-side

  • Encryption: Uses key derived from "C" and IV from "A"

  • Decryption: Uses key derived from "D" and IV from "B"

• Server-side

  • Encryption: Uses key derived from "D" and IV from "B"

  • Decryption: Uses key derived from "C" and IV from "A"

Until now, both client and server have exchanged keys and calculated the ciphers for encryption and decryption. In the current session, all packets are encrypted with precalculated ciphers. If a new session is created, all exchange processes will happen again.

5. Encrypt and decrypt the packet

When the client sends the packet, it checks the self.__block_engine_out method. It is defined as retrieving keys from a shared secret. So, before exchanging the key, the packet is not encrypted.

It’s the same when it gets an inbound packet. When it gets a packet from the other side, the read_message method is called. This method uses __block_engine_in to decrypt the packet.

Conclusion

In conclusion, when the SSH session is created via TCP, the client and server exchange keys to calculate the shared secret with the Diffie-Hellman algorithm.

In the Diffie-Hellman key exchange algorithm, each generates the public key by multiplying its private key and a common random number. Those public keys don’t need to be hidden from the hacker. When the client and server exchange the public key, they calculate it with their private key. Then, they get the same shared secret to generate the encryption key. After setting up the encryption and decryption ciphers, they can encrypt and decrypt both inbound and outbound packets.

Deep Dive into Class and Instance in Python

In Python, you can create an object from the class to represent specific data and perform several actions. The data is presented as variables, and the actions are methods.

The simple User class has two variables and two different methods. It has a name and age as data. Also, it can perform “introduce” and “hello” with its own data.

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        return f"My name is {self.name} and I am {self.age} years old"

    def hello(self):
        return f"Hello, I am {self.name}"

You should know that this is just a template about the User.

The actual user should be created as an object with actual data. We usually call this an instance. An instance is an object made from the class with the actual data. Its shape is literally the same as the User class, but the difference is that it has the actual data. The methods are still tied to the class and are not copied to the instance.

Let’s create some instances from the User class. I made two instances with a different variable name and age values.

daniel = User("Daniel", 35)
emily = User("Emily", 20)

daniel.introduce()
emily.introduce()

# Result
--------------------------------
'My name is Daniel and I am 35 years old'
'My name is Emily and I am 20 years old'

Now, let’s check how the introduce function works internally. If you print the function without calling it, you can see which function is bound to it. As you can see from the result below, it is tied to the method User.introduce, and the object is 0x103be9eb0, which is the id of the Daniel object.

This means that I can call the function like this.

See? The same result came out.

What would happen if I changed the method in the class after creating the instance?

Let’s change the introduce method to return a different string. As you might guess, the instance method has been changed as well. This is simply because the instance method is actually bound to the class. A class function is called with the instance as a function parameter.

This is why we add self to the instance method. Internally, calling the instance method is the same as calling a class function with an instance as a parameter.

daniel.introduce() == User.introduce(daniel)

What is the __new__ method?

The object is made based on the class definition when you create the instance. Some might have learned that the __init__ method is used to create an instance, but it’s wrong. It is just the initialization method that is called after the instance is created. The actual method to create an instance is the __new__ method.

Let’s create the instance using the __new__ method.

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        return f"My name is {self.name} and I am {self.age} years old"

    def hello(self):
        return f"Hello!!"

mark = User.__new__(User)
print(mark.__dict__)
print(type(mark))
print(isinstance(mark, User))
print(mark.hello())


# Result
--------------------------------
{}
<class '__main__.User'>
True
Hello!!

The instance named mark was created successfully but has no data inside the __dict__ variable. However, the hello function is available because it is an instance of the User class. If you want to give it a name and age, you should call the __init__ method. This is how Python creates the instance and initializes the data of that instance.

How does __new__ and __init__ works internally

When you create a class, it actually inherits the object type. Object type is the base class that CPython manages. So, when you make a new type by making the class, it inherits an object and calls it an object.__new__ method.

First, when you create the class, it actually calls the type() function internally. The type function is used to create a custom type like a class. If the type is well created, you create an instance with that type, which is the class here.

In CPython, type_call is the function called when you create an instance with a class type like User(). In this function, type→tp_new is called. After that, type→tp_init is called, and the object is passed as a parameter.

static PyObject *
type_call(PyObject *self, PyObject *args, PyObject *kwds)
{
    PyTypeObject *type = (PyTypeObject *)self;
    PyObject *obj;

    //(... skipped ...) 

    obj = type->tp_new(type, args, kwds);
    obj = _Py_CheckFunctionResult(tstate, (PyObject*)type, obj, NULL);
    if (obj == NULL)
        return NULL;

    //(... skipped ...) 

    type = Py_TYPE(obj);
    if (type->tp_init != NULL) {
        int res = type->tp_init(obj, args, kwds);
        
        //(... skipped ...) 
    }
    return obj;
}

You can ensure that the tp_init is called after creating the object with the tp_new function. Now, we need to find out the actual code of tp_new for the object type.

Here’s the CPython code that defines the object type. The tp_new function is mapped with the object_new function.

PyTypeObject PyBaseObject_Type = {
    PyVarObject_HEAD_INIT(&PyType_Type, 0)
    "object",                                   /* tp_name */
    sizeof(PyObject),                           /* tp_basicsize */
    // ( ... skip ... )
    object_init,                                /* tp_init */
    object_new,                                 /* tp_new */
};

Let’s examine the object_new function to discover what happens inside the __new__ method.

static PyObject *
object_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    // (...skipped...)

    PyObject *obj = type->tp_alloc(type, 0);
    if (obj == NULL) {
        return NULL;
    }
    return obj;
}

“It just allocates the object's memory.”

Now, you can assume that no matter what type your class type inherits, you should make it call the object.__new__ method to allocate the memory for the class. If you do not call the object.__new__ method, then it does not call __init__ method because type_call checks the return object type.

You can test this by customizing the __new__ method for the base type. Here’s an example. I made two classes and inherited A from B. When super().__new__(cls) line is executed, it calls the __new__ method in class A. But the __new__ method of class A returns the string type. So, the __init__ method is not called.

Summary

Here’s the overall process for creating the class and the instance. Remember that the __init__ method is just for initializing the instance. The __new__ method creates the instance itself in memory.

1. Build a Matrix With Conditions

link: https://leetcode.com/problems/build-a-matrix-with-conditions/description

This problem states that we must find a matrix that meets the row and column conditions. Each condition contains the order of numbers that should appear from top to bottom and from left to right. For example, if one of the row conditions is [2, 3], 2 should appear upper than 3. If one of the column conditions is [2, 3], 2 should appear on the left of 3.

Even though it is a k-by-k matrix, let’s consider it one dimension. We can solve the problem only with the row conditions first.

No matter how many conditions are provided, we only have k numbers. Matrix also has k rows. This means we can ensure that each number is placed in each row. So, we don’t need to consider the case of two numbers located in the same row.

We need to solve the order in which the numbers are placed. This problem has now been changed to a graph problem. A similar situation is finding the order of classes I should take when the prerequisites of each class are provided. To solve this problem, we can use the topology sort algorithm to get orders from graphs.

One thing we need to check here is the case that has the cycle. 1 → 2 → 3 → 1 is one case with the cycle because 3 should be placed above 1, but 1 should be above 3, too. This cannot happen! If this case is found, we should return an empty list as the answer.

So, we can use a color mechanism to check if the current number is in progress or completed. Let’s assume that color 0 means ready state. If we start finding orders of nodes with connected edges, then let’s change the color to 1. If all connected edges are well ordered, add the current node to the array and change the color to 2.

While processing each number, we can check the current color to see if the number is in progress. If the color of the number is 1, we face the cycle! In this case, we can return None to detect the cycle case.

Now, we can get the order of k numbers that meet the row conditions. With the same logic, we also need to get the order of k numbers that meet the column conditions. After that, we can just place the number i in the position of row order[i] and column order[i].

Here’s the code.

• Time complexity is O(K+E), where E is the number of edges in the graph. But it excludes the initialization of the matrix for the answer.

• Space complexity is O(K+E), where E is the number of edges in the graph.

 class Solution:
    def buildMatrix(self, k: int, rowConditions: List[List[int]], colConditions: List[List[int]]) -> List[List[int]]:
        def topsort(g, node, colors, ret):
            if colors[node] == 1:
                return False
            if colors[node] == 2:
                return True
            colors[node] = 1
            for ne in g[node]:
                if not topsort(g, ne, colors, ret):
                    return False
            colors[node] = 2
            ret.append(node)
            return True
            
        def make_graph(arr, k):
            g = defaultdict(list)
            s = set(list(range(1,k+1)))
            for p, q in arr:
                g[p].append(q)
            ret = []
            colors = [0 for _ in range(k+1)]
            for e in s:
                if not topsort(g, e, colors, ret):
                    return None
            ret.reverse()
            return { v: i for i, v in enumerate(ret) }
        row = make_graph(rowConditions, k)
        col = make_graph(colConditions, k)
        
        if not row or not col:
            return []
            
        ans = [[0 for _ in range(k) ] for _ in range(k)]
        for i in range(1, k+1):
            ans[row[i]][col[i]] = i

        return ans
        

2. Find a Valid Matrix Given Row and Column Sums

Link: https://leetcode.com/problems/find-valid-matrix-given-row-and-column-sums/description

The problem states that we should fill the matrix that meets the row and column conditions. Row and column conditions contain the sum of each row and column.

Here’s an example. Let’s say the sum of the first column is 5, and the sum of the second row is 8. Then, you can fill in the number like this to meet those two conditions.

If you think about this problem for a while, you will easily find that you can fill the number greedily. It’s because the overall sum is always the same and there is no other constraints to distribute the number except for the sum.

This means we can iterate the rows and distribute the number row[i] greedily to columns. For example, if row[0] is 10, we can fill the column[0] to 10 if possible. If column[0] is smaller than 10, we can fill the rest of the number to column[1].

Here’s the simple code.

• Time complexity is O(N*M), where N is the number of rows, and M is the number of columns.

• Space complexity is O(N*M) because of the list for the answer.

class Solution:
    def restoreMatrix(self, rowSum: List[int], colSum: List[int]) -> List[List[int]]:
        n = len(rowSum)
        m = len(colSum)
        ans = [[0 for _ in range(m)] for _ in range(n)]

        curr_idx = 0
        for i in range(n):
            value = rowSum[i]
            while curr_idx < m and value > 0:
                can = min(colSum[curr_idx], value)
                colSum[curr_idx] -= can
                value -= can
                ans[i][curr_idx] = can
                if colSum[curr_idx] == 0:
                    curr_idx += 1
        return ans

Amazon RDS Performance Insights는 데이터베이스 성능을 모니터링하고 최적화하는 데 도움을 주는 강력한 도구이다. 이 서비스는 복잡한 성능 문제를 시각적으로 쉽게 이해할 수 있도록 데이터를 시각화하고, 데이터베이스 인스턴스의 활동을 실시간으로 분석하여 병목 현상을 식별하고 해결할 수 있도록 돕는다.

Performance Insights는 RDS 인스턴스의 성능 데이터를 수집하여 CPU 사용량, 메모리 사용량, 디스크 I/O, 쿼리 성능 등을 모니터링한다. 이러한 데이터를 통해 데이터베이스 인스턴스의 성능 상태를 실시간으로 파악할 수 있으며, 성능 문제의 원인을 빠르게 식별할 수 있다.

Performance Insights의 주요 기능 중 하나는 데이터베이스 부하 분석이다. 이 도구는 데이터베이스 인스턴스의 활동을 다양한 관점에서 분석할 수 있도록 지원하며, SQL 쿼리, 대기 이벤트, 데이터베이스 내부 활동 등을 시각적으로 보여준다. 이를 통해 사용자는 데이터베이스 성능에 영향을 미치는 주요 요소를 쉽게 식별하고, 성능 최적화를 위한 구체적인 조치를 취할 수 있다.

Performance Insights를 사용하기 위해서는 AWS Management Console, AWS CLI, 또는 AWS SDK를 통해 RDS 인스턴스에서 이 기능을 활성화해야 한다. 활성화된 후에는 Performance Insights 대시보드에서 성능 데이터를 실시간으로 확인할 수 있으며, 지난 시간 동안의 성능 변화를 시각적으로 분석할 수 있다. 대시보드에서는 주요 성능 지표와 함께, SQL 쿼리의 실행 시간, 대기 이벤트의 빈도, 리소스 사용량 등을 상세히 볼 수 있다.

성능 문제를 진단할 때는 다음과 같은 주요 지표와 메트릭을 활용할 수 있다:

1. DB Load: 데이터베이스 부하는 인스턴스의 전체 성능 상태를 나타내는 지표로, CPU 사용량, 대기 시간, 스토리지 I/O 등을 포함한다. DB Load 그래프를 통해 데이터베이스 부하의 변화 추이를 시각적으로 확인할 수 있다.

2. Top SQL Queries: 가장 많은 리소스를 소비하는 SQL 쿼리를 식별할 수 있다. 이 기능은 실행 시간이 긴 쿼리, 자주 실행되는 쿼리, 대기 시간이 긴 쿼리 등을 보여주어 쿼리 최적화의 우선순위를 정하는 데 도움을 준다.

3. Wait Events: 데이터베이스가 작업을 처리하는 동안 발생하는 대기 이벤트를 모니터링하여 병목 현상을 식별할 수 있다. 대기 이벤트 분석을 통해 특정 리소스(예: CPU, I/O, 락)에서의 병목을 파악하고, 이에 대한 최적화 조치를 취할 수 있다.

4. Resource Utilization: CPU, 메모리, 디스크 I/O 등의 리소스 사용량을 모니터링할 수 있다. 리소스 사용량 그래프를 통해 인스턴스의 현재 상태와 과거 상태를 비교하여 성능 문제의 원인을 분석할 수 있다.

Performance Insights는 데이터베이스 성능 최적화뿐만 아니라, 비용 절감에도 도움을 준다. 예를 들어, CPU 사용률이 낮은 경우에는 인스턴스 크기를 줄여 비용을 절감할 수 있으며, 반대로 CPU 사용률이 높을 경우에는 인스턴스 크기를 증가시켜 성능을 향상시킬 수 있다. 또한, 리소스 사용량을 모니터링하여 불필요한 리소스 사용을 줄이고, 효율적인 데이터베이스 운영을 가능하게 한다.

Performance Insights는 Amazon Aurora, MySQL, MariaDB, PostgreSQL, Oracle, SQL Server 등의 다양한 데이터베이스 엔진을 지원한다. 이를 통해 여러 종류의 RDS 인스턴스에서 성능 모니터링과 최적화를 일관되게 수행할 수 있다. 또한, Performance Insights는 7일간의 기본 데이터를 무료로 제공하며, 추가 요금으로 최대 24개월까지 데이터를 보관할 수 있다. 이를 통해 장기적인 성능 추이를 분석하고, 데이터베이스 성능을 지속적으로 최적화할 수 있다.

Amazon Aurora의 파라미터 그룹은 데이터베이스 인스턴스의 동작 방식을 제어하는 설정 집합이다. 이 설정을 통해 데이터베이스 성능, 보안, 로그 및 기타 다양한 기능을 세밀하게 조정할 수 있다. Aurora는 기본 파라미터 그룹을 제공하며, 사용자는 이를 복사하여 사용자 정의 파라미터 그룹을 생성하고 필요에 맞게 설정을 변경할 수 있다.

파라미터 그룹을 설정하는 첫 번째 단계는 파라미터 그룹을 생성하는 것이다. AWS Management Console, AWS CLI, 또는 AWS SDK를 통해 파라미터 그룹을 생성할 수 있다. 파라미터 그룹을 생성할 때는 데이터베이스 엔진 유형과 버전을 지정해야 하며, 이는 해당 엔진과 버전에 맞는 설정이 적용되도록 하기 위함이다. 예를 들어, Aurora MySQL과 Aurora PostgreSQL은 각각 다른 파라미터 그룹을 사용하며, 엔진 버전에 따라 사용할 수 있는 파라미터가 다를 수 있다.

파라미터 그룹이 생성되면, 사용자는 해당 그룹의 파라미터 값을 수정할 수 있다. AWS Management Console에서 파라미터 그룹을 선택하고, 각 파라미터의 현재 값을 확인한 후 필요한 값을 변경할 수 있다.

주요 파라미터

• innodb_buffer_pool_size
  innodb_buffer_pool_size는 InnoDB 스토리지 엔진의 버퍼 풀 크기를 설정하는 파라미터로, 데이터와 인덱스를 메모리에 캐싱하여 디스크 I/O를 줄이고 성능을 향상시킨다. 메모리 용량이 큰 서버에서는 이 값을 크게 설정하여 더 많은 데이터를 메모리에 유지함으로써 데이터베이스 성능을 극대화할 수 있다.

• max_connections
  max_connections는 데이터베이스에 동시에 연결할 수 있는 최대 연결 수를 설정하는 파라미터로, 애플리케이션의 요구에 따라 이 값을 조정할 수 있다. 웹 애플리케이션과 같이 많은 사용자가 동시에 접속하는 환경에서는 이 값을 높여 더 많은 연결을 허용하도록 설정해야 한다.

• query_cache_size
  query_cache_size는 MySQL에서 쿼리 캐시의 크기를 설정하는 파라미터로, 자주 실행되는 SELECT 쿼리의 결과를 캐싱하여 쿼리 성능을 향상시킨다. 그러나 Aurora MySQL 5.7 이상 버전에서는 쿼리 캐시가 제거되었으므로, 그 이하 버전을 사용하는 경우에만 이 파라미터를 조정할 수 있다.

• innodb_log_file_size
  innodb_log_file_size는 InnoDB 로그 파일의 크기를 설정하는 파라미터로, 로그 파일이 크면 크래시 복구 시 시간이 단축되고, 트랜잭션 처리 성능이 향상된다. 그러나 너무 크게 설정하면 디스크 사용량이 증가할 수 있으므로 적절한 크기로 조정해야 한다.

• innodb_flush_log_at_trx_commit
  innodb_flush_log_at_trx_commit은 트랜잭션이 커밋될 때 로그를 디스크에 기록하는 방식을 제어하는 파라미터로, 값에 따라 데이터 안정성과 성능 간의 균형을 맞출 수 있다. 기본값인 1은 각 트랜잭션마다 로그를 디스크에 기록하여 높은 데이터 안정성을 보장하지만, 성능이 저하될 수 있다. 값이 2 또는 0으로 설정하면 성능이 향상되지만, 데이터 손실 위험이 커진다.

• innodb_io_capacity
  innodb_io_capacity는 InnoDB의 백그라운드 작업(예: 버퍼 풀의 페이지 플러시, 로그 파일 기록 등)을 위한 I/O 용량을 설정하는 파라미터로, 디스크 I/O 성능에 맞춰 적절히 설정해야 한다. SSD와 같은 고성능 디스크를 사용하는 경우 이 값을 높여 백그라운드 작업을 더 빠르게 수행할 수 있다.

• innodb_thread_concurrency
  innodb_thread_concurrency는 InnoDB에서 동시에 실행할 수 있는 스레드 수를 제한하는 파라미터로, 스레드 경합을 줄이고 성능을 향상시킬 수 있다. 일반적으로 CPU 코어 수에 맞춰 이 값을 조정하면 성능을 최적화할 수 있다.

• autocommit
  autocommit은 각 SQL 문이 자동으로 커밋될지 여부를 결정하는 파라미터로, 애플리케이션의 트랜잭션 관리 전략에 따라 이 값을 설정할 수 있다. 자동 커밋을 비활성화하면 트랜잭션 단위로 커밋할 수 있어 데이터 일관성을 유지할 수 있다.

• log_bin_trust_function_creators
  log_bin_trust_function_creators는 사용자 정의 함수(UDF)와 저장 프로시저를 생성할 때 필요로 하는 특권을 설정하는 파라미터로, 트리거 및 이벤트를 사용하는 애플리케이션에서 유용하다. 이 값을 1로 설정하면 UDF 및 저장 프로시저를 더 쉽게 생성할 수 있다.

• slow_query_log
  slow_query_log는 느린 쿼리를 로그에 기록하는 기능을 활성화하는 파라미터로, 성능 문제를 진단하고 최적화할 때 유용하다. 느린 쿼리 로그를 통해 성능이 저하되는 쿼리를 식별하고, 인덱스 최적화나 쿼리 구조 개선 등의 조치를 취할 수 있다.

Cluster Parameter Group vs Instance Parameter Group

클러스터 파라미터 그룹은 Aurora 데이터베이스 클러스터 전체에 적용되는 설정을 포함하고 있다. 하나의 클러스터에는 다수의 데이터베이스 인스턴스가 있을 수 있으며, 클러스터 파라미터 그룹은 이 모든 인스턴스에 공통적으로 적용되는 파라미터를 정의한다. 예를 들어, 클러스터 파라미터 그룹을 통해 클러스터 전체의 로그 파일 크기나 복제 설정을 관리할 수 있다. 이러한 설정은 클러스터 내 모든 인스턴스에 동일하게 적용되기 때문에, 클러스터 파라미터 그룹을 올바르게 설정하는 것은 매우 중요하다.

인스턴스 파라미터 그룹은 개별 DB 인스턴스에 적용되는 설정을 정의한다. 각 인스턴스는 독립적으로 구성될 수 있으며, 특정 인스턴스에 대해 별도의 설정을 적용하고자 할 때 인스턴스 파라미터 그룹을 사용한다. 예를 들어, 특정 인스턴스의 메모리 할당량이나 캐시 크기를 조정하고자 할 때 인스턴스 파라미터 그룹을 사용하면 된다. 이는 클러스터 내의 인스턴스가 서로 다른 작업 부하를 처리하거나, 다른 성능 요구 사항을 가질 때 유용하다.

이 두 가지 파라미터 그룹의 차이를 이해하는 것은 매우 중요하다. 클러스터 파라미터 그룹은 클러스터 전체의 일관성을 유지하고, 공통적인 설정을 쉽게 관리할 수 있도록 도와준다. 클러스터 파라미터 그룹을 변경하면 클러스터 내 모든 인스턴스에 즉시 영향을 미치기 때문에, 이러한 변경 사항은 신중하게 관리되어야 한다. 반면에, 인스턴스 파라미터 그룹은 개별 인스턴스의 특수한 요구 사항을 충족시키기 위해 사용된다. 이는 특히 대규모 클러스터에서 특정 인스턴스에 대해 최적화된 설정을 적용할 때 매우 유용하다.

Amazon Aurora는 AWS에서 제공하는 고성능 관계형 데이터베이스 서비스로, MySQL과 PostgreSQL을 기반으로 설계되었다. Aurora는 기존의 MySQL 및 PostgreSQL 데이터베이스와 호환되면서도, 성능과 가용성 면에서 획기적인 향상을 제공한다. Amazon Aurora는 클라우드 네이티브 설계로, 고가용성, 확장성, 데이터 보안, 자동 백업 등 다양한 기능을 포함하고 있어 데이터베이스 운영의 복잡성을 크게 줄여준다.

Amazon Aurora의 주요 장점 중 하나는 뛰어난 성능이다. Aurora는 표준 MySQL보다 최대 5배, 표준 PostgreSQL보다 최대 3배 더 빠른 성능을 제공한다. 이러한 성능 향상은 Aurora의 독자적인 아키텍처 덕분이다. Aurora는 스토리지와 컴퓨팅을 분리하여 각 노드가 독립적으로 확장될 수 있도록 설계되었다. 이는 데이터베이스의 읽기 및 쓰기 작업을 분산시켜 성능 병목을 최소화하고, 고성능을 유지할 수 있게 한다.

Aurora는 고가용성을 보장하기 위해 여러 가용 영역(AZ)에 걸쳐 데이터를 자동으로 복제한다. 기본적으로 6개의 복제본이 3개의 AZ에 걸쳐 저장되며, 이는 데이터 손실을 방지하고 장애 발생 시에도 데이터의 무결성을 유지할 수 있게 한다. Aurora는 장애 복구 시간을 몇 초 이내로 줄이는 자동 장애 조치(failover) 기능을 제공하여, 데이터베이스 가용성을 극대화한다. 이는 비즈니스 연속성을 유지하는 데 매우 중요한 역할을 한다.

또한, Aurora는 자동 백업과 특정 시점 복구(Point-In-Time Recovery, PITR)를 지원한다. 자동 백업은 Aurora 스토리지 계층에서 지속적으로 수행되며, 사용자는 데이터베이스를 특정 시점으로 복구할 수 있다. 이러한 기능은 데이터 손실에 대한 걱정을 덜어주고, 데이터베이스의 안정성을 높여준다. 백업은 Amazon S3에 안전하게 저장되며, S3의 높은 내구성과 가용성을 바탕으로 데이터가 안전하게 보호된다.

Aurora는 또한 읽기 성능을 향상시키기 위해 읽기 복제본(Read Replica)을 지원한다. 최대 15개의 읽기 복제본을 생성할 수 있으며, 이는 읽기 요청을 분산시켜 데이터베이스의 읽기 성능을 극대화할 수 있다. 읽기 복제본은 주 데이터베이스와의 지연 시간이 매우 짧아, 실시간에 가까운 데이터 접근이 가능하다. 이는 대규모 애플리케이션에서 읽기 작업이 집중될 때 매우 유용하다.

자동 백업은 사용자가 지정한 보관 기간 동안 매일 데이터베이스 인스턴스를 백업하여 데이터 손실에 대비할 수 있게 해준다. 이 기능은 데이터베이스 관리자가 수동으로 백업을 수행해야 하는 부담을 덜어주고, 데이터 복구 시점(RPO, Recovery Point Objective)을 최소화하는 데 도움을 준다.

RDS 자동 백업 기능은 백업 보관 기간을 설정함으로써 활성화된다. 기본적으로 RDS는 1일에서 최대 35일까지의 보관 기간을 설정할 수 있으며, 이 기간 동안 자동으로 백업이 수행된다. 백업은 데이터베이스 인스턴스의 자동화된 스냅샷 형태로 저장되며, 이러한 스냅샷은 사용자가 필요할 때 언제든지 복구할 수 있다. 자동 백업 스냅샷은 Amazon S3에 저장되며, S3의 높은 내구성과 가용성을 바탕으로 안전하게 보관된다.

RDS 자동 백업은 데이터베이스 인스턴스의 성능에 영향을 최소화하도록 설계되었다. 백업 작업은 백그라운드에서 수행되며, 데이터베이스의 읽기 및 쓰기 작업에 미치는 영향을 최소화하기 위해 최적화되어 있다. 이로 인해 데이터베이스가 운영 중일 때도 백업 작업이 원활하게 진행될 수 있다.

또한, RDS는 특정 시점 복구(Point-In-Time Recovery, PITR)를 지원한다. 이 기능은 사용자가 특정 시점으로 데이터베이스를 복구할 수 있도록 해준다. 예를 들어, 데이터베이스에 실수로 잘못된 데이터를 입력했거나, 중요 데이터를 삭제한 경우, PITR 기능을 통해 문제 발생 이전의 시점으로 데이터베이스를 복원할 수 있다. 이는 데이터 손실을 최소화하고, 비즈니스 연속성을 유지하는 데 매우 유용하다.

자동 백업 외에도 RDS는 수동 스냅샷 기능을 제공한다. 사용자는 필요에 따라 데이터베이스의 스냅샷을 수동으로 생성하여 저장할 수 있다. 이러한 수동 스냅샷은 자동 백업 스냅샷과 마찬가지로 Amazon S3에 저장되며, 사용자가 원하는 시점에 복구할 수 있다. 수동 스냅샷은 특정 이벤트나 업데이트 전에 데이터베이스 상태를 저장하는 데 유용하며, 이는 데이터베이스 변경으로 인한 위험을 관리하는 데 도움을 준다.

RDS의 백업 복구 과정은 매우 간단하고 직관적이다. 사용자는 AWS Management Console, AWS CLI, 또는 RDS API를 통해 복구 작업을 수행할 수 있다. 복구 작업은 새로운 데이터베이스 인스턴스로 수행되며, 기존 인스턴스를 그대로 유지하면서 복구된 인스턴스를 테스트할 수 있다. 이는 복구 작업 중에 기존 데이터베이스 운영에 영향을 주지 않도록 하며, 복구된 데이터베이스의 유효성을 검증할 수 있는 유연성을 제공한다.

RDS는 또한 데이터베이스 암호화를 지원하여 백업 데이터의 보안을 강화한다. RDS 암호화는 저장된 데이터와 자동 백업, 스냅샷, 복제본 등을 모두 암호화하며, AWS Key Management Service(KMS)를 통해 관리된다. 이를 통해 데이터의 기밀성을 유지하고, 규제 준수 요구사항을 충족할 수 있다.

AWS RDS는 Amazon Web Services의 관계형 데이터베이스 서비스로, 사용자가 클라우드 환경에서 관계형 데이터베이스를 쉽게 설정하고 운영할 수 있게 해준다. RDS는 MySQL, PostgreSQL, MariaDB, Oracle, Microsoft SQL Server 등의 다양한 데이터베이스 엔진을 지원하며, 사용자는 각 엔진의 특징과 요구사항에 맞춰 선택할 수 있다. RDS는 관리형 서비스로, 데이터베이스 패치, 백업, 복구, 확장 등을 자동으로 처리해주어 사용자의 관리 부담을 크게 줄여준다.

RDS의 주요 기능

RDS의 주요 기능 중 하나는 자동 백업 기능이다. 사용자는 백업 보관 기간을 설정할 수 있으며, RDS는 설정된 기간 동안 자동으로 데이터베이스를 백업하고 보관한다. 이러한 자동 백업은 사용자가 직접 백업을 수행하는 것보다 더욱 편리하고 안전하다. 또한, 데이터베이스 인스턴스가 장애를 일으킬 경우, RDS는 자동으로 다른 가용 영역으로 장애 조치를 수행하여 고가용성을 보장한다. 이는 사용자가 데이터베이스 운영 중단 없이 안정적으로 서비스를 제공할 수 있게 해준다.

또한, RDS는 스토리지의 확장성을 제공한다. 초기 설정 시에 할당한 스토리지 용량이 부족할 경우, 사용자는 간단한 설정 변경만으로 스토리지를 확장할 수 있다. 이는 데이터베이스의 성장에 따라 유연하게 대응할 수 있도록 해준다.

RDS는 또한 읽기 성능을 향상시키기 위해 읽기 복제본(Read Replica)을 지원한다. 읽기 복제본을 사용하면, 데이터베이스의 읽기 요청을 복제본으로 분산시켜 주 데이터베이스의 부하를 줄일 수 있다. 이는 데이터베이스의 성능 향상과 안정성에 크게 기여한다.

RDS는 보안 측면에서도 강력한 기능을 제공한다. 사용자는 VPC(가상 사설 클라우드)를 통해 데이터베이스를 격리된 네트워크 환경에서 운영할 수 있으며, IAM(Identity and Access Management)을 통해 사용자 권한을 세밀하게 관리할 수 있다. 또한, RDS는 데이터베이스의 암호화 기능을 제공하여 저장된 데이터를 보호할 수 있다. 이 암호화 기능은 데이터베이스 인스턴스의 스냅샷과 백업에도 적용되어 데이터 보안성을 더욱 높인다.

RDS는 모니터링 기능도 제공한다. Amazon CloudWatch와 통합되어 데이터베이스의 성능 지표를 실시간으로 모니터링할 수 있다. 사용자는 CPU 사용률, 메모리 사용률, 디스크 I/O 등의 지표를 통해 데이터베이스의 상태를 파악하고, 필요에 따라 조치를 취할 수 있다. 또한, RDS는 경고 기능을 통해 특정 지표가 임계값을 초과할 경우 알림을 받을 수 있도록 설정할 수 있다. 이는 데이터베이스의 문제를 사전에 감지하고 대응할 수 있게 해준다.

RDS 비용 및 사용 사례

RDS의 비용 구조는 사용자가 선택한 데이터베이스 엔진, 인스턴스 유형, 스토리지 용량 등에 따라 다르다. 사용자는 필요에 따라 다양한 인스턴스 유형을 선택할 수 있으며, 비용 절감을 위해 예약 인스턴스를 사용할 수도 있다. 또한, RDS는 사용량 기반 과금 방식을 채택하여 사용자가 실제로 사용한 리소스에 대해서만 비용을 지불하도록 한다. 이는 불필요한 비용을 절감하고 효율적으로 예산을 관리할 수 있게 해준다.

RDS의 사용 사례는 매우 다양하다. 웹 애플리케이션의 백엔드 데이터베이스로서, 빅데이터 분석을 위한 데이터 웨어하우스로서, 그리고 다양한 비즈니스 애플리케이션의 데이터 저장소로서 RDS를 활용할 수 있다. 특히, 확장성과 고가용성을 요구하는 애플리케이션에서 RDS의 장점이 더욱 두드러진다. 이는 RDS가 단순히 데이터베이스를 호스팅하는 것을 넘어, 데이터베이스의 운영과 관리에 필요한 다양한 기능을 제공하기 때문이다.

결론적으로, AWS RDS는 클라우드 환경에서 관계형 데이터베이스를 효율적으로 운영할 수 있도록 돕는 강력한 도구이다. 자동화된 관리 기능, 높은 가용성, 확장성, 보안 기능 등을 통해 사용자는 데이터베이스 관리의 복잡성을 줄이고, 비즈니스에 집중할 수 있다. RDS는 다양한 데이터베이스 엔진을 지원하여 사용자의 요구사항에 맞게 선택할 수 있으며, 비용 효율적인 운영을 가능하게 한다. 이러한 점에서 RDS는 클라우드 기반 데이터베이스 솔루션으로서 매우 유용하다.

데이터베이스 샤딩은 대규모 데이터베이스 시스템에서 데이터의 성능과 확장성을 향상시키기 위한 중요한 기술이다. 이 개념은 데이터를 작은 단위로 분할하여 여러 데이터베이스 서버에 분산 저장하는 것을 의미한다. 샤딩을 통해 데이터베이스 시스템은 수평적으로 확장 가능해지며, 이는 한 서버의 자원이 부족해질 때 추가 서버를 추가하여 처리 용량을 늘릴 수 있음을 의미한다.

샤딩 방식

샤딩은 크게 두 가지 방식으로 나눌 수 있다.

첫 번째는 수평 샤딩이다. 수평 샤딩에서는 각 테이블의 로우를 여러 서버에 나누어 저장한다. 예를 들어, 사용자 테이블이 있다고 가정하면, 사용자 ID를 기준으로 특정 범위의 사용자 데이터를 각기 다른 서버에 분산 저장할 수 있다. 이렇게 하면 특정 서버에 대한 부담이 줄어들고, 각 서버는 자신에게 할당된 데이터만 처리하면 되므로 전체 시스템의 성능이 향상된다.

두 번째 방식은 수직 샤딩이다. 수직 샤딩에서는 테이블을 컬럼 단위로 나누어 저장한다. 예를 들어, 사용자 테이블의 경우, 사용자의 기본 정보(이름, 이메일 등)는 한 서버에 저장하고, 사용자의 활동 기록(로그인 기록, 주문 내역 등)은 다른 서버에 저장할 수 있다. 이렇게 하면 특정 쿼리나 작업이 특정 서버에 집중되지 않고 분산되어 처리할 수 있게 되어 성능이 향상된다.

샤딩을 구현할 때는 샤딩 키의 선택이 매우 중요하다. 샤딩 키는 데이터를 분할하는 기준이 되는 값으로, 잘못된 샤딩 키를 선택하면 데이터가 고르게 분산되지 않고 특정 서버에 데이터가 집중될 수 있다. 이는 특정 서버의 부하를 증가시키고 전체 시스템의 성능 저하를 초래할 수 있다. 따라서 샤딩 키는 데이터의 고른 분포를 보장할 수 있도록 신중하게 선택해야 한다.

샤딩의 장점

샤딩의 장점은 무엇보다도 시스템의 확장성과 성능을 향상시킬 수 있다는 점이다. 단일 데이터베이스 서버의 처리 용량이 한계에 도달하면, 추가 서버를 통해 용량을 확장할 수 있다. 또한, 여러 서버에 데이터를 분산 저장함으로써 쿼리 처리 속도가 빨라지고, 데이터 읽기 및 쓰기 작업이 병렬로 수행될 수 있다.

하지만 샤딩에는 몇 가지 단점도 존재한다. 첫째, 시스템의 복잡도가 증가한다. 여러 서버에 데이터를 분산 저장하기 때문에 데이터 일관성을 유지하는 것이 어려워진다. 예를 들어, 여러 서버에 걸친 트랜잭션을 관리하는 것은 매우 복잡할 수 있으며, 이는 개발 및 유지 보수 비용을 증가시킨다. 둘째, 샤딩 키의 변경이 어렵다. 한번 샤딩 키를 선택하고 데이터를 분산 저장하면, 샤딩 키를 변경하기 위해서는 전체 데이터를 다시 분산 저장해야 하는 번거로움이 있다.

샤딩의 또 다른 고려 사항은 데이터 이동이다. 서버 간의 데이터 이동은 네트워크 비용을 발생시키고, 데이터 이동 중에는 서비스 가용성이 떨어질 수 있다. 따라서 샤딩을 계획할 때는 이러한 네트워크 비용과 가용성 문제를 충분히 고려해야 한다.

종합적으로, 데이터베이스 샤딩은 대규모 데이터베이스 시스템의 성능과 확장성을 높이는 데 매우 유용한 기술이다. 샤딩을 통해 데이터 처리 능력을 향상시키고, 시스템의 용량을 유연하게 확장할 수 있다.

그러나 샤딩을 구현할 때는 샤딩 키의 선택, 데이터 일관성 유지, 데이터 이동 등의 여러 가지 고려 사항을 신중하게 판단해야 한다. 이러한 점을 충분히 고려하여 샤딩을 올바르게 구현하면, 대규모 데이터베이스 시스템에서 효율적이고 안정적인 데이터 처리가 가능해진다.