feat: add cpp solution to lc problem: No.0341

No.0341.Flatten Nested List Iterator

Author: yanglbme

lcci/17.09.Get Kth Magic Number/README.md

@@ -25,11 +25,13 @@
 
 **方法二：动态规划**
 
-定义数组 $dp$，其中 $dp[i]$ 表示第 $i$ 个数，答案即为 $dp[k]$。
+方法一的做法足以通过本题，但如果在面试中，面试官可能要求我们实现一个复杂度更低的算法。因此，我们有必要掌握一种更优的算法。
+
+我们定义数组 $dp$，其中 $dp[i]$ 表示第 $i$ 个数，答案即为 $dp[k]$。
 
 定义三个指针 $p_3$, $p_5$, $p_7$，表示下一个数是当前指针指向的数乘以对应的质因数，初始值都为 $1$。
 
-当 $2\le i \le k$ 时，令 $dp[i] = \min(dp[p_3\times 3], dp[p_5]\times 5, dp[p_7]\times 7)$，然后分别比较 $dp[i]$ 和 $dp[p_3]\times 3, dp[p_5]\times 5, dp[p_7]\times 7$，如果相等，则将对应的指针加 $1$。
+当 $2\le i \le k$ 时，令 $dp[i] = \min(dp[p_3]\times 3, dp[p_5]\times 5, dp[p_7]\times 7)$，然后分别比较 $dp[i]$ 和 $dp[p_3]\times 3, dp[p_5]\times 5, dp[p_7]\times 7$，如果相等，则将对应的指针加 $1$。
 
 时间复杂度 $O(k)$，空间复杂度 $O(k)$。
 

solution/0300-0399/0341.Flatten Nested List Iterator/README.md

@@ -59,11 +59,11 @@ return res</pre>
 
 **方法一：递归**
 
-根据题意要求可以将 NestedInteger 数据结构视作一个 N 叉树，当为一个整数时该节点是 N 叉树的叶子节点，当为一个整数数组时该节点是 N 叉树的非叶子节点，数组中的每一个元素包含子树的所有节点。故直接递归遍历 N 叉树并记录所有的叶子节点即可。
+根据题意要求可以将 NestedInteger 数据结构视作一个 N 叉树，当元素为一个整数时，该节点是 N 叉树的叶子节点，当元素为一个整数数组时，该节点是 N 叉树的非叶子节点，数组中的每一个元素包含子树的所有节点。故直接递归遍历 N 叉树并记录所有的叶子节点即可。
 
 **方法二：直接展开**
 
-调用 hasNext 时，如果 nestedList 的第一个元素是列表类型，则不断展开这个元素，直到第一个元素是整数类型。 调用 Next 方法时，由 hasNext 方法已确保 nestedList 第一个元素为整数类型，直接返回即可。
+调用 hasNext 时，如果 nestedList 的第一个元素是列表类型，则不断展开这个元素，直到第一个元素是整数类型。 调用 Next 方法时，由于 `hasNext()` 方法已确保 nestedList 第一个元素为整数类型，直接返回即可。
 
 <!-- tabs:start -->
 
@@ -184,6 +184,62 @@ public class NestedIterator implements Iterator<Integer> {
  */
 ```
 
+### **C++**
+
+```cpp
+/**
+ * // This is the interface that allows for creating nested lists.
+ * // You should not implement it, or speculate about its implementation
+ * class NestedInteger {
+ *   public:
+ *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
+ *     bool isInteger() const;
+ *
+ *     // Return the single integer that this NestedInteger holds, if it holds a single integer
+ *     // The result is undefined if this NestedInteger holds a nested list
+ *     int getInteger() const;
+ *
+ *     // Return the nested list that this NestedInteger holds, if it holds a nested list
+ *     // The result is undefined if this NestedInteger holds a single integer
+ *     const vector<NestedInteger> &getList() const;
+ * };
+ */
+
+class NestedIterator {
+public:
+    NestedIterator(vector<NestedInteger> &nestedList) {
+        dfs(nestedList);
+    }
+    
+    int next() {
+        return vals[cur++];
+    }
+    
+    bool hasNext() {
+        return cur < vals.size();
+    }
+private:
+    vector<int> vals;
+    int cur = 0;
+
+    void dfs(vector<NestedInteger> &nestedList) {
+        for (auto& e : nestedList) {
+            if (e.isInteger()) {
+                vals.push_back(e.getInteger());
+            } else {
+                dfs(e.getList());
+            }
+        }
+    }
+};
+
+/**
+ * Your NestedIterator object will be instantiated and called as such:
+ * NestedIterator i(nestedList);
+ * while (i.hasNext()) cout << i.next();
+ */
+```
+
 ### **TypeScript**
 
 ```ts

solution/0300-0399/0341.Flatten Nested List Iterator/README_EN.md

@@ -168,6 +168,62 @@ public class NestedIterator implements Iterator<Integer> {
  */
 ```
 
+### **C++**
+
+```cpp
+/**
+ * // This is the interface that allows for creating nested lists.
+ * // You should not implement it, or speculate about its implementation
+ * class NestedInteger {
+ *   public:
+ *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
+ *     bool isInteger() const;
+ *
+ *     // Return the single integer that this NestedInteger holds, if it holds a single integer
+ *     // The result is undefined if this NestedInteger holds a nested list
+ *     int getInteger() const;
+ *
+ *     // Return the nested list that this NestedInteger holds, if it holds a nested list
+ *     // The result is undefined if this NestedInteger holds a single integer
+ *     const vector<NestedInteger> &getList() const;
+ * };
+ */
+
+class NestedIterator {
+public:
+    NestedIterator(vector<NestedInteger> &nestedList) {
+        dfs(nestedList);
+    }
+    
+    int next() {
+        return vals[cur++];
+    }
+    
+    bool hasNext() {
+        return cur < vals.size();
+    }
+private:
+    vector<int> vals;
+    int cur = 0;
+
+    void dfs(vector<NestedInteger> &nestedList) {
+        for (auto& e : nestedList) {
+            if (e.isInteger()) {
+                vals.push_back(e.getInteger());
+            } else {
+                dfs(e.getList());
+            }
+        }
+    }
+};
+
+/**
+ * Your NestedIterator object will be instantiated and called as such:
+ * NestedIterator i(nestedList);
+ * while (i.hasNext()) cout << i.next();
+ */
+```
+
 ### **TypeScript**
 
 ```ts

solution/0300-0399/0341.Flatten Nested List Iterator/Solution.cpp

@@ -0,0 +1,51 @@
+/**
+ * // This is the interface that allows for creating nested lists.
+ * // You should not implement it, or speculate about its implementation
+ * class NestedInteger {
+ *   public:
+ *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
+ *     bool isInteger() const;
+ *
+ *     // Return the single integer that this NestedInteger holds, if it holds a single integer
+ *     // The result is undefined if this NestedInteger holds a nested list
+ *     int getInteger() const;
+ *
+ *     // Return the nested list that this NestedInteger holds, if it holds a nested list
+ *     // The result is undefined if this NestedInteger holds a single integer
+ *     const vector<NestedInteger> &getList() const;
+ * };
+ */
+
+class NestedIterator {
+public:
+    NestedIterator(vector<NestedInteger> &nestedList) {
+        dfs(nestedList);
+    }
+    
+    int next() {
+        return vals[cur++];
+    }
+    
+    bool hasNext() {
+        return cur < vals.size();
+    }
+private:
+    vector<int> vals;
+    int cur = 0;
+
+    void dfs(vector<NestedInteger> &nestedList) {
+        for (auto& e : nestedList) {
+            if (e.isInteger()) {
+                vals.push_back(e.getInteger());
+            } else {
+                dfs(e.getList());
+            }
+        }
+    }
+};
+
+/**
+ * Your NestedIterator object will be instantiated and called as such:
+ * NestedIterator i(nestedList);
+ * while (i.hasNext()) cout << i.next();
+ */