feat: update cpp solutions (#3923)

yanglbme · web-flow · commit 2b30bd0a2587 · 2025-01-04T22:25:27.000+08:00
diff --git a/lcci/04.01.Route Between Nodes/README.md b/lcci/04.01.Route Between Nodes/README.md
@@ -126,7 +126,7 @@ public:
         for (auto& e : graph) {
             g[e[0]].push_back(e[1]);
         }
-        function<bool(int)> dfs = [&](int i) {
+        auto dfs = [&](this auto&& dfs, int i) -> bool {
             if (i == target) {
                 return true;
             }
diff --git a/lcci/04.01.Route Between Nodes/README_EN.md b/lcci/04.01.Route Between Nodes/README_EN.md
@@ -134,7 +134,7 @@ public:
         for (auto& e : graph) {
             g[e[0]].push_back(e[1]);
         }
-        function<bool(int)> dfs = [&](int i) {
+        auto dfs = [&](this auto&& dfs, int i) -> bool {
             if (i == target) {
                 return true;
             }
diff --git a/lcci/04.01.Route Between Nodes/Solution.cpp b/lcci/04.01.Route Between Nodes/Solution.cpp
@@ -6,7 +6,7 @@ class Solution {
         for (auto& e : graph) {
             g[e[0]].push_back(e[1]);
         }
-        function<bool(int)> dfs = [&](int i) {
+        auto dfs = [&](this auto&& dfs, int i) -> bool {
             if (i == target) {
                 return true;
             }
@@ -23,4 +23,4 @@ class Solution {
         };
         return dfs(start);
     }
-};
+};
diff --git a/lcci/04.02.Minimum Height Tree/README.md b/lcci/04.02.Minimum Height Tree/README.md
@@ -103,7 +103,7 @@ class Solution {
 class Solution {
 public:
     TreeNode* sortedArrayToBST(vector<int>& nums) {
-        function<TreeNode*(int, int)> dfs = [&](int l, int r) -> TreeNode* {
+        auto dfs = [&](this auto&& dfs, int l, int r) -> TreeNode* {
             if (l > r) {
                 return nullptr;
             }
diff --git a/lcci/04.02.Minimum Height Tree/README_EN.md b/lcci/04.02.Minimum Height Tree/README_EN.md
@@ -24,19 +24,19 @@ Given sorted array: [-10,-3,0,5,9],
 
 
 
-One possible answer is: [0,-3,9,-10,null,5]，which represents the following tree: 
+One possible answer is: [0,-3,9,-10,null,5]，which represents the following tree:
 
 
 
-          0 
+          0
 
-         / \ 
+         / \
 
-       -3   9 
+       -3   9
 
-       /   / 
+       /   /
 
-     -10  5 
+     -10  5
 
 </pre>
 
@@ -127,7 +127,7 @@ class Solution {
 class Solution {
 public:
     TreeNode* sortedArrayToBST(vector<int>& nums) {
-        function<TreeNode*(int, int)> dfs = [&](int l, int r) -> TreeNode* {
+        auto dfs = [&](this auto&& dfs, int l, int r) -> TreeNode* {
             if (l > r) {
                 return nullptr;
             }
diff --git a/lcci/04.02.Minimum Height Tree/Solution.cpp b/lcci/04.02.Minimum Height Tree/Solution.cpp
@@ -10,7 +10,7 @@
 class Solution {
 public:
     TreeNode* sortedArrayToBST(vector<int>& nums) {
-        function<TreeNode*(int, int)> dfs = [&](int l, int r) -> TreeNode* {
+        auto dfs = [&](this auto&& dfs, int l, int r) -> TreeNode* {
             if (l > r) {
                 return nullptr;
             }
@@ -19,4 +19,4 @@ class Solution {
         };
         return dfs(0, nums.size() - 1);
     }
-};
+};
diff --git a/solution/0100-0199/0131.Palindrome Partitioning/README.md b/solution/0100-0199/0131.Palindrome Partitioning/README.md
@@ -149,14 +149,14 @@ public:
         }
         vector<vector<string>> ans;
         vector<string> t;
-        function<void(int)> dfs = [&](int i) {
+        auto dfs = [&](this auto&& dfs, int i) -> void {
             if (i == n) {
-                ans.push_back(t);
+                ans.emplace_back(t);
                 return;
             }
             for (int j = i; j < n; ++j) {
                 if (f[i][j]) {
-                    t.push_back(s.substr(i, j - i + 1));
+                    t.emplace_back(s.substr(i, j - i + 1));
                     dfs(j + 1);
                     t.pop_back();
                 }
diff --git a/solution/0100-0199/0131.Palindrome Partitioning/README_EN.md b/solution/0100-0199/0131.Palindrome Partitioning/README_EN.md
@@ -130,14 +130,14 @@ public:
         }
         vector<vector<string>> ans;
         vector<string> t;
-        function<void(int)> dfs = [&](int i) {
+        auto dfs = [&](this auto&& dfs, int i) -> void {
             if (i == n) {
-                ans.push_back(t);
+                ans.emplace_back(t);
                 return;
             }
             for (int j = i; j < n; ++j) {
                 if (f[i][j]) {
-                    t.push_back(s.substr(i, j - i + 1));
+                    t.emplace_back(s.substr(i, j - i + 1));
                     dfs(j + 1);
                     t.pop_back();
                 }
diff --git a/solution/0100-0199/0131.Palindrome Partitioning/Solution.cpp b/solution/0100-0199/0131.Palindrome Partitioning/Solution.cpp
@@ -11,14 +11,14 @@ class Solution {
         }
         vector<vector<string>> ans;
         vector<string> t;
-        function<void(int)> dfs = [&](int i) {
+        auto dfs = [&](this auto&& dfs, int i) -> void {
             if (i == n) {
-                ans.push_back(t);
+                ans.emplace_back(t);
                 return;
             }
             for (int j = i; j < n; ++j) {
                 if (f[i][j]) {
-                    t.push_back(s.substr(i, j - i + 1));
+                    t.emplace_back(s.substr(i, j - i + 1));
                     dfs(j + 1);
                     t.pop_back();
                 }
@@ -27,4 +27,4 @@ class Solution {
         dfs(0);
         return ans;
     }
-};
+};
diff --git a/solution/1100-1199/1120.Maximum Average Subtree/README.md b/solution/1100-1199/1120.Maximum Average Subtree/README.md
@@ -160,7 +160,7 @@ class Solution {
 public:
     double maximumAverageSubtree(TreeNode* root) {
         double ans = 0;
-        function<pair<int, int>(TreeNode*)> dfs = [&](TreeNode* root) -> pair<int, int> {
+        auto dfs = [&](this auto&& dfs, TreeNode* root) -> pair<int, int> {
             if (!root) {
                 return {0, 0};
             }
diff --git a/solution/1100-1199/1120.Maximum Average Subtree/README_EN.md b/solution/1100-1199/1120.Maximum Average Subtree/README_EN.md
@@ -32,7 +32,7 @@ tags:
 <pre>
 <strong>Input:</strong> root = [5,6,1]
 <strong>Output:</strong> 6.00000
-<strong>Explanation:</strong> 
+<strong>Explanation:</strong>
 For the node with value = 5 we have an average of (5 + 6 + 1) / 3 = 4.
 For the node with value = 6 we have an average of 6 / 1 = 6.
 For the node with value = 1 we have an average of 1 / 1 = 1.
@@ -163,7 +163,7 @@ class Solution {
 public:
     double maximumAverageSubtree(TreeNode* root) {
         double ans = 0;
-        function<pair<int, int>(TreeNode*)> dfs = [&](TreeNode* root) -> pair<int, int> {
+        auto dfs = [&](this auto&& dfs, TreeNode* root) -> pair<int, int> {
             if (!root) {
                 return {0, 0};
             }
diff --git a/solution/1100-1199/1120.Maximum Average Subtree/Solution.cpp b/solution/1100-1199/1120.Maximum Average Subtree/Solution.cpp
@@ -13,7 +13,7 @@ class Solution {
 public:
     double maximumAverageSubtree(TreeNode* root) {
         double ans = 0;
-        function<pair<int, int>(TreeNode*)> dfs = [&](TreeNode* root) -> pair<int, int> {
+        auto dfs = [&](this auto&& dfs, TreeNode* root) -> pair<int, int> {
             if (!root) {
                 return {0, 0};
             }
@@ -27,4 +27,4 @@ class Solution {
         dfs(root);
         return ans;
     }
-};
+};
diff --git a/solution/1300-1399/1373.Maximum Sum BST in Binary Tree/README.md b/solution/1300-1399/1373.Maximum Sum BST in Binary Tree/README.md
@@ -214,20 +214,19 @@ public:
     int maxSumBST(TreeNode* root) {
         int ans = 0;
         const int inf = 1 << 30;
-
-        function<vector<int>(TreeNode*)> dfs = [&](TreeNode* root) {
+        auto dfs = [&](this auto&& dfs, TreeNode* root) -> array<int, 4> {
             if (!root) {
-                return vector<int>{1, inf, -inf, 0};
+                return {1, inf, -inf, 0};
             }
             auto l = dfs(root->left);
             auto r = dfs(root->right);
             int v = root->val;
             if (l[0] && r[0] && l[2] < v && v < r[1]) {
                 int s = l[3] + r[3] + v;
                 ans = max(ans, s);
-                return vector<int>{1, min(l[1], v), max(r[2], v), s};
+                return {1, min(l[1], v), max(r[2], v), s};
             }
-            return vector<int>(4);
+            return {0};
         };
         dfs(root);
         return ans;
diff --git a/solution/1300-1399/1373.Maximum Sum BST in Binary Tree/README_EN.md b/solution/1300-1399/1373.Maximum Sum BST in Binary Tree/README_EN.md
@@ -198,20 +198,19 @@ public:
     int maxSumBST(TreeNode* root) {
         int ans = 0;
         const int inf = 1 << 30;
-
-        function<vector<int>(TreeNode*)> dfs = [&](TreeNode* root) {
+        auto dfs = [&](this auto&& dfs, TreeNode* root) -> array<int, 4> {
             if (!root) {
-                return vector<int>{1, inf, -inf, 0};
+                return {1, inf, -inf, 0};
             }
             auto l = dfs(root->left);
             auto r = dfs(root->right);
             int v = root->val;
             if (l[0] && r[0] && l[2] < v && v < r[1]) {
                 int s = l[3] + r[3] + v;
                 ans = max(ans, s);
-                return vector<int>{1, min(l[1], v), max(r[2], v), s};
+                return {1, min(l[1], v), max(r[2], v), s};
             }
-            return vector<int>(4);
+            return {0};
         };
         dfs(root);
         return ans;
diff --git a/solution/1300-1399/1373.Maximum Sum BST in Binary Tree/Solution.cpp b/solution/1300-1399/1373.Maximum Sum BST in Binary Tree/Solution.cpp
@@ -14,22 +14,21 @@ class Solution {
     int maxSumBST(TreeNode* root) {
         int ans = 0;
         const int inf = 1 << 30;
-
-        function<vector<int>(TreeNode*)> dfs = [&](TreeNode* root) {
+        auto dfs = [&](this auto&& dfs, TreeNode* root) -> array<int, 4> {
             if (!root) {
-                return vector<int>{1, inf, -inf, 0};
+                return {1, inf, -inf, 0};
             }
             auto l = dfs(root->left);
             auto r = dfs(root->right);
             int v = root->val;
             if (l[0] && r[0] && l[2] < v && v < r[1]) {
                 int s = l[3] + r[3] + v;
                 ans = max(ans, s);
-                return vector<int>{1, min(l[1], v), max(r[2], v), s};
+                return {1, min(l[1], v), max(r[2], v), s};
             }
-            return vector<int>(4);
+            return {0};
         };
         dfs(root);
         return ans;
     }
-};
+};
diff --git a/solution/1500-1599/1559.Detect Cycles in 2D Grid/README.md b/solution/1500-1599/1559.Detect Cycles in 2D Grid/README.md
@@ -452,7 +452,7 @@ public:
         int m = grid.size(), n = grid[0].size();
         vector<vector<bool>> vis(m, vector<bool>(n));
         const vector<int> dirs = {-1, 0, 1, 0, -1};
-        function<bool(int, int, int, int)> dfs = [&](int x, int y, int px, int py) {
+        auto dfs = [&](this auto&& dfs, int x, int y, int px, int py) -> bool {
             vis[x][y] = true;
             for (int k = 0; k < 4; ++k) {
                 int nx = x + dirs[k], ny = y + dirs[k + 1];
diff --git a/solution/1500-1599/1559.Detect Cycles in 2D Grid/README_EN.md b/solution/1500-1599/1559.Detect Cycles in 2D Grid/README_EN.md
@@ -452,7 +452,7 @@ public:
         int m = grid.size(), n = grid[0].size();
         vector<vector<bool>> vis(m, vector<bool>(n));
         const vector<int> dirs = {-1, 0, 1, 0, -1};
-        function<bool(int, int, int, int)> dfs = [&](int x, int y, int px, int py) {
+        auto dfs = [&](this auto&& dfs, int x, int y, int px, int py) -> bool {
             vis[x][y] = true;
             for (int k = 0; k < 4; ++k) {
                 int nx = x + dirs[k], ny = y + dirs[k + 1];
diff --git a/solution/1500-1599/1559.Detect Cycles in 2D Grid/Solution2.cpp b/solution/1500-1599/1559.Detect Cycles in 2D Grid/Solution2.cpp
@@ -4,7 +4,7 @@ class Solution {
         int m = grid.size(), n = grid[0].size();
         vector<vector<bool>> vis(m, vector<bool>(n));
         const vector<int> dirs = {-1, 0, 1, 0, -1};
-        function<bool(int, int, int, int)> dfs = [&](int x, int y, int px, int py) {
+        auto dfs = [&](this auto&& dfs, int x, int y, int px, int py) -> bool {
             vis[x][y] = true;
             for (int k = 0; k < 4; ++k) {
                 int nx = x + dirs[k], ny = y + dirs[k + 1];
diff --git a/solution/1600-1699/1676.Lowest Common Ancestor of a Binary Tree IV/README.md b/solution/1600-1699/1676.Lowest Common Ancestor of a Binary Tree IV/README.md
@@ -160,13 +160,21 @@ class Solution {
 public:
     TreeNode* lowestCommonAncestor(TreeNode* root, vector<TreeNode*>& nodes) {
         unordered_set<int> s;
-        for (auto node : nodes) s.insert(node->val);
-        function<TreeNode*(TreeNode*)> dfs = [&](TreeNode* root) -> TreeNode* {
-            if (!root || s.count(root->val)) return root;
+        for (auto node : nodes) {
+            s.insert(node->val);
+        }
+        auto dfs = [&](this auto&& dfs, TreeNode* root) -> TreeNode* {
+            if (!root || s.contains(root->val)) {
+                return root;
+            }
             auto left = dfs(root->left);
             auto right = dfs(root->right);
-            if (!left) return right;
-            if (!right) return left;
+            if (!left) {
+                return right;
+            }
+            if (!right) {
+                return left;
+            }
             return root;
         };
         return dfs(root);
diff --git a/solution/1600-1699/1676.Lowest Common Ancestor of a Binary Tree IV/README_EN.md b/solution/1600-1699/1676.Lowest Common Ancestor of a Binary Tree IV/README_EN.md
@@ -154,13 +154,21 @@ class Solution {
 public:
     TreeNode* lowestCommonAncestor(TreeNode* root, vector<TreeNode*>& nodes) {
         unordered_set<int> s;
-        for (auto node : nodes) s.insert(node->val);
-        function<TreeNode*(TreeNode*)> dfs = [&](TreeNode* root) -> TreeNode* {
-            if (!root || s.count(root->val)) return root;
+        for (auto node : nodes) {
+            s.insert(node->val);
+        }
+        auto dfs = [&](this auto&& dfs, TreeNode* root) -> TreeNode* {
+            if (!root || s.contains(root->val)) {
+                return root;
+            }
             auto left = dfs(root->left);
             auto right = dfs(root->right);
-            if (!left) return right;
-            if (!right) return left;
+            if (!left) {
+                return right;
+            }
+            if (!right) {
+                return left;
+            }
             return root;
         };
         return dfs(root);
diff --git a/solution/1600-1699/1676.Lowest Common Ancestor of a Binary Tree IV/Solution.cpp b/solution/1600-1699/1676.Lowest Common Ancestor of a Binary Tree IV/Solution.cpp
@@ -13,15 +13,23 @@ class Solution {
 public:
     TreeNode* lowestCommonAncestor(TreeNode* root, vector<TreeNode*>& nodes) {
         unordered_set<int> s;
-        for (auto node : nodes) s.insert(node->val);
-        function<TreeNode*(TreeNode*)> dfs = [&](TreeNode* root) -> TreeNode* {
-            if (!root || s.count(root->val)) return root;
+        for (auto node : nodes) {
+            s.insert(node->val);
+        }
+        auto dfs = [&](this auto&& dfs, TreeNode* root) -> TreeNode* {
+            if (!root || s.contains(root->val)) {
+                return root;
+            }
             auto left = dfs(root->left);
             auto right = dfs(root->right);
-            if (!left) return right;
-            if (!right) return left;
+            if (!left) {
+                return right;
+            }
+            if (!right) {
+                return left;
+            }
             return root;
         };
         return dfs(root);
     }
-};
+};

Original file line number	Diff line number	Diff line change
`@@ -126,7 +126,7 @@ public:`
`126`	`126`	`for (auto& e : graph) {`
`127`	`127`	`g[e[0]].push_back(e[1]);`
`128`	`128`	`}`
`129`		`- function<bool(int)> dfs = [&](int i) {`
	`129`	`+ auto dfs = [&](this auto&& dfs, int i) -> bool {`
`130`	`130`	`if (i == target) {`
`131`	`131`	`return true;`
`132`	`132`	`}`
Original file line number	Diff line number	Diff line change
`@@ -134,7 +134,7 @@ public:`
`134`	`134`	`for (auto& e : graph) {`
`135`	`135`	`g[e[0]].push_back(e[1]);`
`136`	`136`	`}`
`137`		`- function<bool(int)> dfs = [&](int i) {`
	`137`	`+ auto dfs = [&](this auto&& dfs, int i) -> bool {`
`138`	`138`	`if (i == target) {`
`139`	`139`	`return true;`
`140`	`140`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ class Solution {`
`6`	`6`	`for (auto& e : graph) {`
`7`	`7`	`g[e[0]].push_back(e[1]);`
`8`	`8`	`}`
`9`		`- function<bool(int)> dfs = [&](int i) {`
	`9`	`+ auto dfs = [&](this auto&& dfs, int i) -> bool {`
`10`	`10`	`if (i == target) {`
`11`	`11`	`return true;`
`12`	`12`	`}`
`@@ -23,4 +23,4 @@ class Solution {`
`23`	`23`	`};`
`24`	`24`	`return dfs(start);`
`25`	`25`	`}`
`26`		`-};`
	`26`	`+};`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ class Solution {`
`103`	`103`	`class Solution {`
`104`	`104`	`public:`
`105`	`105`	`TreeNode* sortedArrayToBST(vector<int>& nums) {`
`106`		`- function<TreeNode(int, int)> dfs = [&](int l, int r) -> TreeNode {`
	`106`	`+ auto dfs = [&](this auto&& dfs, int l, int r) -> TreeNode* {`
`107`	`107`	`if (l > r) {`
`108`	`108`	`return nullptr;`
`109`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`	`class Solution {`
`11`	`11`	`public:`
`12`	`12`	`TreeNode* sortedArrayToBST(vector<int>& nums) {`
`13`		`- function<TreeNode(int, int)> dfs = [&](int l, int r) -> TreeNode {`
	`13`	`+ auto dfs = [&](this auto&& dfs, int l, int r) -> TreeNode* {`
`14`	`14`	`if (l > r) {`
`15`	`15`	`return nullptr;`
`16`	`16`	`}`
`@@ -19,4 +19,4 @@ class Solution {`
`19`	`19`	`};`
`20`	`20`	`return dfs(0, nums.size() - 1);`
`21`	`21`	`}`
`22`		`-};`
	`22`	`+};`
Original file line number	Diff line number	Diff line change
`@@ -149,14 +149,14 @@ public:`
`149`	`149`	`}`
`150`	`150`	`vector<vector<string>> ans;`
`151`	`151`	`vector<string> t;`
`152`		`- function<void(int)> dfs = [&](int i) {`
	`152`	`+ auto dfs = [&](this auto&& dfs, int i) -> void {`
`153`	`153`	`if (i == n) {`
`154`		`- ans.push_back(t);`
	`154`	`+ ans.emplace_back(t);`
`155`	`155`	`return;`
`156`	`156`	`}`
`157`	`157`	`for (int j = i; j < n; ++j) {`
`158`	`158`	`if (f[i][j]) {`
`159`		`- t.push_back(s.substr(i, j - i + 1));`
	`159`	`+ t.emplace_back(s.substr(i, j - i + 1));`
`160`	`160`	`dfs(j + 1);`
`161`	`161`	`t.pop_back();`
`162`	`162`	`}`
Original file line number	Diff line number	Diff line change
`@@ -130,14 +130,14 @@ public:`
`130`	`130`	`}`
`131`	`131`	`vector<vector<string>> ans;`
`132`	`132`	`vector<string> t;`
`133`		`- function<void(int)> dfs = [&](int i) {`
	`133`	`+ auto dfs = [&](this auto&& dfs, int i) -> void {`
`134`	`134`	`if (i == n) {`
`135`		`- ans.push_back(t);`
	`135`	`+ ans.emplace_back(t);`
`136`	`136`	`return;`
`137`	`137`	`}`
`138`	`138`	`for (int j = i; j < n; ++j) {`
`139`	`139`	`if (f[i][j]) {`
`140`		`- t.push_back(s.substr(i, j - i + 1));`
	`140`	`+ t.emplace_back(s.substr(i, j - i + 1));`
`141`	`141`	`dfs(j + 1);`
`142`	`142`	`t.pop_back();`
`143`	`143`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,14 +11,14 @@ class Solution {`
`11`	`11`	`}`
`12`	`12`	`vector<vector<string>> ans;`
`13`	`13`	`vector<string> t;`
`14`		`- function<void(int)> dfs = [&](int i) {`
	`14`	`+ auto dfs = [&](this auto&& dfs, int i) -> void {`
`15`	`15`	`if (i == n) {`
`16`		`- ans.push_back(t);`
	`16`	`+ ans.emplace_back(t);`
`17`	`17`	`return;`
`18`	`18`	`}`
`19`	`19`	`for (int j = i; j < n; ++j) {`
`20`	`20`	`if (f[i][j]) {`
`21`		`- t.push_back(s.substr(i, j - i + 1));`
	`21`	`+ t.emplace_back(s.substr(i, j - i + 1));`
`22`	`22`	`dfs(j + 1);`
`23`	`23`	`t.pop_back();`
`24`	`24`	`}`
`@@ -27,4 +27,4 @@ class Solution {`
`27`	`27`	`dfs(0);`
`28`	`28`	`return ans;`
`29`	`29`	`}`
`30`		`-};`
	`30`	`+};`
Original file line number	Diff line number	Diff line change
`@@ -160,7 +160,7 @@ class Solution {`
`160`	`160`	`public:`
`161`	`161`	`double maximumAverageSubtree(TreeNode* root) {`
`162`	`162`	`double ans = 0;`
`163`		`- function<pair<int, int>(TreeNode)> dfs = [&](TreeNode root) -> pair<int, int> {`
	`163`	`+ auto dfs = [&](this auto&& dfs, TreeNode* root) -> pair<int, int> {`
`164`	`164`	`if (!root) {`
`165`	`165`	`return {0, 0};`
`166`	`166`	`}`