leetcode

Author: daiwb

LeetCode/detectCycle.cpp

@@ -0,0 +1,47 @@
+#include <vector>
+#include <iostream>
+#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)
+typedef long long LL;
+
+struct ListNode {
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+class Solution {
+public:
+    ListNode *detectCycle(ListNode *head) {
+        if (head == NULL) return NULL;
+        ListNode* n1 = head;
+        ListNode* n2 = head;
+        
+        while (true) {
+            n1 = n1->next;
+            if (n1 == NULL) return NULL;
+            
+            n2 = n2->next;
+            if (n2 == NULL) return NULL;
+            n2 = n2->next;
+            if (n2 == NULL) return NULL;
+            
+            if (n1 == n2) {
+                n1 = head;
+                while (n1 != n2) {
+                    n1 = n1->next;
+                    n2 = n2->next;
+                }
+                return n1;
+            }
+        }
+    }
+};
+
+int main() {
+    return 0;
+}

LeetCode/generateMatrix.cpp

@@ -0,0 +1,31 @@
+#include <vector>
+#include <iostream>
+#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)
+typedef long long LL;
+
+int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+
+class Solution {
+public:
+    vector<vector<int> > generateMatrix(int n) {
+        vector<vector<int> > res(n, vector<int>(n, 0));
+        int x = 0, y = -1;
+        int idx = 0;
+        FOR(i,1,n*n) {
+            int tx = x + dir[idx][0], ty = y + dir[idx][1];
+            if (tx < 0 || tx >= n || ty < 0 || ty >= n || res[tx][ty] != 0) idx = (idx + 1) % 4;
+            x += dir[idx][0], y += dir[idx][1];
+            res[x][y] = i;
+        }
+        return res;
+    }
+};
+
+int main() {
+    return 0;
+}

LeetCode/generateTrees.cpp

@@ -0,0 +1,47 @@
+#include <vector>
+#include <iostream>
+#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)
+typedef long long LL;
+
+struct TreeNode {
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution {
+public:
+    vector<TreeNode *> doit(int lt, int rt) {
+        vector<TreeNode *> res;
+        if (lt > rt) {
+            res.push_back(NULL);
+            return res;
+        }
+        FOR(i,lt,rt) {
+            vector<TreeNode *> lc = doit(lt, i - 1);
+            vector<TreeNode *> rc = doit(i + 1, rt);
+            REP(j1,lc.size()) {
+                REP(j2,rc.size()) {
+                    TreeNode *t = new TreeNode(i);
+                    t->left = lc[j1];
+                    t->right = rc[j2];
+                    res.push_back(t);
+                }
+            }
+        }
+        return res;
+    }
+    vector<TreeNode *> generateTrees(int n) {
+        return doit(1, n);
+    }
+};
+
+int main() {
+    return 0;
+}

LeetCode/maxPathSum.cpp

@@ -0,0 +1,39 @@
+#include <vector>
+#include <iostream>
+#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)
+typedef long long LL;
+
+struct TreeNode {
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution {
+public:
+    int mx;
+    int doit(TreeNode *root) {
+        if (root == NULL) return 0;
+        int v = root->val;
+        int lt = max(0, doit(root->left));
+        int rt = max(0, doit(root->right));
+        mx = max(mx, v + lt + rt);
+        return v + max(lt, rt);;
+    }
+    int maxPathSum(TreeNode *root) {
+        if (root == NULL) return 0;
+        mx = root->val;
+        doit(root);
+        return mx;
+    }
+};
+
+int main() {
+    return 0;
+}

LeetCode/maxProfitII.cpp LeetCode/maxProfit2.cppLeetCode/maxProfitII.cpp renamed to LeetCode/maxProfit2.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    bool search(int A[], int n, int target) {
+        int lt = 0, rt = n - 1;
+        while (lt <= rt) {
+            int mt = (lt + rt) / 2;
+            if (A[mt] == target) return true;
+            if (A[lt] < A[mt]) {
+                if (A[lt] <= target && target < A[mt]) rt = mt - 1;
+                else lt = mt + 1;
+            } else if (A[lt] > A[mt]) {
+                if (A[mt] < target && target <= A[rt]) lt = mt + 1;
+                else rt = mt - 1;
+            } else ++lt;
+        }
+        return false;
+    }
+};