.

Author: Luke

divisor-game.h

@@ -0,0 +1,18 @@
+// https://leetcode-cn.com/problems/divisor-game/
+
+#pragma once
+
+#include <algorithm>
+#include <iostream>
+
+using namespace std;
+
+class Solution {
+  public:
+    bool divisorGame(int N) { return !(N & 1); }
+};
+
+inline void test() {
+    Solution solution;
+    cout << (solution.divisorGame(2) ? "True" : "False") << endl;
+}

dungeon-game.h

@@ -2,14 +2,37 @@
 
 #pragma once
 
+#include <algorithm>
 #include <iostream>
 #include <vector>
 
-#using namespace std;
+using namespace std;
 
 class Solution {
   public:
-    int calculateMinimumHP(vector<vector<int>> &dungeon) {}
+    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) {
+            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();
+    }
 };
 
-inline void test() {}
+inline void test() {
+    Solution solution;
+    cout << solution.calculateMinimumHP(
+                {{-2, -3, 3}, {-5, -10, 1}, {10, 30, -5}})
+         << endl; // 7
+}

longest-increasing-path-in-a-matrix.h

@@ -0,0 +1,69 @@
+// https://leetcode-cn.com/problems/longest-increasing-path-in-a-matrix/
+
+#pragma once
+
+#include <algorithm>
+#include <iostream>
+#include <queue>
+#include <vector>
+
+using namespace std;
+
+class Solution {
+  public:
+    int res = 0;
+    int dir[5] = {0, 1, 0, -1, 0};
+    int M, N;
+    int dfs(vector<vector<int>> &dp, vector<vector<int>> &matrix, int x, int y,
+            int len) {
+        if (dp[x][y] != -1)
+            return dp[x][y];
+        // int tmp = len;
+        for (int i = 0; i < 4; i++) {
+            int tx = x + dir[i];
+            int ty = y + dir[i + 1];
+            if (tx >= 0 && tx < M && ty >= 0 && ty < N) {
+                if (matrix[tx][ty] > matrix[x][y]) {
+                    dp[x][y] = max(dp[x][y], dfs(dp, matrix, tx, ty, len + 1));
+                }
+            }
+        }
+        return ++dp[x][y];
+    }
+    int longestIncreasingPath(vector<vector<int>> &matrix) {
+        if (matrix.empty() || matrix.front().size())
+            return 0;
+        M = matrix.size(), N = matrix.front().size();
+        vector<vector<int>> dp(M, vector<int>(N, -1));
+        for (int i = 0; i < M; i++) {
+            for (int j = 0; j < N; j++) {
+                res = max(res, dfs(dp, matrix, i, j, 1));
+            }
+        }
+        return ++res;
+    }
+};
+
+inline void test() {
+    Solution solution;
+    cout << solution.longestIncreasingPath({{9, 9, 4}, {6, 6, 8}, {2, 1, 1}})
+         << endl; // 4
+    cout << solution.longestIncreasingPath({{3, 4, 5}, {3, 2, 6}, {2, 2, 1}})
+         << endl; // 4
+    cout << solution.longestIncreasingPath(
+                {{0, 0, 12, 6, 15, 1, 12, 10, 12, 10, 6},
+                 {6, 19, 6, 13, 5, 18, 17, 19, 7, 11, 13},
+                 {8, 6, 9, 1, 15, 7, 10, 10, 3, 7, 18},
+                 {2, 14, 12, 10, 17, 2, 3, 10, 4, 8, 3},
+                 {8, 2, 19, 3, 19, 10, 17, 18, 12, 10, 8},
+                 {0, 17, 14, 12, 10, 4, 8, 17, 15, 11, 19},
+                 {13, 6, 14, 8, 16, 19, 12, 17, 16, 17, 8},
+                 {7, 4, 6, 8, 3, 9, 19, 12, 4, 13, 0},
+                 {18, 0, 16, 12, 10, 11, 8, 14, 6, 3, 0},
+                 {10, 3, 14, 17, 19, 18, 10, 2, 11, 5, 19},
+                 {6, 2, 2, 1, 8, 1, 11, 7, 7, 18, 1},
+                 {11, 12, 16, 0, 9, 6, 8, 3, 12, 8, 15},
+                 {5, 18, 17, 4, 11, 9, 9, 6, 8, 2, 4},
+                 {3, 12, 7, 2, 9, 17, 14, 10, 14, 5, 0}})
+         << endl;
+}

split-array-largest-sum.h

@@ -0,0 +1,40 @@
+// https://leetcode-cn.com/problems/split-array-largest-sum/
+
+#pragma once
+
+#include <algorithm>
+#include <iostream>
+#include <numeric>
+#include <vector>
+
+using namespace std;
+
+class Solution {
+  public:
+    int splitArray(const vector<int> &nums, int m) {
+        int64_t l = *max_element(nums.begin(), nums.end()),
+                r = accumulate(nums.begin(), nums.end(), 0i64);
+        while (l < r) {
+            int64_t s = 0, c = 1;
+            const int64_t mid = (l + r) >> 1;
+            for (auto &&num : nums) {
+                s += num;
+                if (s > mid) {
+                    ++c;
+                    s = num;
+                }
+            }
+            if (c > m) {
+                l = mid + 1;
+            } else {
+                r = mid;
+            }
+        }
+        return l;
+    }
+};
+
+inline void test() {
+    Solution solution;
+    cout << solution.splitArray({7, 2, 5, 10, 8}, 2) << endl; // 18
+}

two-sum.h

@@ -0,0 +1,36 @@
+// https://leetcode-cn.com/problems/two-sum/
+
+#pragma once
+
+#include <algorithm>
+#include <iostream>
+#include <unordered_map>
+
+using namespace std;
+
+class Solution {
+  public:
+    vector<int> twoSum(const vector<int> &nums, int target) {
+        unordered_map<int, int> mp;
+        for (int i = 0; i < nums.size(); ++i) {
+            if (auto iter = mp.find(nums[i]); iter != mp.end()) {
+                return {iter->second, i};
+            }
+            mp[target - nums[i]] = i;
+        }
+
+        return {};
+    }
+};
+
+inline ostream &operator<<(ostream &os, const vector<int> &nums) {
+    for (auto &&num : nums) {
+        os << num << " ";
+    }
+    return os;
+}
+
+inline void test() {
+    Solution solution;
+    cout << solution.twoSum({2, 7, 11, 15}, 9) << endl;
+}

zui-xiao-tiao-yue-ci-shu.h

@@ -0,0 +1,31 @@
+// https://leetcode-cn.com/problems/zui-xiao-tiao-yue-ci-shu/
+
+#pragma once
+
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+class Solution {
+  public:
+    int minJump(const vector<int> &jump) {
+        const auto M = jump.size();
+        vector<int> dp(M, 0);
+        for (int i = M - 1; i >= 0; --i) {
+            dp[i] = i + jump[i] >= M ? 1 : (dp[i + jump[i]] + 1);
+            for (int j = i + 1; j < M && j < i + jump[i] && dp[j] > dp[i];
+                 ++j) {
+                dp[j] = min(dp[j], dp[i] + 1);
+            }
+        }
+
+        return dp[0];
+    }
+};
+
+inline void test() {
+    Solution solution;
+    cout << solution.minJump({2, 5, 1, 1, 1, 1}) << endl;
+}