add 70-75

Author: suifengls

ConvertSortedListtoBinarySearchTree.cpp

@@ -0,0 +1,48 @@
+/*
+  Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.
+*/
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+  TreeNode *sortedListToBST(ListNode *head) {
+    if(!head)
+      return NULL;
+    int len = 0;
+    ListNode *node = head;
+    while(node)
+      {
+	node = node->next;
+	++len;
+      }
+    return buildHelper(head, 0, len-1);
+  }
+  TreeNode *buildHelper(ListNode *&head, int st, int ed)
+  {
+    if(st > ed)
+      return NULL;
+    int mid = (st+ed)/2;
+    TreeNode *left = buildHelper(head, st, mid-1);
+    TreeNode *root = new TreeNode(head->val);
+    head = head->next;
+    TreeNode *right = buildHelper(head, mid+1, ed);
+    root->left = left;
+    root->right = right;
+    return root;
+  }
+};

FlattenBinaryTreetoLinkedList.cpp

@@ -0,0 +1,68 @@
+/*
+  Given a binary tree, flatten it to a linked list in-place.
+  
+  For example,
+  Given
+
+         1
+        / \
+       2   5
+      / \   \
+     3   4   6
+  The flattened tree should look like:
+   1
+    \
+     2
+      \
+       3
+        \
+         4
+          \
+           5
+            \
+             6
+  click to show hints.
+
+  Hints:
+  If you notice carefully in the flattened tree, each node's right child points to the next node of a pre-order traversal.
+*/
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+  void flatten(TreeNode *root) {
+    if(!root)
+      return;
+    flattenHelper(root);
+  }
+  TreeNode *flattenHelper(TreeNode *root)
+  {
+    if(!root->left && !root->right)
+      return root;
+    TreeNode *rhead = NULL;
+    if(root->right)
+      rhead = flattenHelper(root->right);
+    TreeNode *ltail = root;
+    if(root->left)
+      {
+	TreeNode *lhead = flattenHelper(root->left);
+	root->left = NULL;
+	root->right = lhead;
+	while(ltail->right)
+	  ltail = ltail->right;
+      }
+    if(rhead)
+      {
+	ltail->right = rhead;
+	rhead->left = NULL;
+      }
+    return root;
+  }
+};

LongestConsecutiveSequence.cpp

@@ -0,0 +1,39 @@
+/*
+  Given an unsorted array of integers, find the length of the longest consecutive elements sequence.
+
+  For example,
+  Given [100, 4, 200, 1, 3, 2],
+  The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.
+  
+  Your algorithm should run in O(n) complexity.
+*/
+
+class Solution {
+public:
+  int longestConsecutive(vector<int> &num) {
+    unordered_set<int> hashset;
+    for(int i = 0; i < num.size(); ++i)
+      hashset.insert(num[i]);
+    int maxlen = 1;
+    for(int i = 0; i < num.size(); ++i)
+      {
+	int inc = num[i];
+	int des = num[i];
+	int len = 1;
+	if(hashset.find(num[i]) == hashset.end())
+	  continue;
+	while(hashset.find(inc+1) != hashset.end())
+	  {
+	    ++len;
+	    hashset.erase(++inc);
+	  }
+	while(hashset.find(des-1) != hashset.end())
+	  {
+	    ++len;
+	    hashset.erase(--des);
+	  }
+	maxlen = max(maxlen, len);
+      }
+    return maxlen;
+  }
+};

PalindromePartitioningII.cpp

@@ -0,0 +1,34 @@
+/*
+  Given a string s, partition s such that every substring of the partition is a palindrome.
+
+  Return the minimum cuts needed for a palindrome partitioning of s.
+  
+  For example, given s = "aab",
+  Return 1 since the palindrome partitioning ["aa","b"] could be produced using 1 cut.
+*/
+
+class Solution {
+public:
+  int minCut(string s) {
+    int n = s.size();
+    bool palin[n][n];
+    int cut[n+1];
+    for(int i = 0; i < n; ++i)
+      for(int j = 0; j < n; ++j)
+	palin[i][j] = false;
+    for(int i = 0; i <= n; ++i)
+      cut[i] = n-i-1;
+    for(int i = n-1; i >= 0; --i)
+      {
+	for(int j = i; j < n; ++j)
+	  {
+	    if(s[i] == s[j] && (j-i < 2 || palin[i+1][j-1]))
+	      {
+		palin[i][j] = true;
+		cut[i] = min(cut[i], cut[j+1]+1);
+	      }
+	  }
+      }
+    return cut[0];
+  }
+};

PathSum.cpp

@@ -0,0 +1,44 @@
+/*
+  Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.
+  
+  For example:
+  Given the below binary tree and sum = 22,
+              5
+             / \
+            4   8
+           /   / \
+          11  13  4
+         /  \      \
+        7    2      1
+  return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.
+*/
+
+  /**
+  * Definition for binary tree
+  * struct TreeNode {
+  *     int val;
+  *     TreeNode *left;
+  *     TreeNode *right;
+  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+  * };
+  */
+class Solution {
+public:
+  bool hasPathSum(TreeNode *root, int sum) {
+    if(!root)
+      return false;
+    return pathHelper(root, sum);
+  }
+  bool pathHelper(TreeNode *root, int sum)
+  {
+    if(!root)
+      return false;
+    else
+      {
+	sum -= root->val;
+	if(sum == 0 && !root->left && !root->right)
+	  return true;
+      }
+    return pathHelper(root->left, sum) || pathHelper(root->right, sum);
+  }
+};

PopulatingNextRightPointersinEachNode.cpp

@@ -0,0 +1,51 @@
+/*
+  Given a binary tree
+
+    struct TreeLinkNode {
+      TreeLinkNode *left;
+      TreeLinkNode *right;
+      TreeLinkNode *next;
+    }
+  Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.
+
+  Initially, all next pointers are set to NULL.
+  
+  Note:
+
+  You may only use constant extra space.
+  You may assume that it is a perfect binary tree (ie, all leaves are at the same level, and every parent has two children).
+  For example,
+  Given the following perfect binary tree,
+        1
+       /  \
+      2    3
+     / \  / \
+    4  5  6  7
+  After calling your function, the tree should look like:
+         1 -> NULL
+       /  \
+      2 -> 3 -> NULL
+     / \  / \
+    4->5->6->7 -> NULL
+*/
+
+/**
+ * Definition for binary tree with next pointer.
+ * struct TreeLinkNode {
+ *  int val;
+ *  TreeLinkNode *left, *right, *next;
+ *  TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+  void connect(TreeLinkNode *root) {
+    if(!root || (!root->left && !root->right))
+      return;
+    root->left->next = root->right;
+    if(root->next)
+      root->right->next = root->next->left;
+    connect(root->left);
+    connect(root->right);
+  }
+};

README.md

@@ -324,3 +324,27 @@ Solve problems in LeetCode http://oj.leetcode.com/.
 
     	  Recursive call. Middle element is current root.
 
+70. Convert Sorted List to Binary Search Tree
+
+    	  Recursive call. Helper(ListNode *&head, ...) beacuse we need to move head to its next in each recursive call.
+	  After left = helper(head, ...), head now points to middle node, which is the current root.
+
+71. Path Sum
+
+    	 Recursive call. sum -= root->val. If at one leaf, sum == 0. return true.
+
+72. Flatten Binary Tree to Linked List
+
+    	 Flatten right subtree, then left subtree recursively. Then attach right subtree to the end of the left subtree.
+
+73. Longest Consecutive Sequence
+
+    	 Use hashset to store each element. When iterate one element, find the increasing & decreasing order, and erase these numbers.
+
+74. Surrounded Regions
+
+    	 DFS or BFS. Check boundary.
+
+75. Palindrome Partitioning II
+
+    	 DP. Use a 2D array ispalin[i][j] (true, if string(i to j) is parlinfrom). cut[i] = min(cut[i], cut[j+1]+1).

SurroundedRegions.cpp

@@ -0,0 +1,53 @@
+/*
+  Given a 2D board containing 'X' and 'O', capture all regions surrounded by 'X'.
+
+  A region is captured by flipping all 'O's into 'X's in that surrounded region .
+  
+  For example,
+   X X X X
+   X O O X
+   X X O X
+   X O X X
+  After running your function, the board should be:
+   X X X X
+   X X X X
+   X X X X
+   X O X X
+*/
+
+class Solution {
+public:
+  void solve(vector<vector<char>> &board) {
+    if(board.empty())
+      return;
+    int m = board.size(), n = board[0].size();
+    for(int i = 0; i < m; ++i)
+      for(int j = 0; j < n; ++j)
+	if(i == 0 || i == m-1 || j == 0 || j == n-1)
+	  bfs(board, i, j, m, n);
+    for(int i = 0; i < m; ++i)
+      for(int j = 0; j < n; ++j)
+	board[i][j] = (board[i][j] == 'P') ? 'O' : 'X';
+  }
+  void bfs(vector<vector<char>> &board, int x, int y, int m, int n)
+  {
+    if(board[x][y] != 'O')
+      return;
+    queue<pair<int, int>> q;
+    q.push(make_pair(x, y));
+    while(!q.empty())
+      {
+	int i = q.front().first, j = q.front().second;
+	q.pop();
+	if(i < 0 || i >= m || j < 0 || j >= n)
+	  continue;
+	if(board[i][j] != 'O')
+	  continue;
+	board[i][j] = 'P';
+	q.push(make_pair(i-1, j));
+	q.push(make_pair(i+1, j));
+	q.push(make_pair(i, j-1));
+	q.push(make_pair(i, j+1));
+      }
+  }
+};