add 46-48

Author: suifengls

CombinationSum.cpp

@@ -0,0 +1,43 @@
+/*
+  Given a set of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.
+
+  The same repeated number may be chosen from C unlimited number of times.
+
+  Note:
+  All numbers (including target) will be positive integers.
+  Elements in a combination (a1, a2, … , ak) must be in non-descending order. (ie, a1 ≤ a2 ≤ … ≤ ak).
+  The solution set must not contain duplicate combinations.
+
+  For example, given candidate set 2,3,6,7 and target 7,
+  A solution set is:
+  [7]
+  [2, 2, 3]
+*/
+class Solution {
+public:
+    vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
+	vector<vector<int> > result;
+	vector<int> com;
+	if(candidates.empty())
+	    return result;
+	sort(candidates.begin(), candidates.end());
+	sumHelper(candidates, target, result, com, 0, 0);
+	return result;
+    }
+    void sumHelper(vector<int> &candidates, int target, vector<vector<int> > &result, vector<int> &com, int sum, int k)
+        {
+	    if(sum > target)
+		return;
+	    else if(sum == target)
+		result.push_back(com);
+	    else
+	    {
+		for(int i = k; i < candidates.size(); ++i)
+		{
+		    com.push_back(candidates[i]);
+		    sumHelper(candidates, target, result, com, sum+candidates[i], i);
+		    com.pop_back();
+		}
+	    }
+	}
+};

MultiplyStrings.cpp

@@ -0,0 +1,55 @@
+/*
+  Given two numbers represented as strings, return multiplication of the numbers as a string.
+  
+  Note: The numbers can be arbitrarily large and are non-negative.
+*/
+class Solution {
+public:
+    string multiply1(string num1, string num2) {
+	reverse(num1.begin(), num1.end());
+	reverse(num2.begin(), num2.end());
+	string result(num1.size()+num2.size()+1, '0');
+	for(int i = 0; i < num1.size(); ++i)
+	{
+	    int carry = 0;
+	    int n1 = num1[i] - '0';
+	    for(int j = 0; j < num2.size(); ++j)
+	    {
+		int n2 = num2[j] - '0';
+		int mul = n1*n2 + carry + (result[i+j]-'0');
+		carry = mul/10;
+		result[i+j] = mul%10 + '0';
+	    }
+	    if(carry > 0)
+		result[i+num2.size()] = carry + '0';
+	}
+	reverse(result.begin(), result.end());
+	int k = 0;
+	while(k < result.size() && result[k] == '0')
+	    ++k;
+	if(k == result.size())
+	    return "0";
+	return result.substr(k);
+    }
+};
+
+class Solution {
+public:
+    string multiply2(string num1, string num2) {
+	string result(num1.size()+num2.size(), '0');
+	for(int i = num1.size()-1; i >= 0; --i)
+	{
+	    int carry = 0;
+	    for(int j = num2.size()-1; j >= 0; --j)
+	    {
+		int mul = carry + (num1[i]-'0') * (num2[j]-'0') + result[i+j+1]-'0';
+		carry = mul/10;
+		result[i+j+1] = mul%10 + '0';
+	    }
+	    result[i] += carry;
+	}
+	while(result.size() > 1 && result[0] == '0')
+	    result.erase(result.begin());
+	return result;
+    }
+};

README.md

@@ -211,4 +211,19 @@ Solve problems in LeetCode http://oj.leetcode.com/.
 45. Search for a Range
 
     	   Be careful of index bound!
-    	   L points to the index of first target, R points to the next index of last target. 
+    	   L points to the index of first target, R points to the next index of last target. 
+
+46. Combination Sum
+
+    		DFS. The start index is the same as current due to the repeated element.
+
+47. Multiple Strings
+
+    	     Reverse two strings, multiple one by one.
+	     OR do as what we do to multiple two numbers. 
+	     Be careful about index of the result. 
+
+48. Reorder List
+    
+		Reverse the last half of the list, then insert each node to thr first half one by one.
+

ReorderList.cpp

@@ -0,0 +1,57 @@
+/*
+  Given a singly linked list L: L0→L1→…→Ln-1→Ln,
+  reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→…
+  
+  You must do this in-place without altering the nodes' values.
+  
+  For example,
+  Given {1,2,3,4}, reorder it to {1,4,2,3}.
+*/
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    void reorderList(ListNode *head) {
+	if(!head || !head->next || !head->next->next)
+	    return;
+	ListNode *fast = head, *slow = head;
+	while(fast->next && fast->next->next)
+	{
+	    fast = fast->next->next;
+	    slow = slow->next;
+	}
+	// reverse last half
+	ListNode *half = reverse(slow);
+	fast = head;
+	while(half)
+	{
+	    ListNode *tmp1 = fast->next;
+	    ListNode *tmp2 = half->next;
+	    fast->next = half;
+	    half->next = tmp1;
+	    half = tmp2;
+	    fast = tmp1;
+	}
+    }
+    ListNode *reverse(ListNode *root)
+	{
+	    ListNode *node = root->next, *next = NULL;
+	    root->next = NULL;
+	    while(node->next)
+	    {
+		ListNode *tmp = node->next;
+		node->next = next;
+		next = node;
+		node = tmp;
+	    }
+	    node->next = next;
+	    return node;
+	}
+};