[ys-han00] WEEK 14 solutions

binary-tree-level-order-traversal/ys-han00.cpp

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    vector<vector<int>> ans;
+    void rec(TreeNode* curr, int level) {
+        if(ans.size() < level)
+            ans.push_back(vector<int>());
+        ans[level - 1].push_back(curr->val);
+        if(curr->left)
+            rec(curr->left, level + 1);
+        if(curr->right)
+            rec(curr->right, level + 1);
+    }
+    vector<vector<int>> levelOrder(TreeNode* root) {
+        if(root)
+            rec(root, 1);
+        return ans;
+    }
+};
+

counting-bits/ys-han00.cpp

@@ -0,0 +1,40 @@
+class Solution {
+public:
+    vector<int> countBits(int n) {
+        vector<int> dp(n + 1, 0);
+        for(int i = 1; i <= n; i++)
+            dp[i] = dp[(i >> 1)] + (i & 1);
+
+        return dp;
+    }
+
+    // vector<int> countBits(int n) {
+    //     vector<int> dp(n + 1, 0);
+    //     int msb = 1;
+
+    //     for(int i = 1; i <= n; i++) {
+    //         if(msb << 1 == i)
+    //             msb <<= 1;
+    //         dp[i] = 1 + dp[i - msb];
+    //     }
+    //     return dp;   
+    // }
+
+    // vector<int> countBits(int n) {
+    //     vector<int> dp(n + 1, 0);
+    //     dp[0] = 0;
+    //     if(n >= 1)
+    //         dp[1] = 1;
+    //     for(int i = 2; i <= n; i *= 2) {
+    //         for(int j = 0; j < i; j++) {
+    //             if(i + j > n)
+    //                 break;
+    //             dp[i + j] = dp[i / 2 + j];
+    //             if(j >= i / 2) dp[i + j]++;
+    //         }
+    //     }
+
+    //     return dp;
+    // }
+};
+

find-median-from-data-stream/ys-han00.cpp

@@ -0,0 +1,39 @@
+class MedianFinder {
+public:
+    priority_queue<int> lower;
+    priority_queue<int, vector<int>, greater<int>> upper;
+
+    MedianFinder() {    
+    }
+
+    void addNum(int num) {
+        if(upper.empty() || upper.top() < num)
+            upper.push(num);
+        else
+            lower.push(num);
+
+        if(lower.size() > upper.size()) {
+            upper.push(lower.top());
+            lower.pop();
+        }
+        else if(lower.size() + 1 < upper.size()) {
+            lower.push(upper.top());
+            upper.pop();
+        }
+    }
+
+    double findMedian() {
+        if(lower.size() < upper.size())
+            return upper.top();
+        else
+            return (lower.top() + upper.top()) / 2.;
+    }
+};
+
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * MedianFinder* obj = new MedianFinder();
+ * obj->addNum(num);
+ * double param_2 = obj->findMedian();
+ */
+

house-robber-ii/ys-han00.cpp

@@ -0,0 +1,31 @@
+class Solution {
+public:
+    int rob(vector<int>& nums) {
+        vector<vector<int>> dp(2, vector<int>(nums.size(), 0));
+
+        dp[0][0] = nums[0];
+        if(nums.size() == 1) 
+            return dp[0][0];
+
+        dp[0][1] = nums[1];
+        dp[1][1] = nums[1];
+
+        int ans = max(dp[0][0], dp[0][1]);
+        for(int i = 2; i < nums.size(); i++) {
+            int maxi = -1, maxi2 = -1;
+            for(int j = 0; j < i - 1; j++) {
+                maxi = max(dp[0][j], maxi);
+                maxi2 = max(dp[1][j], maxi2);
+            }
+
+            dp[0][i] = maxi + nums[i];
+            dp[1][i] = maxi2 + nums[i];
+
+            if(i != nums.size() - 1)
+                ans = max(ans, dp[0][i]);
+            ans = max(ans, dp[1][i]);
+        }
+        return ans;
+    }
+};
+

insert-interval/ys-han00.cpp

@@ -0,0 +1,58 @@
+class Solution {
+public:
+    vector<vector<int>> insert(vector<vector<int>>& intervals, vector<int>& newInterval) {
+        vector<vector<int>> ans;
+        int n = intervals.size();
+        int i = 0;
+
+        while (i < n && intervals[i][1] < newInterval[0]) {
+            ans.push_back(intervals[i]);
+            i++;
+        }
+
+        while (i < n && intervals[i][0] <= newInterval[1]) {
+            newInterval[0] = min(newInterval[0], intervals[i][0]);
+            newInterval[1] = max(newInterval[1], intervals[i][1]);
+            i++;
+        }
+        ans.push_back(newInterval);
+
+        while (i < n) {
+            ans.push_back(intervals[i]);
+            i++;
+        }
+
+        return ans;
+    }
+
+    // vector<vector<int>> insert(vector<vector<int>>& intervals, vector<int>& newInterval) {
+    //     vector<vector<int>> ans;
+    //     bool tmp = false;
+    //     int left = newInterval[0], right = newInterval[1];
+
+    //         for(int i = 0; i < intervals.size(); i++) {
+    //         if(intervals[i][1] < left) {
+    //             ans.push_back(intervals[i]);
+    //             continue;
+    //         }
+    //         else if(right < intervals[i][0]) {
+    //             if(!tmp) {
+    //                 ans.push_back(vector<int>({left, right}));
+    //                 tmp = true;
+    //             }
+    //             ans.push_back(intervals[i]);
+    //             continue;
+    //         }
+    //         else {
+    //             left = min(left, intervals[i][0]);
+    //             right = max(right, intervals[i][1]);
+    //         }
+    //     }
+
+    //     if(!tmp)
+    //         ans.push_back(vector<int>({left, right}));
+
+    //     return ans;   
+    // }
+};
+

word-search-ii/ys-han00.cpp

@@ -0,0 +1,71 @@
+struct TrieNode {
+    TrieNode* children[26];
+    string* word; 
+
+    TrieNode() {
+        for (int i = 0; i < 26; i++) children[i] = nullptr;
+        word = nullptr;
+    }
+};
+
+class Solution {
+    int rows, cols;
+    vector<string> output;
+
+    void insert(TrieNode* root, const string& word) {
+        TrieNode* curr = root;
+        for (char ch : word) {
+            int idx = ch - 'a';
+            if (!curr->children[idx]) curr->children[idx] = new TrieNode();
+            curr = curr->children[idx];
+        }
+        curr->word = const_cast<string*>(&word); 
+    }
+
+    void dfs(vector<vector<char>>& board, int r, int c, TrieNode* node) {
+        char ch = board[r][c];
+        int idx = ch - 'a';
+
+        if (idx < 0 || !node->children[idx]) return;
+
+        TrieNode* nextNode = node->children[idx];
+
+        if (nextNode->word != nullptr) {
+            output.push_back(*(nextNode->word));
+            nextNode->word = nullptr; 
+        }
+
+        board[r][c] = '#'; 
+
+        int dr[] = {-1, 1, 0, 0};
+        int dc[] = {0, 0, -1, 1};
+
+        for (int i = 0; i < 4; i++) {
+            int nr = r + dr[i];
+            int nc = c + dc[i];
+            if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && board[nr][nc] != '#') {
+                dfs(board, nr, nc, nextNode);
+            }
+        }
+
+        board[r][c] = ch;
+    }
+
+public:
+    vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
+        TrieNode* root = new TrieNode();
+        for (const string& w : words) insert(root, w);
+
+        rows = board.size();
+        cols = board[0].size();
+
+        for (int r = 0; r < rows; r++) {
+            for (int c = 0; c < cols; c++) {
+                dfs(board, r, c, root);
+            }
+        }
+
+        return output;
+    }
+};
+