Add 18 more.

iphkwan · iphkwan · commit c946bb141a18 · 2013-07-07T23:44:23.000+08:00
diff --git a/Decode_Ways.cc b/Decode_Ways.cc
@@ -0,0 +1,26 @@
+class Solution {
+public:
+    int numDecodings(string s) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        int len  = s.length();
+        if (len == 0 || s[0] == '0') {
+            return 0;
+        }
+        vector<int> dp;
+        for (int i = 0; i <= len; i++) {
+            dp.push_back(0);
+        }
+        dp[1] = dp[0] = 1;
+        for (int i = 2; i <= len; i++) {
+            if (s[i - 1] != '0') {
+                dp[i] += dp[i - 1];
+            }
+            int num = (s[i - 2] - '0') * 10 + (s[i - 1] - '0');
+            if (num >= 10 && num <= 26) {
+                dp[i] += dp[i - 2];
+            }
+        }
+        return dp[len];
+    }
+};
diff --git a/Gray_Code.cc b/Gray_Code.cc
@@ -0,0 +1,15 @@
+class Solution
+{
+public:
+    /*
+     * for reference: http://en.wikipedia.org/wiki/Gray_code.
+     */
+    vector<int> grayCode (int n) {
+        vector<int> ret;
+        int size = 1 << n;
+        for (int i = 0; i < size; i++) {
+            ret.push_back((i >> 1) ^ i);
+        }
+        return ret;
+    }
+};
diff --git a/Largest_Rectangle_in_Histogram.cc b/Largest_Rectangle_in_Histogram.cc
@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int largestRectangleArea(vector<int> &height) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        int len = height.size();
+        if (len == 0) {
+            return 0;
+        }
+        stack<int> st;
+        int ans = 0, curHeight, width;
+        for (int i = 0; i < len; i++) {
+            while (!st.empty() && height[st.top()] >= height[i]) {
+                curHeight = height[st.top()];
+                st.pop();
+                width = (st.empty() ? i : i - st.top() - 1);
+                ans = max(ans, curHeight * width);
+            }
+            st.push(i);
+        }
+        while (!st.empty()) {
+            curHeight = height[st.top()];
+            st.pop();
+            width = (st.empty() ? len : len - st.top() - 1);
+            ans = max(ans, curHeight * width); 
+        }
+        return ans;
+    }
+};
diff --git a/Maximal_Rectangle.cc b/Maximal_Rectangle.cc
@@ -0,0 +1,40 @@
+class Solution {
+public:
+    int maximalRectangle(vector<vector<char> > &matrix) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        if (matrix.size() == 0) {
+            return 0;
+        }
+        vector<vector<int> > dp;
+        vector<int> tmp;
+        for (int i = 0; i < matrix[0].size(); i++) {
+            tmp.push_back(0);
+        }
+        for (int i = 0; i < matrix.size(); i++) {
+            dp.push_back(tmp);
+            if (matrix[i][0] == '1') {
+                dp[i][0] = 1;
+            }
+            for (int j = 1; j < matrix[i].size(); j++) {
+                if (matrix[i][j] == '1') {
+                    dp[i][j] = dp[i][j - 1] + 1;
+                }
+            }
+        }
+        int ans = 0;
+        for (int i = 0; i < matrix.size(); i++) {
+            for (int j = 0; j < matrix[i].size(); j++) {
+                int width = matrix[i].size();
+                for (int k = i; k >= 0; k--) {
+                    if (dp[k][j] == 0) {
+                        break;
+                    }
+                    width = min(width, dp[k][j]);
+                    ans = max(ans, width * (i - k + 1));
+                }
+            }
+        }
+        return ans;
+    }
+};
diff --git a/Partition_List.cc b/Partition_List.cc
@@ -0,0 +1,38 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *partition(ListNode *head, int x) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        ListNode *entry = NULL;
+        ListNode *pHead = NULL;
+        ListNode *pTail = NULL;
+        for (ListNode **pCnt = &head; *pCnt != NULL; ) {
+            entry = *pCnt;
+            if (entry->val < x) {
+                *pCnt = entry->next;
+                if (pHead == NULL) {
+                    pHead = entry;
+                    pTail = entry;
+                } else {
+                    pTail->next = entry;
+                    pTail = pTail->next;
+                }
+            } else {
+                pCnt = &(entry->next);
+            }
+        }
+        if (pTail != NULL) {
+            pTail->next = head;
+            return pHead;
+        }
+        return head;
+    }
+};
diff --git a/README.md b/README.md
@@ -3,4 +3,4 @@ leetcode
 
 No voice but big deal.
 
-> 39 / 132
+> 57 / 132
diff --git a/Remove_Duplicates_from_Sorted_Array.cc b/Remove_Duplicates_from_Sorted_Array.cc
@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int removeDuplicates(int A[], int n) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        if (n == 0) {
+            return 0;
+        }
+        int pos = 0;
+        for (int i = 1; i < n; i++) {
+            if (A[i] != A[pos]) {
+                A[++pos] = A[i];
+            }
+        }
+        return pos + 1;
+    }
+};
diff --git a/Remove_Duplicates_from_Sorted_Array_II.cc b/Remove_Duplicates_from_Sorted_Array_II.cc
@@ -0,0 +1,34 @@
+class Solution {
+public:
+    int removeDuplicates(int A[], int n) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        if (n == 0) {
+            return 0;
+        }
+        int cur_num = A[0], cur_count = 1, ans = 0, pos = 0;
+        for (int i = 1; i < n; i++) {
+            while (i < n && A[i] == cur_num) {
+                i++;
+                cur_count++;
+            }
+            cur_count = min(cur_count, 2);
+            ans += cur_count;
+            while (cur_count--) {
+                A[pos++] = cur_num;
+            }
+            if (i < n) {
+                cur_num = A[i];
+                cur_count = 1;
+            } else {
+                cur_count = 0;
+            }
+        }
+        cur_count = min(cur_count, 2);
+        ans += cur_count;
+        while (cur_count--) {
+            A[pos++] = cur_num;
+        }
+        return ans;
+    }
+};
diff --git a/Remove_Duplicates_from_Sorted_List.cc b/Remove_Duplicates_from_Sorted_List.cc
@@ -0,0 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *deleteDuplicates(ListNode *head) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        ListNode **pCur = &head;
+        ListNode *pPre = NULL;
+        ListNode *entry = NULL;
+        while (*pCur != NULL) {
+            entry = *pCur;
+            if (pPre != NULL && pPre->val == entry->val) {
+                *pCur = entry->next;
+                delete entry;
+                entry = NULL;
+            } else {
+                pCur = &(entry->next);
+                pPre = entry;
+            }
+        }
+        return head;
+    }
+};
diff --git a/Remove_Duplicates_from_Sorted_List_II.cc b/Remove_Duplicates_from_Sorted_List_II.cc
@@ -0,0 +1,43 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *deleteDuplicates(ListNode *head) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        ListNode **pCur = &head;
+        ListNode **helper = pCur;
+        ListNode *entry = NULL;
+        ListNode *dummy = NULL;
+        bool flag;
+        while (*pCur != NULL) {
+            entry = *pCur;
+            flag = false;
+            helper = &(entry->next);
+            while (*helper != NULL) {
+                dummy = *helper;
+                if (dummy->val != entry->val) {
+                    break;
+                }
+                flag = true;
+                *helper = dummy->next;
+                delete dummy;
+                dummy = NULL;
+            }
+            if (flag) {
+                *pCur = entry->next;
+                delete entry;
+                entry = NULL;
+            } else {
+                pCur = &(entry->next);
+            }
+        }
+        return head;
+    }
+};
diff --git a/Restore_IP_Addresses.cc b/Restore_IP_Addresses.cc
@@ -0,0 +1,63 @@
+class Solution {
+public:
+    bool judge(string &s, int st) {
+        int num = 0;
+        for (int i = 0; i < 3; i++) {
+            num = num * 10 + (s[st + i] - '0');
+        }
+        if (num >= 0 && num <= 255) {
+            return true;
+        }
+        return false;
+    }
+    vector<string> restoreIpAddresses(string s) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        vector<string> ans;
+        int len = s.length(), slen;
+        if (len < 4 || len > 12) {
+            return ans;
+        }
+        for (int i = 1; i <= 3; i++) {
+            if (i >= 2 && s[0] == '0') {
+                break;
+            }
+            if (i == 3 && judge(s, 0) == false) {
+                break;
+            }
+            for (int j = 1; j <=3 && i + j < len; j++) {
+                if (j >= 2 && s[i] == '0') {
+                    break;
+                }
+                if (j == 3 && judge(s, i) == false) {
+                    break;
+                }
+                for (int k = 1; k <= 3 && i + j + k < len; k++) {
+                    if (k >= 2 && s[i + j] == '0') {
+                        break;
+                    }
+                    if (k == 3 && judge(s, i + j) == false) {
+                        break;
+                    }
+                    slen = len - i - j - k;
+                    if (slen > 3 || (slen == 3 && judge(s, i + j + k) == false)) {
+                        continue;
+                    }
+                    if (slen >= 2 && s[i + j + k] == '0') {
+                        continue;
+                    }
+                    string tmp = "";
+                    tmp += s.substr(0, i);
+                    tmp += '.';
+                    tmp += s.substr(i, j);
+                    tmp += '.';
+                    tmp += s.substr(i + j, k);
+                    tmp += '.';
+                    tmp += s.substr(i + j + k, slen);
+                    ans.push_back(tmp);
+                }
+            }
+        }
+        return ans;
+    }
+};
diff --git a/Reverse_Linked_List_II.cc b/Reverse_Linked_List_II.cc
@@ -0,0 +1,35 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *reverseBetween(ListNode *head, int m, int n) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        int len = n - m + 1;
+        if (len <= 1) {
+            return head;
+        }
+        ListNode **ppHead = &head;
+        for (int i = 1; i < m; i++) {
+             ppHead = &((*ppHead)->next);
+        }
+        ListNode *pCur = *ppHead;
+        ListNode *pPre = NULL;
+        ListNode *pNxt = NULL;
+        while (len--) {
+            pNxt = pCur->next;
+            pCur->next = pPre;
+            pPre = pCur;
+            pCur = pNxt;
+        }
+        (*ppHead)->next = pCur;
+        *ppHead = pPre;
+        return head;
+    }
+};
diff --git a/Scramble_String.cc b/Scramble_String.cc
diff --git a/Search_in_Rotated_Sorted_Array.cc b/Search_in_Rotated_Sorted_Array.cc
diff --git a/Search_in_Rotated_Sorted_Array_II.cc b/Search_in_Rotated_Sorted_Array_II.cc
diff --git a/Subsets.cc b/Subsets.cc
diff --git a/Subsets_II.cc b/Subsets_II.cc
diff --git a/Word_Search.cc b/Word_Search.cc

Original file line number	Diff line number	Diff line change
`@@ -3,4 +3,4 @@ leetcode`
`3`	`3`
`4`	`4`	`No voice but big deal.`
`5`	`5`
`6`		`-> 39 / 132`
	`6`	`+> 57 / 132`