add 31-34

Author: suifengls

BinaryTreeLevelOrderTraversal.cpp

@@ -0,0 +1,64 @@
+/*
+  Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).
+  
+  For example:
+  Given binary tree {3,9,20,#,#,15,7},
+          3
+         / \
+        9  20
+	  /  \
+	 15   7
+  return its level order traversal as:
+  [
+   [3],
+   [9,20],
+   [15,7]
+  ]
+*/
+
+  /**
+  * Definition for binary tree
+  * struct TreeNode {
+  *     int val;
+  *     TreeNode *left;
+  *     TreeNode *right;
+  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+  * };
+  */
+class Solution {
+public:
+    vector<vector<int> > levelOrder(TreeNode *root) {
+	vector<vector<int> > orders;
+	if(!root)
+	    return orders;
+	queue<TreeNode *> level;
+	vector<int> lv;
+	level.push(root);
+	int count = 1, ncount = 0;
+	while(!level.empty())
+	{
+	    TreeNode *node = level.front();
+	    level.pop();
+	    lv.push_back(node->val);
+	    --count;
+	    if(node->left)
+	    {
+		++ncount;
+		level.push(node->left);
+	    }
+	    if(node->right)
+	    {
+		++ncount;
+		level.push(node->right);
+	    }
+	    if(count == 0)
+	    {
+		orders.push_back(lv);
+		lv.clear();
+		count = ncount;
+		ncount = 0;
+	    }
+	}
+	return orders;
+    }
+};

DecodeWays.cpp

@@ -0,0 +1,32 @@
+/*
+  A message containing letters from A-Z is being encoded to numbers using the following mapping:
+  
+  'A' -> 1
+  'B' -> 2
+  ...
+  'Z' -> 26
+  Given an encoded message containing digits, determine the total number of ways to decode it.
+  
+  For example,
+  Given encoded message "12", it could be decoded as "AB" (1 2) or "L" (12).
+  
+  The number of ways decoding "12" is 2.
+*/
+class Solution {
+public:
+    int numDecodings(string s) {
+	if(s.empty() || s == "0")
+	    return 0;
+	vector<int> ways(s.size()+1, 1);
+	for(int i = s.size()-1; i >= 0; --i)
+	{
+	    if(s[i] == '0')
+		ways[i] = 0;
+	    else
+		ways[i] = ways[i+1];
+	    if(i+1 < s.size() && ((s[i] == '1') || (s[i] == '2' && s[i+1] - '0' <= 6)))
+		ways[i] += ways[i+2];
+	}
+	return ways[0];
+    }
+};

README.md

@@ -15,7 +15,7 @@ Solve problems in LeetCode http://oj.leetcode.com/.
 
        Use long long to make sure the string can be converted, then check whether it exceeds INT_MAX/INT_MIN.
 
-3. 3 Sum
+**3. 3 Sum**
 
        Size of vector >= 3
 
@@ -31,7 +31,7 @@ Solve problems in LeetCode http://oj.leetcode.com/.
 
        Use a dummy node, link the next to the new Listnode with the smaller value, then return dummy->next.
 
-6. Implement strStr()
+**6. Implement strStr()**
 
        Use char* directly to compare.
 
@@ -51,15 +51,15 @@ Solve problems in LeetCode http://oj.leetcode.com/.
 
    	Two pointers, one faster, one slow, then meet together or meet NULL.
 
-10. Insert Interval
+**10. Insert Interval**
 
     	Usefull of vector insert() and erase().
 
 	Insert: inserting new elements before the element at the specified position.	
 
 	Erase return value: An iterator pointing to the new location of the element that followed the last element erased by the function call. 
 
-11. Valid Number
+**11. Valid Number**
 
     	Too many different cases to handle.
 
@@ -89,11 +89,11 @@ Solve problems in LeetCode http://oj.leetcode.com/.
 
     	Recursive Problem. Left nodes should locate in [min, parent->val], right nodes should locate in [parent->val, max].
 
-16. Valid Palindrome
+**16. Valid Palindrome**
 
     	isalnum(c): Checks whether c is either a decimal digit or an uppercase or lowercase letter.
 
-17. Word Ladder
+**17. Word Ladder**
 
     	Graph BFS problem. Use a queue and a visited array for BFS without constructing the graph.
 
@@ -103,7 +103,7 @@ Solve problems in LeetCode http://oj.leetcode.com/.
 
 	Stop condition: while(l1 || l2 || carry)
 
-19. Integer to Roman
+**19. Integer to Roman**
 
     	Left(-) and right(+) for 5s and 10s.
 
@@ -121,7 +121,7 @@ Solve problems in LeetCode http://oj.leetcode.com/.
 
     	Make sure number of left parentheses is not smaller than number of right parentheses.
 
-23. Merge k Sorted Lists
+**23. Merge k Sorted Lists**
 
     	Call the Merge Tow Sorted Lists k times, you are done!
 
@@ -150,10 +150,30 @@ Solve problems in LeetCode http://oj.leetcode.com/.
 
     	Similar to Add Two Numbers. Use string instead of linked list.
 
-29. Sqrt(x)
+**29. Sqrt(x)**
 
 	Binary search method. Be careful about overflow, using long long.
 
 30. Combinations
 
 	DFS. In position k, iterative through k+1 to n.
+
+31. Subsets
+
+	DFS. Similar to Combinations, but stores all subsets into result.
+
+**32. Word Search**
+
+    	DFS. If current char match the word, traversal its four directions. Use a visited[][] to mark visited or not.
+
+	Put the check into a function for a better structure of code.
+
+**33. Decode Ways**
+
+      	Dynamic problem. Similar to Climbing Stairs, with some limitations.
+
+	dp[i] = dp[i-1] + dp[i-2], add dp[i-2] if two char can be put together. 
+34. Binary Tree Level Order Traversal
+
+    	Use a queue to store the children nodes of current level.
+

Subsets.cpp

@@ -0,0 +1,41 @@
+/*
+  Given a set of distinct integers, S, return all possible subsets.
+
+  Note:
+  Elements in a subset must be in non-descending order.
+  The solution set must not contain duplicate subsets.
+  For example,
+  If S = [1,2,3], a solution is:
+
+  [
+    [3],
+    [1],
+    [2],
+    [1,2,3],
+    [1,3],
+    [2,3],
+    [1,2],
+    []
+  ]
+*/
+
+class Solution {
+public:
+    vector<vector<int> > subsets(vector<int> &S) {
+	vector<vector<int> > result;
+	vector<int> sets;
+	sort(S.begin(), S.end());
+	setHelper(S, result, sets, 0);
+	return result;
+    }
+    void setHelper(vector<int> &S, vector<vector<int> > &result, vector<int> &sets, int k)
+        {
+	    result.push_back(sets);
+	    for(int i = k; i < S.size(); ++i)
+	    {
+		sets.push_back(S[i]);
+		setHelper(S, result, sets, i+1);
+		sets.pop_back();
+	    }
+	}
+};

WordSearch.cpp

@@ -0,0 +1,53 @@
+/*
+  Given a 2D board and a word, find if the word exists in the grid.
+
+  The word can be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.
+
+  For example,
+  Given board =
+
+  [
+    ["ABCE"],
+    ["SFCS"],
+    ["ADEE"]
+  ]
+  word = "ABCCED", -> returns true,
+  word = "SEE", -> returns true,
+  word = "ABCB", -> returns false.
+*/
+class Solution {
+public:
+    bool exist(vector<vector<char> > &board, string word) {
+	if(word.empty())
+	    return true;
+	if(board.empty())
+	    return false;
+	int m = board.size(), n = board[0].size();
+	vector<vector<bool> > visited(m, vector<bool>(n, false));
+	for(int i = 0; i < m; ++i)
+	    for(int j = 0; j < n; ++j)
+		if(searchHelper(board, visited, word, 0, i, j))
+		    return true;
+	return false;
+    }
+    bool searchHelper(vector<vector<char> > &board, vector<vector<bool> > &visited, string word, int l, int i, int j)
+        {
+	    if(word.size() == l)
+		return true;
+	    if(i < 0 || i >= board.size() || j < 0 || j >= board[0].size())
+		return false;
+	    if(board[i][j] != word[l] || visited[i][j])
+		return false;
+	    visited[i][j] = true;
+	    if(searchHelper(board, visited, word, l+1, i-1, j))
+		return true;
+	    if(searchHelper(board, visited, word, l+1, i+1, j))
+		return true;
+	    if(searchHelper(board, visited, word, l+1, i, j-1))
+		return true;
+	    if(searchHelper(board, visited, word, l+1, i, j+1))
+		return true;
+	    visited[i][j] = false;
+	    return false;
+	}
+};