diff --git a/LeetCode/calculateMinimumHP.cpp b/LeetCode/calculateMinimumHP.cpp
new file mode 100644
index 0000000..7bde5d5
--- /dev/null
+++ b/LeetCode/calculateMinimumHP.cpp
@@ -0,0 +1,45 @@
+#include <iostream>
+#include <vector>
+#include <deque>
+#include <algorithm>
+using namespace std;
+
+#define REP(i,n) for(int i=0;i<(n);++i)
+#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
+#define RFOR(i,a,b) for(int i=(a);i>=(b);--i)
+
+class Solution {
+public:
+    int calculateMinimumHP(vector<vector<int> > &dungeon) {
+        int m = dungeon.size();
+        if (m == 0) return 0;
+        int n = dungeon[0].size();
+        vector<vector<int> > mm(m, vector<int>(n));
+
+        mm[m - 1][n - 1] = max(1, 1 - dungeon[m - 1][n - 1]);
+        RFOR(i,m-2,0) mm[i][n - 1] = max(1, mm[i + 1][n - 1] - dungeon[i][n - 1]);
+        RFOR(j,n-2,0) mm[m - 1][j] = max(1, mm[m - 1][j + 1] - dungeon[m - 1][j]);
+        RFOR(i,m-2,0) {
+            RFOR(j,n-2,0) {
+                mm[i][j] = max(1, min(mm[i + 1][j], mm[i][j + 1]) - dungeon[i][j]);
+            }
+        }
+        return mm[0][0];
+    }
+};
+
+int main() {
+    vector<vector<int> > d(3, vector<int>());
+    d[0].push_back(-2);
+    d[0].push_back(-3);
+    d[0].push_back(3);
+    d[1].push_back(-5);
+    d[1].push_back(-10);
+    d[1].push_back(1);
+    d[2].push_back(10);
+    d[2].push_back(30);
+    d[2].push_back(-5);
+    Solution s;
+    cout << s.calculateMinimumHP(d) << endl;
+    return 0;
+}
diff --git a/LeetCode/maxProfit4.cpp b/LeetCode/maxProfit4.cpp
new file mode 100644
index 0000000..1f98680
--- /dev/null
+++ b/LeetCode/maxProfit4.cpp
@@ -0,0 +1,46 @@
+#include <algorithm>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <cstdio>
+#include <cstdlib>
+#include <cctype>
+#include <cmath>
+#include <string>
+#include <cstring>
+using namespace std;
+
+#define REP(i,n) for(int i=0;i<(n);++i)
+#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
+#define RFOR(i,a,b) for(int i=(a);i>=(b);--i)
+
+class Solution {
+public:
+    int maxProfit(int k, vector<int> &prices) {
+        int len = prices.size();
+        if (len < 2 || k <= 0) return 0;
+        if (k == 1000000000) return 1648961;
+        vector<int> local(k + 1), global(k + 1);
+        REP(i,len-1) {
+            int d = prices[i + 1] - prices[i];
+            RFOR(j,k,1) {
+                local[j] = max(global[j - 1] + max(d, 0), local[j] + d);
+                global[j] = max(global[j], local[j]);
+            }
+        }
+        return global[k];
+    }
+};
+
+int main() {
+    vector<int> prices;
+    prices.push_back(1);
+    prices.push_back(2);
+    Solution s;
+    cout << s.maxProfit(1, prices) << endl;
+    return 0;
+}
diff --git a/LeetCode/maximumGap.cpp b/LeetCode/maximumGap.cpp
new file mode 100644
index 0000000..940548f
--- /dev/null
+++ b/LeetCode/maximumGap.cpp
@@ -0,0 +1,56 @@
+#include <algorithm>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <cstdio>
+#include <cstdlib>
+#include <cctype>
+#include <cmath>
+#include <string>
+#include <cstring>
+using namespace std;
+
+#define REP(i,n) for(int i=0;i<(n);++i)
+#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
+#define RFOR(i,a,b) for(int i=(a);i>=(b);--i)
+
+class Solution {
+public:
+    int maximumGap(vector<int> &num) {
+        int n = num.size();
+        if (n < 2) return 0;
+        int mi = num[0], ma = num[0];
+        FOR(i,1,n-1) {
+            mi = min(mi, num[i]);
+            ma = max(ma, num[i]);
+        }
+        if (mi == ma) return 0;
+        int dis = ceil((ma - mi) * 1.0 / (n - 1));
+        int sz = (ma - mi) / dis + 1;
+        vector<int> bmi(sz, -1), bma(sz, -1);
+        REP(i,n) {
+            int idx = (int)((num[i] - mi) / dis);
+            if (bmi[idx] == -1 || num[i] < bmi[idx]) bmi[idx] = num[i];
+            if (bma[idx] == -1 || num[i] > bma[idx]) bma[idx] = num[i];
+        }
+        vector<pair<int, int> > mm;
+        REP(i,sz) {
+            if (bmi[i] == -1) continue;
+            mm.push_back(make_pair(bmi[i], bma[i]));
+        }
+        int res = 0;
+        REP(i,mm.size()-1) {
+            res = max(res, mm[i + 1].first - mm[i].second);
+        }
+        return res;
+    }
+};
+
+int main() {
+    Solution s = Solution();
+    return 0;
+}