Add jzo 60-66

Author: csJd

nowcoder/jzo.60.HierarchicalTraversal.cpp

@@ -0,0 +1,51 @@
+/*
+https://www.nowcoder.com/practice/445c44d982d04483b04a54f298796288
+
+题目描述
+从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
+*/
+
+#include <queue>
+#include <tuple>
+#include <vector>
+using namespace std;
+
+// struct TreeNode {
+//     int val;
+//     struct TreeNode *left;
+//     struct TreeNode *right;
+//     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+// };
+
+class Solution {
+  public:
+    vector<vector<int>> Print(TreeNode *pRoot) {
+        vector<vector<int>> res;
+        if (!pRoot) {
+            return res;
+        }
+        TreeNode *p;
+        vector<int> row;
+        queue<tuple<TreeNode *, int>> q;
+        q.push(make_tuple(pRoot, 0));
+        int curLevel = 0, level;
+        while (!q.empty()) {
+            tie(p, level) = q.front();
+            q.pop();
+            if (level > curLevel) {
+                curLevel = level;
+                res.push_back(row);
+                row.clear();
+            }
+            row.push_back(p->val);
+            if (p->left) {
+                q.push(make_tuple(p->left, level + 1));
+            }
+            if (p->right) {
+                q.push(make_tuple(p->right, level + 1));
+            }
+        }
+        res.push_back(row);
+        return res;
+    }
+};

nowcoder/jzo.61.SerializeTree.cpp

@@ -0,0 +1,79 @@
+/*
+https://www.nowcoder.com/practice/cf7e25aa97c04cc1a68c8f040e71fb84
+
+题目描述
+请实现两个函数，分别用来序列化和反序列化二叉树
+
+二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保
+存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过某种符号表示
+空节点（#），以 ！ 表示一个结点值的结束（value!）。
+
+二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。
+*/
+
+#include <cstdio>
+#include <cstring>
+#include <stack>
+#include <string>
+
+using namespace std;
+
+// struct TreeNode {
+//     int val;
+//     struct TreeNode *left;
+//     struct TreeNode *right;
+//     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+// };
+
+class Solution {
+  public:
+    char *Serialize(TreeNode *root) {
+        string res = "";
+        stack<TreeNode *> st;
+        st.push(root);
+        // use stack to perform preorder traverse
+        while (!st.empty()) {
+            TreeNode *node = st.top();
+            st.pop();
+            if (!node) {
+                res += '#';
+                continue;
+            }
+            res += to_string(node->val) + '!';
+            st.push(node->right);
+            st.push(node->left);
+        }
+        char *cres = new char[res.length() + 1];
+        strcpy(cres, res.c_str());
+        return cres;
+    }
+
+    TreeNode *MyDeserialize(char *str, int &pos) {
+        if (str == nullptr || strlen(str + pos) == 0) {
+            return nullptr;
+        };
+        if (str[pos] == '#') {
+            pos += 1;
+            return nullptr;
+        }
+        int val = atoi(str + pos);
+        TreeNode *node = new TreeNode(val);
+        pos = strchr(str + pos, '!') - str + 1;
+        node->left = MyDeserialize(str, pos);
+        node->right = MyDeserialize(str, pos);
+        return node;
+    }
+
+    TreeNode *Deserialize(char *str) {
+        int pos = 0;
+        return MyDeserialize(str, pos);
+    }
+};
+
+// int main() {
+//     char stree[100] = "1!2!#3!###";
+//     Solution solu;
+//     TreeNode *root = solu.Deserialize(stree);
+//     puts(solu.Serialize(root));
+//     return 0;
+// }

nowcoder/jzo.62.KSmallestNode.cpp

@@ -0,0 +1,44 @@
+/*
+https://www.nowcoder.com/practice/ef068f602dde4d28aab2b210e859150a
+
+题目描述
+给定一棵二叉搜索树，请找出其中的第k小的结点。例如，（5，3，7，2，4，6，8）中，
+按结点数值大小顺序第三小结点的值为4。
+*/
+
+#include <stack>
+
+using namespace std;
+
+// struct TreeNode {
+//     int val;
+//     struct TreeNode *left;
+//     struct TreeNode *right;
+//     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+// };
+
+class Solution {
+  public:
+    TreeNode *KthNode(TreeNode *pRoot, int k) {
+        stack<TreeNode *> st;
+        TreeNode *p = pRoot;
+        // use stack to perform in-order traverse
+        while (p || !st.empty()) {
+            // only node without a left child can be poped
+            while (p) {
+                st.push(p);
+                p = p->left;
+            }
+            p = st.top();
+            st.pop();
+
+            --k;
+            if (k == 0) {
+                return p;
+            }
+            p = p->right;
+        }
+
+        return nullptr;
+    }
+};

nowcoder/jzo.63.MedianOfStream.cpp

@@ -0,0 +1,39 @@
+/*
+https://www.nowcoder.com/practice/9be0172896bd43948f8a32fb954e1be1
+
+题目描述
+如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流
+中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()
+方法获取当前读取数据的中位数。
+*/
+
+#include <queue>
+using namespace std;
+
+class Solution {
+  public:
+    priority_queue<int> left;                             // maximum at top
+    priority_queue<int, vector<int>, greater<int>> right; // minimum at top
+
+    void Insert(int num) {
+        if (left.empty() || num <= left.top()) {
+            left.push(num);
+        } else {
+            right.push(num);
+        }
+        if (left.size() > right.size() + 1) {
+            right.push(left.top());
+            left.pop();
+        } else if (left.size() < right.size()) {
+            left.push(right.top());
+            right.pop();
+        }
+    }
+
+    double GetMedian() {
+        if (left.size() > right.size()) {
+            return left.top();
+        }
+        return (left.top() + right.top()) / 2.0;
+    }
+};

nowcoder/jzo.64.MaxInWindows.cpp

@@ -0,0 +1,54 @@
+/*
+https://www.nowcoder.com/practice/1624bc35a45c42c0bc17d17fa0cba788
+
+题目描述
+给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，
+那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}；
+针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2, 3,4],2,6,2,5,1}，
+{2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}，
+{2,3,4,2,[6,2,5], 1}， {2,3,4,2,6,[2,5,1]}。
+
+单调队列: https://oi-wiki.org/ds/monotonous-queue
+*/
+
+#include <deque>
+#include <iostream>
+#include <vector>
+using namespace std;
+
+class Solution {
+  public:
+    vector<int> maxInWindows(const vector<int> &num, unsigned int size) {
+        vector<int> res;
+        if (size == 0) {
+            return res;
+        }
+
+        deque<int> mono_queue; // decreasing monotonous queue
+        for (unsigned i = 0; i < num.size(); ++i) {
+            // keep nums decreasing in queue
+            while (!mono_queue.empty() && num[i] >= num[mono_queue.back()]) {
+                mono_queue.pop_back();
+            }
+            mono_queue.push_back(i);
+            if (i + 1 >= size) {
+                // front num of queue is out of window
+                if (i - mono_queue.front() >= size) {
+                    mono_queue.pop_front();
+                }
+                res.push_back(num[mono_queue.front()]);
+            }
+        }
+        return res;
+    }
+};
+
+// int main() {
+//     unsigned int size = 3u;
+//     auto res = Solution().maxInWindows({2, 3, 4, 2, 6, 2, 5, 1}, size);
+//     for (int x : res) {
+//         cout << x << ' ';
+//     }
+//     cout << endl;
+//     return 0;
+// }

nowcoder/jzo.65.MatrixPath.cpp

@@ -0,0 +1,63 @@
+/*
+https://www.nowcoder.com/practice/c61c6999eecb4b8f88a98f66b273a3cc
+
+题目描述
+请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步
+可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。
+例如 [a b c e; s f c s; a d e e]
+矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字
+符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
+*/
+
+#include <deque>
+#include <iostream>
+#include <vector>
+using namespace std;
+
+int dx[] = {0, 0, -1, 1};
+int dy[] = {-1, 1, 0, 0};
+
+class Solution {
+  public:
+    bool dfs(int i, int j, int &rows, int &cols, char *matrix, char *s) {
+        if (!s[0]) {
+            return true;
+        }
+        bool flag = false;
+        char tmp = matrix[i * cols + j];
+        matrix[i * cols + j] = 0;
+        for (int d = 0; d < 4; ++d) {
+            int r = i + dx[d];
+            int c = j + dy[d];
+            if (r >= 0 && r < rows && c >= 0 && c < cols &&
+                matrix[r * cols + c] == s[0]) {
+                flag = flag || dfs(r, c, rows, cols, matrix, s + 1);
+            }
+        }
+        matrix[i * cols + j] = tmp;
+        return flag;
+    }
+
+    bool hasPath(char *matrix, int rows, int cols, char *str) {
+        if (matrix == nullptr || !rows || !cols) {
+            return false;
+        }
+        for (int i = 0; i < rows; ++i) {
+            for (int j = 0; j < cols; ++j) {
+                if (matrix[i * cols + j] == str[0]) {
+                    if (dfs(i, j, rows, cols, matrix, str + 1)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+};
+
+// int main() {
+//     char mat[] = "abcesfcsadee";
+//     char s[] = "bcced";
+//     cout << Solution().hasPath(mat, 3, 4, s);
+//     return 0;
+// }

nowcoder/jzo.66.MovingCount.cpp

@@ -0,0 +1,63 @@
+/*
+https://www.nowcoder.com/practice/6e5207314b5241fb83f2329e89fdecc8
+
+题目描述
+地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。
+例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 =
+18。但是，它不能进入方格（35,38），因为3+5+3+8 =
+19。请问该机器人能够达到多少个格子？
+*/
+
+#include <iostream>
+using namespace std;
+
+int dx[] = {0, 0, -1, 1};
+int dy[] = {-1, 1, 0, 0};
+
+class Solution {
+  public:
+    int digitsSum(int a, int b) {
+        int res = 0;
+        while (a || b) {
+            res += a % 10;
+            res += b % 10;
+            a /= 10;
+            b /= 10;
+        }
+        return res;
+    }
+
+    void dfs(int r, int c, int &rows, int &cols, int &cnt, bool vis[]) {
+        vis[r * cols + c] = true;
+        cnt += 1;
+        for (int d = 0; d < 4; ++d) {
+            int nr = r + dx[d];
+            int nc = c + dy[d];
+            if (nr >= 0 && nr < rows && nc >= 0 && nc < cols &&
+                !vis[nr * cols + nc]) {
+                dfs(nr, nc, rows, cols, cnt, vis);
+            }
+        }
+    }
+
+    int movingCount(int threshold, int rows, int cols) {
+        if (threshold < 0) {
+            return 0;
+        }
+
+        bool vis[rows * cols];
+        for (int i = 0; i < rows; ++i) {
+            for (int j = 0; j < cols; ++j) {
+                vis[i * cols + j] = (digitsSum(i, j) > threshold);
+            }
+        }
+        int cnt = 0;
+        dfs(0, 0, rows, cols, cnt, vis);
+        return cnt;
+    }
+};
+
+// int main() {
+//     cout << Solution().movingCount(2, 3, 3);
+//     return 0;
+// }