format

Author: Kun Luo

src/4sum.cc

@@ -3,25 +3,21 @@
 using namespace std;
 
 class Solution {
-public:
-    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
+  public:
+    int fourSumCount(vector<int> &A, vector<int> &B, vector<int> &C, vector<int> &D) {
         int           counter = 0;
         map<int, int> sum_map;
         for (const auto a : A) {
-            for (const auto b : B) {
-                ++sum_map[a + b];
-            }
+            for (const auto b : B) { ++sum_map[a + b]; }
         }
         for (const auto c : C) {
-            for (const auto d : D) {
-                counter += sum_map[-(c + d)];
-            }
+            for (const auto d : D) { counter += sum_map[-(c + d)]; }
         }
         return counter;
     }
 };
 
-int main(int argc, char const* argv[]) {
+int main(int argc, char const *argv[]) {
     Solution    solution;
     vector<int> a{0, 1, -1};
     vector<int> b{-1, 1, 0};

src/add-two-numbers.cc

@@ -4,8 +4,8 @@ using namespace std;
 using namespace utils;
 
 class Solution {
-public:
-    ListNode* addTwoNumbers(ListNode* ln, ListNode* rn) {
+  public:
+    ListNode *addTwoNumbers(ListNode *ln, ListNode *rn) {
         int32_t   val = 0, flow = 0;
         ListNode *ret = nullptr, *cur = nullptr;
 
@@ -42,19 +42,17 @@ class Solution {
             cur       = cur->next;
         }
 
-        if (flow != 0) {
-            cur->next = new ListNode{flow};
-        }
+        if (flow != 0) { cur->next = new ListNode{flow}; }
         return ret;
     }
 };
 
-int main(int argc, char const* argv[]) {
-    ListNode* a = make_nodes({2, 4, 3});
-    ListNode* b = make_nodes({5, 6, 7, 2});
+int main(int argc, char const *argv[]) {
+    ListNode *a = make_nodes({2, 4, 3});
+    ListNode *b = make_nodes({5, 6, 7, 2});
 
     Solution  solution;
-    ListNode* res = solution.addTwoNumbers(a, b);
+    ListNode *res = solution.addTwoNumbers(a, b);
     print_nodes(res);
     del_nodes(a);
     del_nodes(b);

src/basic-calculator.cc

@@ -3,13 +3,13 @@
 using namespace std;
 
 class Solution {
-public:
-    int calculate(const string& str) {
+  public:
+    int calculate(const string &str) {
         size_t idx = 0;
         return calculate(str, idx);
     }
 
-    int calculate(const string& str, size_t& idx) const {
+    int calculate(const string &str, size_t &idx) const {
         int64_t res = 0;
         for (char opr = '+'; idx < str.size();) {
             switch (str[idx]) {
@@ -23,9 +23,7 @@ class Solution {
                 default:
                     if (isdigit(str[idx])) {
                         int64_t x = str[idx++] - '0';
-                        while (idx < str.size() && isdigit(str[idx])) {
-                            x = x * 10 + str[idx++] - '0';
-                        }
+                        while (idx < str.size() && isdigit(str[idx])) { x = x * 10 + str[idx++] - '0'; }
                         res += opr == '+' ? x : -x;
                     } else {
                         ++idx;
@@ -37,7 +35,7 @@ class Solution {
     }
 };
 
-int main(int argc, char const* argv[]) {
+int main(int argc, char const *argv[]) {
     Solution solution;
     cout << solution.calculate("1-(2-(3-2))") << endl;         // 0
     cout << solution.calculate("1 + 1") << endl;               // 2

src/best-time-to-buy-and-sell-stock-iii.cc

@@ -4,11 +4,11 @@ using namespace std;
 using namespace utils;
 
 class Solution {
-public:
-    int maxProfit(vector<int>& prices) {
+  public:
+    int maxProfit(vector<int> &prices) {
         auto fst_buy = numeric_limits<int>::min(), fst_sell = 0;
         auto sec_buy = numeric_limits<int>::min(), sec_sell = 0;
-        for (const auto& price : prices) {
+        for (const auto &price : prices) {
             fst_buy  = std::max(fst_buy, -price);
             fst_sell = std::max(fst_sell, fst_buy + price);
             sec_buy  = std::max(sec_buy, fst_sell - price);
@@ -18,7 +18,7 @@ class Solution {
     }
 };
 
-int main(int argc, char const* argv[]) {
+int main(int argc, char const *argv[]) {
     vector<int> vec{1, 2, 3};
     Solution    solution;
     cout << solution.maxProfit(vec);

src/binary-tree-maximum-path-sum.cc

@@ -4,14 +4,14 @@ using namespace std;
 using namespace utils;
 
 class Solution {
-public:
-    int maxPathSum(TreeNode* root) {
+  public:
+    int maxPathSum(TreeNode *root) {
         int res = std::numeric_limits<int>::min();
         find_max_sum(root, res);
         return res;
     }
 
-    int find_max_sum(TreeNode* root, int& res) const {
+    int find_max_sum(TreeNode *root, int &res) const {
         if (root == nullptr) return 0;
         const int ls = max(0, find_max_sum(root->left, res));
         const int rs = max(0, find_max_sum(root->right, res));
@@ -20,7 +20,7 @@ class Solution {
     }
 };
 
-int main(int argc, char const* argv[]) {
+int main(int argc, char const *argv[]) {
     Solution   solution;
     const auto tree = make_tree(-10, make_tree(9), make_tree(20, make_tree(15), make_tree(17)));
     cout << solution.maxPathSum(tree) << endl;

src/broken-board-dominoes.cc

@@ -5,23 +5,19 @@
 
 using namespace std;
 
-ostream& operator<<(ostream& os, const std::vector<vector<char>>& board) {
-    for (auto&& row : board) {
-        for (auto&& col : row) {
-            os << col << "  ";
-        }
+ostream &operator<<(ostream &os, const std::vector<vector<char>> &board) {
+    for (auto &&row : board) {
+        for (auto &&col : row) { os << col << "  "; }
         os << endl;
     }
     return os;
 }
 
 class Solution {
-public:
-    int domino(int n, int m, const vector<vector<int>>& broken) {
+  public:
+    int domino(int n, int m, const vector<vector<int>> &broken) {
         vector<vector<char>> board(n, vector<char>(m, 0));
-        for (auto&& xy : broken) {
-            board[xy[0]][xy[1]] = 'X';
-        }
+        for (auto &&xy : broken) { board[xy[0]][xy[1]] = 'X'; }
         const int                    L   = (n * m - broken.size()) / 2;
         int                          res = 0;
         stack<tuple<char, int, int>> opr_stk;
@@ -51,12 +47,10 @@ class Solution {
             // 回退
             if (row >= n) {
                 res = std::max<int>(res, opr_stk.size());
-                if (opr_stk.size() == L) {
-                    return L;
-                }
+                if (opr_stk.size() == L) { return L; }
                 for (;;) {
                     if (opr_stk.empty()) return res;
-                    auto& [dir, x, y] = opr_stk.top();
+                    auto &[dir, x, y] = opr_stk.top();
                     if (dir == '-') {
                         board[x][y + 1] = 0;
                         if (x + 1 < n && board[x + 1][y] == 0) {
@@ -82,7 +76,7 @@ class Solution {
     }
 };
 
-int main(int argc, char const* argv[]) {
+int main(int argc, char const *argv[]) {
     Solution solution;
 
     // cout << solution.domino(2, 3, {{1, 0}, {1, 1}}) << endl;

src/container-with-most-water.cc

@@ -3,8 +3,8 @@
 using namespace std;
 
 class Solution {
-public:
-    int maxArea(const vector<int>& height) {
+  public:
+    int maxArea(const vector<int> &height) {
         switch (height.size()) {
             case 0:
             case 1: return 0;
@@ -20,16 +20,14 @@ class Solution {
                         --r;
                     }
                     const auto area = h * (r - l + 1);
-                    if (area > max_area) {
-                        max_area = area;
-                    }
+                    if (area > max_area) { max_area = area; }
                 }
                 return max_area;
         }
     }
 };
 
-int main(int argc, char const* argv[]) {
+int main(int argc, char const *argv[]) {
     vector<int> vec{1, 8, 6, 2, 5, 4, 8, 3, 7};
     Solution    solution;
     std::cout << solution.maxArea(vec);

src/distinct-subsequences.cc

@@ -4,15 +4,13 @@ using namespace std;
 using namespace utils;
 
 class Solution {
-public:
-    static int num_distinct(const string& src, const string& dst) {
+  public:
+    static int num_distinct(const string &src, const string &dst) {
         const size_t             M = src.length(), N = dst.size();
         vector<vector<uint32_t>> dp(N + 1, vector<uint32_t>(M + 1));
         std::fill(dp[0].begin(), dp[0].end(), 1);
         for (size_t i = 1; i <= dst.size(); ++i) {
-            if (dst[i - 1] == src[i - 1]) {
-                dp[i][i] = dp[i - 1][i - 1];
-            }
+            if (dst[i - 1] == src[i - 1]) { dp[i][i] = dp[i - 1][i - 1]; }
             for (size_t j = i + 1; j <= src.size(); ++j) {
                 if (dst[i - 1] == src[j - 1]) {
                     dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1];
@@ -25,7 +23,7 @@ class Solution {
     }
 };
 
-int main(int argc, char const* argv[]) {
+int main(int argc, char const *argv[]) {
     cout << Solution::num_distinct("xslledayhxhadmctrliaxqpokyezcfhzaskeykchkmhpyjipxtsuljkwkovmvel"
                                    "vwxzwieeuqnjozrfwmzsylcwvsthnxujvrkszqwtglewkycikdaiocglwzukwov"
                                    "sghkhyidevhbgffoqkpabthmqihcfxxzdejletqjoxmwftlxfcxgxgvpperwbqv"

src/divisor-game.cc

@@ -4,11 +4,13 @@
 using namespace std;
 
 class Solution {
-public:
-    bool divisorGame(int N) { return !(N & 1); }
+  public:
+    bool divisorGame(int N) {
+        return !(N & 1);
+    }
 };
 
-int main(int argc, char const* argv[]) {
+int main(int argc, char const *argv[]) {
     Solution solution;
     cout << (solution.divisorGame(2) ? "True" : "False") << endl;
 }

src/dungeon-game.cc

@@ -5,27 +5,21 @@
 using namespace std;
 
 class Solution {
-public:
-    int calculateMinimumHP(const vector<vector<int>>& dungeon) {
+  public:
+    int calculateMinimumHP(const vector<vector<int>> &dungeon) {
         const int           M = dungeon.size(), N = dungeon.front().size();
         vector<vector<int>> dp(M, vector<int>(N, 0));
         dp[M - 1][N - 1] = max(1, 1 - dungeon[M - 1][N - 1]);
+        for (int i = M - 2; i >= 0; --i) { dp[i][N - 1] = max(1, dp[i + 1][N - 1] - dungeon[i][N - 1]); }
+        for (int j = N - 2; j >= 0; --j) { dp[M - 1][j] = max(1, dp[M - 1][j + 1] - dungeon[M - 1][j]); }
         for (int i = M - 2; i >= 0; --i) {
-            dp[i][N - 1] = max(1, dp[i + 1][N - 1] - dungeon[i][N - 1]);
-        }
-        for (int j = N - 2; j >= 0; --j) {
-            dp[M - 1][j] = max(1, dp[M - 1][j + 1] - dungeon[M - 1][j]);
-        }
-        for (int i = M - 2; i >= 0; --i) {
-            for (int j = N - 2; j >= 0; --j) {
-                dp[i][j] = max(1, min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j]);
-            }
+            for (int j = N - 2; j >= 0; --j) { dp[i][j] = max(1, min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j]); }
         }
         return dp.front().front();
     }
 };
 
-int main(int argc, char const* argv[]) {
+int main(int argc, char const *argv[]) {
     Solution solution;
     cout << solution.calculateMinimumHP({{-2, -3, 3}, {-5, -10, 1}, {10, 30, -5}}) << endl; // 7
 }