add 13-17

Author: suifengls

ClimbingStairs.cpp

@@ -0,0 +1,19 @@
+/*
+  You are climbing a stair case. It takes n steps to reach to the top.
+  
+  Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
+*/
+
+class Solution {
+public:
+    int climbStairs(int n) {
+	if(n < 1)
+	    return 0;
+	int dp[n];
+	dp[0] = 1; // first stair
+	dp[1] = 2; // second stair
+	for(int i = 2; i < n; ++i)
+	    dp[i] = dp[i-1] + dp[i-2];
+	return dp[n-1];
+    }
+};

MergeSortedArray.cpp

@@ -0,0 +1,34 @@
+/*
+  Given two sorted integer arrays A and B, merge B into A as one sorted array.
+  
+  Note:
+  You may assume that A has enough space to hold additional elements from B. The number of elements initialized in A and B are m and n respectively.
+*/
+
+class Solution {
+public:
+    void merge(int A[], int m, int B[], int n) {
+	int k = m + n - 1;
+	while(m > 0 && n > 0)
+	{
+	    if(A[m-1] > B[n-1])
+	    {
+		A[k] = A[m-1];
+		--m;
+	    }
+	    else
+	    {
+		A[k] = B[n-1];
+		--n;
+	    }
+	    --k;
+	}
+	while(n > 0)
+	{
+	    A[k] = B[n-1];
+	    --k;
+	    --n;
+	}
+	return;
+    }
+};

README.md

@@ -71,4 +71,25 @@ Solve problems in LeetCode http://oj.leetcode.com/.
 
 	Use FINITE AUTOMATA: How to construct the state transition graph correctly?
 
-	Reference: http://discuss.leetcode.com/questions/241/valid-number/768
+	Reference: http://discuss.leetcode.com/questions/241/valid-number/768
+
+12. Clibming Stairs
+
+    	You have two choices, 1 step or 2 steps, dp[i] = dp[i-1] + dp[i-2].
+
+13. Set Matrix Zeroes
+
+    	Save row and column index firstly, then set 0s according to the index we saved.
+
+14. Merge Sorted Array
+
+    	Backward to stoer the larger number from A and B. Only move the rest numbers in B to A if B has numbers left after A has been moved.
+
+15. Valid Palindrome
+
+    	isalnum(c): Checks whether c is either a decimal digit or an uppercase or lowercase letter.
+
+16. Word Ladder
+
+    	Graph BFS problem. Use a queue and a visited array for BFS without constructing the graph.
+

SetMatrixZeroes.cpp

@@ -0,0 +1,31 @@
+/*
+  Given a m x n matrix, if an element is 0, set its entire row and column to 0. Do it in place.
+  
+  Follow up:
+  Did you use extra space?
+  A straight forward solution using O(mn) space is probably a bad idea.
+  A simple improvement uses O(m + n) space, but still not the best solution.
+  Could you devise a constant space solution?
+*/
+
+class Solution {
+public:
+    void setZeroes(vector<vector<int> > &matrix) {
+	if(matrix.empty())
+	    return;
+	int m = matrix.size(), n = matrix[0].size();
+	vector<bool> row(m, false), col(n, false);
+	for(int i = 0; i < m; ++i)
+	    for(int j = 0; j < n; ++j)
+		if(matrix[i][j] == 0)
+		{
+		    row[i] = true;
+		    col[j] = true;
+		}
+	for(int i = 0; i < m; ++i)
+	    for(int j = 0; j < n; ++j)
+		if(row[i] || col[j])
+		    matrix[i][j] = 0;
+	return;
+    }
+};

ValidPalindrome.cpp

@@ -0,0 +1,50 @@
+/*
+  Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.
+
+  For example,
+  "A man, a plan, a canal: Panama" is a palindrome.
+  "race a car" is not a palindrome.
+  
+  Note:
+  Have you consider that the string might be empty? This is a good question to ask during an interview.
+  
+  For the purpose of this problem, we define empty string as valid palindrome.
+*/
+
+class Solution {
+public:
+    bool isPalindrome1(string s) {
+	if(s.empty())
+	    return true;
+	int l = 0, r = s.size()-1;
+	while(l < r)
+	{
+	    while(l < r && (!isalpha(s[l]) && !isdigit(s[l])))
+		++l;
+	    while(l < r && (!isalpha(s[r]) && !isdigit(s[r])))
+		--r;
+	    if(l >= r)
+		return true;
+	    if(tolower(s[l]) != tolower(s[r]))
+		return false;
+	    ++l;
+	    --r;
+	}
+	return true;
+    }
+};
+
+class Solution {
+public:
+    bool isPalindrome2(string s) {
+	for (int i = 0, j = s.size() - 1; i < j; ++i, --j)
+	{
+	    while (i < j && !isalnum(s[i])) i++;
+	    while (i < j && !isalnum(s[j])) j--;
+
+	    if (tolower(s[i]) != tolower(s[j]))
+		return false;
+	}
+	return true;
+    }
+};

WordLadder.cpp

@@ -0,0 +1,59 @@
+/*
+  Given two words (start and end), and a dictionary, find the length of shortest transformation sequence from start to end, such that:
+
+  Only one letter can be changed at a time
+  Each intermediate word must exist in the dictionary
+  For example,
+
+  Given:
+  start = "hit"
+  end = "cog"
+  dict = ["hot","dot","dog","lot","log"]
+  As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
+  return its length 5.
+
+  Note:
+  Return 0 if there is no such transformation sequence.
+  All words have the same length.
+  All words contain only lowercase alphabetic characters.
+*/
+
+class Solution {
+public:
+    int ladderLength(string start, string end, unordered_set<string> &dict) {
+	int length = 2, count = 1, neighb = 0;
+	unordered_set<string> visited;
+	queue<string> level;
+	level.push(start);
+	visited.insert(start);
+	while(!level.empty())
+	{
+	    string curr = level.front();
+	    level.pop();
+	    --count;
+	    for(int i = 0; i < curr.size(); ++i)
+	    {
+		for(int j = 0; j < 26; ++j)
+		{
+		    string next = curr;
+		    next[i] = 'a' + j;
+		    if(next == end)
+			return length;
+		    if(dict.find(next) != dict.end() && visited.find(next) == visited.end())
+		    {
+			++neighb;
+			level.push(next);
+			visited.insert(next);
+		    }
+		}
+	    }
+	    if(count == 0)  // new level starts
+	    {
+		++length;
+		count = neighb;
+		neighb = 0;
+	    }
+	}
+	return 0;
+    }
+};