Leetcode on Coinidea's Blog

[leetcode]Number Complement

Mon, 09 Mar 2020 13:54:50 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Solution {
public:
 int findComplement(int num) {
 int countDigit = 0;
 int numBak = num;
 while (0 < num) {
 num = num >> 1;
 countDigit++;
 }
 return (int)(pow(2, countDigit) - 1 - numBak);
 }
};

[leetcode]Print in Order

Sun, 23 Feb 2020 04:11:23 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


class Foo {
private:
 bool isFirst;
 bool isSecond;
 bool isThird;
public:
 Foo() {
 isFirst = false;
 isSecond = false;
 isThird = true;
 }

 void first(std::function<void()> printFirst) {
 while (!isThird);
 isThird = false;
 isSecond = false;
 printFirst();
 // printFirst() outputs "first". Do not change or remove this line.
 isFirst = true;
 }

 void second(std::function<void()> printSecond) {
 while(!isFirst);
 isFirst = false;
 isThird = false;
 // printSecond() outputs "second". Do not change or remove this line.
 printSecond();
 isSecond = true;
 }

 void third(std::function<void()> printThird) {
 while(!isSecond);
 isFirst = false;
 isSecond = false;
 // printThird() outputs "third". Do not change or remove this line.
 printThird();
 isThird = true;
 }
};

[leetcode]First Bad Version

Tue, 18 Jul 2017 14:17:57 +0000

This problem is a variation of binary search, but be very careful about integer overflow when summing large numbers. The correct way to compute the midpoint is left + (right - left) / 2. I used long long instead.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// Forward declaration of isBadVersion API.
bool isBadVersion(int version);

class Solution {
public:
 int bSearch(long long left, long long right) {
 if (left >= right) {
 return right;
 }
 long long middle = (left + right) / 2;
 if (!isBadVersion(middle)) {
 if (middle + 1 > right) return middle;
 if (isBadVersion(middle + 1)) return middle + 1;
 else return bSearch(middle, right);
 }
 else {
 return bSearch(left, middle);
 }
 }

 int firstBadVersion(int n) {
 return bSearch(1, n);
 }
};

[leetcode]Palindrome Linked List

Tue, 18 Jul 2017 06:10:24 +0000

This problem asks to determine if a singly linked list is a palindrome. My original idea was to reverse the first half of the linked list and then traverse again, which should meet the time complexity $O(n)$ and space complexity $O(1)$ requirements, but it kept getting a time limit exceeded error for some reason.
After checking the discuss section and hints, a simple recursion actually works.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class Solution {
public:
 ListNode * temp;
 bool isPalindrome(ListNode* head) {
 temp = head;
 return check(head);
 }

 bool check(ListNode * node) {
 if (node == NULL) return true;
 bool flag = check(node->next) && (node->val == temp->val);
 temp = temp->next;
 return flag;
 }
};

[leetcode]Maximum Product Subarray

Mon, 17 Jul 2017 06:34:07 +0000

This problem gives an array and asks for the maximum product of a subarray, considering positive numbers, negative numbers, and zeros. The hint suggests computing a max and min for each value, then using them to generate the maximum and minimum including the current element. I used a simulation approach instead: multiply all numbers together — if the product is positive, it’s the maximum; if negative, compare the results of dropping the leftmost or rightmost negative number. To handle zeros, first split the array by zeros.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


class Solution {
public:
 int maxProductNoZero(vector<int>& nums) {
 int max = 1;
 int left = nums.size();
 int right = -1;
 for (int i = 0; i < nums.size(); i++) {
 max *= nums[i];
 if (nums[i] < 0 && i < left) {
 left = i;
 }
 if (nums[i] < 0 && i > right) {
 right = i;
 }
 }
 if (max < 0 && nums.size() > 1) {
 int max_left = 1;
 for (int i = left + 1; i < nums.size(); i++) {
 max_left *= nums[i];
 }
 int max_right = 1;
 for (int i = 0; i < right; i++) {
 max_right *= nums[i];
 }
 max = max_left > max_right ? max_left : max_right;
 }
 return max;
 }

 int maxProduct(vector<int>& nums) {
 int max = nums[0];
 vector<int> zero;
 zero.clear();
 zero.push_back(-1);
 for (int i = 0; i < nums.size(); i++) {
 if (max < nums[i]) {
 max = nums[i];
 }
 if (0 == nums[i]) {
 zero.push_back(i);
 }
 }
 zero.push_back(nums.size());
 for (int i = 0; i < zero.size() - 1; i++) {
 if (zero[i + 1] - 1 >= zero[i] + 1) {
 vector<int> sub;
 sub.clear();
 for (int j = zero[i] + 1; j <= zero[i + 1] - 1; j++) {
 sub.push_back(nums[j]);
 }
 int tmp = maxProductNoZero(sub);
 if (tmp > max) max = tmp;
 }
 }
 return max;
 }
};

[LeetCode] Isomorphic Strings

Fri, 14 Jul 2017 03:38:23 +0000

This problem can be solved by using a hash map to store the mapping between the two strings. I initially thought it only contained lowercase letters, but it actually includes all ASCII characters. I started with one hash map, but since the mapping needs to be one-to-one, I ended up using two.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class Solution {
public:
 bool isIsomorphic(string s, string t) {
 if (s.length() != t.length()) return false;
 char hash_s[256];
 char hash_t[256];
 memset(hash_s, NULL, 256);
 memset(hash_t, NULL, 256);
 for (int i = 0; i < s.length(); i++) {
 if (NULL == hash_s[s[i]] && NULL == hash_t[t[i]]) {
 hash_s[s[i]] = t[i];
 hash_t[t[i]] = s[i];
 }
 else {
 if (hash_s[s[i]] != t[i] || hash_t[t[i]] != s[i]) return false;
 }
 }
 return true;
 }
};

[leetcode]Two Sum II – Input array is sorted

Fri, 14 Jul 2017 03:34:59 +0000

For this problem I used binary search, since the array is sorted. A better approach would be to use two pointers (left and right) moving inward. I recall seeing this problem before in “The Beauty of Programming” or “Erta to Offer”.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


class Solution {
public:
 vector<int> result;

 void bSearch(vector<int>& numbers, int start, int end, int find) {
 if (start > end) return;
 int middle = (start + end) / 2;
 if (find == numbers[middle]) {
 result.push_back(middle + 1);
 return;
 } else if (find > numbers[middle]) {
 bSearch(numbers, middle + 1, end, find);
 } else {
 bSearch(numbers, start, middle - 1, find);
 }
 }

 vector<int> twoSum(vector<int>& numbers, int target) {
 for (int i = 0; i < numbers.size(); i++) {
 int find = target - numbers[i];
 result.push_back(i + 1);
 bSearch(numbers, i + 1, numbers.size(), find);
 if (result.size() == 2) {
 return result;
 }
 result.clear();
 }
 return result;
 }
};

[LeetCode] Combine Two Tables

Fri, 14 Jul 2017 03:31:53 +0000

This problem is simply a table join query. However, I initially thought JOIN was the same as LEFT JOIN, and used WHERE instead of ON, which resulted in an inner join. I got it wrong several times.

1
2
3
4


select p.FirstName, p.LastName, a.City, a.State
from Person as p
left join Address as a
on p.PersonId = a.PersonId

[leetcode]Min Stack

Fri, 14 Jul 2017 03:26:49 +0000

It’s been almost two years since I last practiced problems, and the pressure is huge. I’ve been practicing recently to keep my skills sharp.

This problem is supposedly from “erta to Offer”. My solution obviously has issues, but it still got accepted. I’ve realized that after writing PHP, JS, and C# for so long, I’ve almost forgotten how to use Vector.

The correct approach for this problem should be to use one stack to maintain the minimum value — push onto it whenever a new minimum is found. Another stack holds the data. This ensures O(n) complexity with O(1) query time.

My somewhat naive solution:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


class MinStack {
private:
 vector<int> stack;
 int min;
public:
 MinStack() {
 stack.clear();
 }

 void push(int x) {
 if (stack.empty() || min > x) {
 min = x;
 }
 stack.push_back(x);
 }

 void pop() {
 if (!stack.empty()) {
 stack.pop_back();
 genMin();
 }
 }

 void genMin() {
 min = *(stack.begin());
 for (vector<int>::iterator i = stack.begin() + 1; i < stack.end(); i++) {
 if (min > *i) {
 min = *i;
 }
 }
 }

 int top() {
 if (!stack.empty()) {
 return *(stack.end() - 1);
 }
 return false;
 }

 int getMin() {
 return min;
 }
};

[LeetCode][PHP Implementation] Contains Duplicate

Tue, 01 Dec 2015 10:06:29 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


<?php
class Solution
{
 public function containsDuplicate($nums)
 {
 $hashTable = array();
 foreach ($nums as $num)
 {
 if (!array_key_exists($num,$hashTable))
 {
 $hashTable[$num] = 1;
 }
 else
 {
 return false;
 }
 }
 return true;
 }
}
$solution = new Solution();
echo $solution->containsDuplicate(array(2,1,3,4,5,6,7,9));
?>

[LeetCode][PHP Implementation] Excel Sheet Column Number

Mon, 30 Nov 2015 12:25:48 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


<?php
class Solution
{
 public function titleToNumber($s)
 {
 $num = 0;
 $len = strlen($s) - 1;
 for ($i = $len; $i >= 0; $i--)
 {
 $num += (ord($s[$i]) - ord('A') + 1) * (int)pow(26, $len - $i);
 }
 return $num;
 }
}
$solution = new Solution();
echo $solution->titleToNumber("AA");
?>

[LeetCode][PHP Implementation] Valid Anagram

Mon, 30 Nov 2015 12:24:46 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


<?php
class Solution
{
 public function isAnagram($s, $t)
 {
 $s = strtolower($s);
 $t = strtolower($t);
 for ($i = 0; $i < 26; $i++)
 {
 $sChars[$i] = 0;
 $tChars[$i] = 0;
 }
 for ($i = 0; $i < strlen($s); $i++)
 {
 $sChars[ord($s[$i]) - ord('a')]++;
 }
 for ($i = 0; $i < strlen($t); $i++)
 {
 $tChars[ord($t[$i]) - ord('a')]++;
 }
 //var_dump($sChars);
 //var_dump($tChars);
 for ($i = 0; $i < 26; $i++)
 {
 if ($sChars[$i] != $tChars[$i])
 {
 return false;
 }
 }
 return true;
 }
}
$solution = new Solution();
echo $solution->isAnagram("HelloWorld", "whelloorld");
?>

[LeetCode][PHP Implementation] Add Digits

Mon, 30 Nov 2015 12:23:52 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


<?php
class Solution
{
 public function addDigits($num)
 {
 while ($num > 10)
 {
 $tmp = 0;
 while ($num > 0)
 {
 $tmp += $num % 10;
 $num = intval($num / 10);
 }
 $num = $tmp;
 }
 return $num;
 }
}
$solution = new Solution();
echo $solution->addDigits(381);
?>

[LeetCode][PHP Implementation] Two Sum

Mon, 30 Nov 2015 12:22:21 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


<?php
class solution
{
 public function twoSum($nums, $target)
 {
 $result = array();
 for ($i = 0; $i < count($nums); $i++)
 {
 for ($j = 0; $j < count($nums); $j++)
 {
 if ($target == $nums[$i] + $nums[$j])
 {
 $result[0] = $i + 1;
 $result[1] = $j + 1;
 return $result;
 }
 }
 }
 return $result;
 }
}
$solution = new Solution();
var_dump($solution->twoSum(array(2,7,11,15), 9));
?>

[LeetCode][PHP Implementation] Single Number

Mon, 30 Nov 2015 12:20:03 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


<?php
class Solution
{
 public function singleNumber($nums)
 {
 $single = 0;
 foreach ($nums as $num)
 {
 $single ^= $num;
 echo $num;
 }
 return $single;
 }
}
$solution = new Solution();
echo $solution->singleNumber(array(1,1,2,3,2,4,4,5,3));
?>

[leetcode_213]House Robber II

Fri, 18 Sep 2015 14:45:21 +0000

Because the houses form a circle, we iterate over each point as the starting point, exclude its adjacent points, and assume the starting point is always selected. Then we can reuse the solution from House Robber.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


class Solution {
public:
 int robOne(vector& nums) {
 if (nums.size() == 0) {
 return 0;
 }
 vector v(nums.size() + 1);
 v[0] = 0;
 v[1] = nums[0];
 for (int i = 1; i < nums.size(); i++) {
 int j = i + 1;
 if (nums[i] + v[j - 2] > v[j - 1]) {
 v[j] = nums[i] + v[j - 2];
 } else {
 v[j] = v[j - 1];
 }
 }
 return v[nums.size()];
 }

 int rob(vector& nums) {
 vector numsc;
 int size = nums.size();
 int sum = 0;
 for (int i = 0; i < size; i++) {
 numsc.clear();
 int tmp = nums[i];
 for (int j = i; j < size; j++) {
 if (j == ((i-1) < 0 ? i - 1 + size : i - 1) ||
 j == ((i+1) >= size ? i + 1 - size : i + 1) ||
 j == i) {
 numsc.push_back(0);
 continue;
 }
 numsc.push_back(nums[j]);
 }
 for (int j = 0; j < i; j++) {
 if (j == ((i-1) < 0 ? i - 1 + size : i - 1) ||
 j == ((i+1) >= size ? i + 1 - size : i + 1) ||
 j == i) {
 numsc.push_back(0);
 continue;
 }
 numsc.push_back(nums[j]);
 }
 tmp += robOne(numsc);
 if (tmp >= sum) {
 sum = tmp;
 }
 }
 return sum;
 }
};

[leetcode_215] Kth Largest Element in an Array

Mon, 14 Sep 2015 12:29:31 +0000

Finding the k-th largest number. I took a shortcut and just used a direct sort. The proper approach should be simulating quickselect.

1
2
3
4
5
6
7


class Solution {
public:
 int findKthLargest(vector<int>& nums, int k) {
 sort(nums.begin(), nums.end(), greater<int>());
 return nums[k - 1];
 }
};

[leetcode_275]H-Index II

Mon, 14 Sep 2015 12:28:35 +0000

This solution passes, but it does not use an O(log n) approach. Marking this for a revisit next time.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class Solution {
public:
 int hIndex(vector<int>& citations) {
 //sort(citations.begin(), citations.end(), greater<int>());
 int size = citations.size();
 int max = 0;
 for (int i = size - 1; i >= 0; i--) {
 int j = size - 1 - i;
 if (citations[i] >= j + 1) {
 max = j + 1;
 }
 }
 return max;
 }
};

[leetcode_274]H-Index

Mon, 14 Sep 2015 12:27:38 +0000

Sort in descending order, then perform a linear search to find the qualifying h-index.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Solution {
public:
 int hIndex(vector<int>& citations) {
 sort(citations.begin(), citations.end(), greater<int>());
 int size = citations.size();
 int max = 0;
 for (int i = 0; i < size; i++)
 {
 if (citations[i] >= i + 1)
 {
 max = i + 1;
 }
 }
 return max;
 }
};

[LeetCode 154] Find Minimum in Rotated Sorted Array II

Sun, 13 Sep 2015 08:22:43 +0000

Similar approach to Find Minimum in Rotated Sorted Array.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


class Solution {
public:
 int min;
 void search(int left, int right, vector<int>& nums)
 {
 if (right < left)
 {
 return;
 }
 int mid = (left + right) / 2;
 if (nums[mid] < min) {
 min = nums[mid];
 search(left, mid - 1, nums);
 search(mid + 1, right, nums);
 } else if (nums[mid] >= min) {
 search(left, mid - 1, nums);
 search(mid + 1, right, nums);
 }
 }

 int findMin(vector<int>& nums) {
 min = nums[0];
 search(0, nums.size() - 1, nums);
 return min;
 }
};

[leetcode_216]Combination Sum III

Sun, 13 Sep 2015 08:20:50 +0000

Depth-first search.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


class Solution {
public:
 vector<vector<int>> result;
 vector<int> list;

 void search(int now, int k, int n, int sum) {
 if (list.size() == k && sum == n) {
 result.push_back(list);
 }
 if (list.size() >= k || now > 9) {
 return;
 }
 list.push_back(now);
 search(now + 1, k , n , sum + now);
 list.pop_back();
 search(now + 1, k , n , sum);
 }

 vector<vector<int>> combinationSum3(int k, int n) {
 result.clear();
 list.clear();

 search(1, k, n, 0);

 return result;
 }
};

[leetcode_240]Search a 2D Matrix II

Sun, 13 Sep 2015 08:20:04 +0000

Due to the special properties of the matrix, we can simply start searching from the top-left corner.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class Solution {
public:
 bool searchMatrix(vector<vector<int>>& matrix, int target) {
 int row = matrix.size() - 1;
 int cols = matrix[0].size() - 1;
 int x = 0;
 int y = cols;
 while (x <= row && y >= 0)
 {
 if (target == matrix[x][y])
 {
 return true;
 }
 else if (target > matrix[x][y])
 {
 x++;
 }
 else
 {
 y--;
 }
 }
 return false;
 }
};

[LeetCode 230] Kth Smallest Element in a BST

Thu, 10 Sep 2015 14:34:22 +0000

Find the k-th smallest element in a binary search tree. Perform an in-order traversal to generate the sorted sequence, store it in an array, and return the k-th element.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


class Solution {
public:
 vector<int> list;
 void queryTree(TreeNode * node)
 {
 if (NULL == node)
 {
 return;
 }
 if (NULL != node->left)
 {
 queryTree(node->left);
 }
 list.push_back(node->val);
 if (NULL != node->right)
 {
 queryTree(node->right);
 }
 }

 int kthSmallest(TreeNode* root, int k) {
 list.clear();
 queryTree(root);
 return list[k-1];
 }
};

[LeetCode 219] Contains Duplicate II

Wed, 09 Sep 2015 12:36:36 +0000

Determine whether there exist two identical elements in an array whose index difference is at most k. A hash map problem.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class Solution {
public:
 bool containsNearbyDuplicate(vector<int>& nums, int k) {
 map<int, int> mNums;
 mNums.clear();
 for (int i = 0;i < nums.size();i++)
 {
 map<int,int>::iterator it = mNums.find(nums[i]);
 if (mNums.end() == it)
 {
 mNums.insert(pair<int,int>(nums[i], i));
 }
 else
 {
 if (i - it->second <= k)
 {
 return true;
 }
 mNums.erase(it);
 mNums.insert(pair<int,int>(nums[i], i));
 }
 }
 return false;
 }
};

[LeetCode 223] Rectangle Area

Wed, 09 Sep 2015 12:35:06 +0000

Calculate the total area of two rectangles, which may have an overlapping region.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


class Solution {
public:
 int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) {
 int bx,by,tx,ty;
 bx = A > E ? A : E;
 by = B > F ? B : F;
 tx = C < G ? C : G;
 ty = D < H ? D : H;

 int same = 0;
 if (tx <= bx || ty <= by) {
 same = 0;
 } else {
 same = (tx - bx) * (ty - by);
 }

 return (C - A) * (D - B) + (G - E) * (H - F) - same;
 }
};

[LeetCode 198] House Robber

Mon, 07 Sep 2015 15:19:40 +0000

Select numbers from an array of positive integers to maximize the sum, with the constraint that no two adjacent numbers can be selected.
One could enumerate all 2^n cases, but that’s too expensive. Instead, use one-dimensional dynamic programming: f(n) = max(f(n-1), nums[n] + f(n-2));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class Solution {
public:
 int rob(vector<int>& nums) {
 if (nums.size() <= 0)
 {
 return 0;
 }
 vector<int> v(nums.size() + 1);
 v[0] = 0;
 v[1] = nums[0];
 for (int i = 1; i < nums.size(); i++)
 {
 int j = i + 1;
 if (nums[i] + v[j - 2] > v[j - 1])
 {
 v[j] = nums[i] + v[j-2];
 }
 else
 {
 v[j] = v[j-1];
 }
 }
 return v[nums.size()];
 }
};

[LeetCode 199] Binary Tree Right Side View

Mon, 07 Sep 2015 04:58:23 +0000

Find the rightmost node value at each level of a binary tree. Serialize each level and output the last node of each level.

class Solution {
public:
vector<int> rightSideView(TreeNode* root) {
vector<int> ans(0);
if (NULL == root)
{
return ans;
}
queue<TreeNode *> qList;
qList.push(root);
while (qList.size() > 0)
{
int size = qList.size();
for (int i = 0;i < size;i++)
{
TreeNode * head = qList.front();
if (NULL != head->left)
{
qList.push(head->left);
}
if (NULL != head->right)
{
qList.push(head->right);
}
qList.pop();
if (i == size-1)
{
ans.push_back(head->val);
}
}
}
return ans;
}
};

[LeetCode 260] Single Number III

Mon, 07 Sep 2015 04:57:15 +0000

Given an array where all numbers appear in pairs except for two numbers, find those two numbers.
The single-number case is well known – just XOR everything. With two unique numbers, XOR gives a^b. Since a^b is non-zero, pick any bit position where it is 1, partition the array into two groups based on that bit, and XOR each group separately to get a and b.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class Solution {
public:
 vector<int> singleNumber(vector<int>& nums) {
 int ab = 0;
 for (int i = 0; i < nums.size(); i++) {
 ab ^= nums[i];
 }

 int pos = 0;
 while(0 == ab % 2) {
 pos++;
 ab /= 2;
 }

 int a = 0;
 int b = 0;
 int tmp = (int)pow(2.0, pos);

 for (int i = 0; i < nums.size(); i++) {
 if ((nums[i]^tmp) == (nums[i] - tmp)) {
 a ^= nums[i];
 }
 else {
 b ^= nums[i];
 }
 }

 vector<int> ans(0);
 ans.push_back(a);
 ans.push_back(b);
 return ans;
 }
};

[LeetCode 206] Reverse Linked List

Tue, 01 Sep 2015 14:53:34 +0000

Reverse a singly linked list.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


class Solution {
public:
 ListNode* reverseList(ListNode* head) {
 if (NULL == head)
 {
 return head;
 }
 ListNode * before = NULL;
 ListNode * now = head;
 ListNode * next = now->next;

 while (NULL != next)
 {
 ListNode * beforeTmp = now;
 ListNode * nowTmp = next;
 ListNode * nextTmp = next->next;

 now->next = before;
 next->next = now;

 before = beforeTmp;
 now = nowTmp;
 next = nextTmp;
 }

 head = now;
 return head;
}
};

[LeetCode 238] Product of Array Except Self

Mon, 31 Aug 2015 11:47:19 +0000

Given an input array a1, a2, a3, …

Generate an output array where each element is the product of all other elements, e.g. a2a3, a1a3, a1*a2. The goal is to solve it in O(n) time without using division.

Use two extra arrays to store the prefix product and suffix product for each index.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


class Solution {
public:
 vector<int> productExceptSelf(vector<int>& nums) {
 int size = nums.size();
 vector<int> front(size), back(size), result(size);
 front[0] = 1;
 back[size-1] = 1;
 for (int i = 1;i < size;i++)
 {
 front[i] = front[i-1] * nums[i-1];
 }
 for (int i = size - 2;i >= 0;i--)
 {
 back[i] = back[i + 1] * nums[i + 1];
 }
 result[0] = back[0];
 result[size-1] = front[size - 1];
 for (int i = 1;i < size - 1;i++)
 {
 result[i] = front[i] * back[i];
 }
 return result;
 }
};

[LeetCode 172] Factorial Trailing Zeroes

Mon, 31 Aug 2015 11:43:47 +0000

Count how many trailing zeroes n! has. The problem essentially reduces to counting the number of factor 5 in the prime factorization (since there are always more 2s than 5s). A naive approach of checking every number modulo 5 would time out; instead, you only need to compute the relationship between powers of 5 and n.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class Solution {
public:
 int trailingZeroes(int n) {
 vector<int> five(14);
 for (int i = 1; i <= 13; i++) {
 five[i] = ((int)pow(5.0, i));
 }
 int before = 0;
 int count = 0;
 for (int i = 13; i >= 1; i--) {
 if (five[i] <= n) {
 count += (n / five[i] - before) * i;
 before = (n / five[i]);
 }
 }
 return count;
 }
};

[LeetCode 257] Binary Tree Paths

Fri, 28 Aug 2015 14:24:23 +0000

Enumerate all paths of a binary tree – a simple search will do.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


class Solution {
public:
 string convertIntToStr(int num)
 {
 char str[255];
 sprintf(str, "%d", num);
 return str;
 }

void binaryTreePath(TreeNode* node, string& path, vector<string>& paths)
{
 if (NULL == node)
 {
 return;
 }
 path += convertIntToStr(node->val);
 if (NULL != node->left)
 {
 string tmp = path;
 path += "->";
 binaryTreePath(node->left, path, paths);
 path = tmp;
 }
 if (NULL != node->right)
 {
 string tmp = path;
 path += "->";
 binaryTreePath(node->right, path, paths);
 path = tmp;
 }
 if (NULL == node->left && NULL == node->right)
 {
 paths.push_back(path);
 }
}

vector<string> binaryTreePaths(TreeNode* root) {
 vector<string> paths;
 paths.clear();

 string path = "";
 binaryTreePath(root, path, paths);

 return paths;
}
};

[leetcode_165] Compare Version Numbers

Thu, 27 Aug 2015 13:37:59 +0000

Another way to describe the problem: Split the two input numbers by ., then compare them segment by segment. If the number of segments differs, the one with more segments is larger – provided the extra segments contain a non-zero value.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


class Solution {
public:
 void getNums(string version1, vector<int> &v1)
 {
 int s = 0;
 int pos = version1.find(".");
 while (-1 != pos)
 {
 v1.push_back(atoi(version1.substr(s, pos - s).c_str()));
 s = pos + 1;
 pos = version1.find(".", pos + 1);
 }
 v1.push_back(atoi(version1.substr(s).c_str()));
 }
 int compareVersion(string version1, string version2) {
 vector<int> v1, v2;
 v1.clear();
 v2.clear();
 getNums(version1, v1);
 getNums(version2, v2);
 int min = v1.size() > v2.size() ? v2.size() : v1.size();
 for (int i = 0; i < min;i++)
 {
 if (v1[i] > v2[i])
 {
 return 1;
 }
 if (v1[i] < v2[i])
 {
 return -1;
 }
 }
 if (v1.size() > v2.size())
 {
 for (int i = min; i < v1.size(); i++)
 {
 if (v1[i] > 0)
 {
 return 1;
 }
 }
 return 0;
 }
 if (v1.size() < v2.size())
 {
 for (int i = min; i < v2.size(); i++)
 {
 if (v2[i] > 0)
 {
 return -1;
 }
 }
 return 0;
 }
 return 0;
 }
};

[leetcode_203]Remove Linked List Elements

Thu, 27 Aug 2015 13:32:41 +0000

Remove all nodes with a specified value from a singly linked list.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


class Solution {
public:
 ListNode* removeElements(ListNode* head, int val) {
 if (NULL == head)
 {
 return NULL;
 }
 ListNode * before = NULL;
 ListNode * now = head;
 while (now != NULL)
 {
 if (now -> val == val)
 {
 if (before == NULL)
 {
 head = head->next;
 now = head;
 }
 else
 {
 if (now != NULL)
 {
 before->next = now->next;
 }
 now = before->next;
 }
 }
 else
 {
 before = now;
 now = now->next;
 }
 }
 return head;
 }
};

[LeetCode 268] Missing Number

Thu, 27 Aug 2015 13:30:51 +0000

Given a sequence from 0 to n with one number i missing, find i.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


class Solution {
public:
 int missingNumber(vector<int>& nums) {
 int sum = 0;
 int max = 0;
 bool isZero = false;
 for (int i = 0; i < nums.size(); i++) {
 sum += nums[i];
 if (nums[i] >= max) {
 max = nums[i];
 }
 if (nums[i] == 0) {
 isZero = true;
 }
 }
 int oSum = (0 + max) * (max - 0 + 1) / 2;
 if (oSum == sum) {
 if (!isZero) {
 return 0;
 } else {
 return max + 1;
 }
 } else {
 return oSum - sum;
 }
 }
};

[leetcode_160]Intersection of Two Linked Lists

Thu, 27 Aug 2015 13:28:46 +0000

Find the intersection node of two singly linked lists. The idea is simple: the longer list advances by the difference in length first.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


class Solution {
public:
 ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
 int countA = 0;
 int countB = 0;
 ListNode * tmpA = headA;
 ListNode * tmpB = headB;
 while(NULL != tmpA)
 {
 countA++;
 tmpA = tmpA->next;
 }
 while(NULL != tmpB)
 {
 countB++;
 tmpB = tmpB->next;
 }
 int move = 0;
 if (countA > countB)
 {
 while (move < countA - countB)
 {
 headA = headA->next;
 move++;
 }
 }
 else
 {
 while (move < countB - countA)
 {
 headB = headB->next;
 move++;
 }
 }
 while (headA != headB)
 {
 headA = headA->next;
 headB = headB->next;
 }
 return headA;
 }
};

[leetcode_173]Binary Search Tree Iterator

Thu, 27 Aug 2015 13:27:01 +0000

Traversing a binary search tree is essentially an in-order traversal of the tree. An iterative approach can be used.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


class BSTIterator {
public:
 int pos;
 vector<TreeNode *> treeNodeStack;

 void buildStack(TreeNode *node)
 {
 if (node == NULL)
 {
 return;
 }
 else
 {
 if (NULL != node->left)
 {
 buildStack(node->left);
 }
 treeNodeStack.push_back(node);
 if (NULL != node->right)
 {
 buildStack(node->right);
 }
 }
 }

 BSTIterator(TreeNode *root) {
 pos = 0;
 treeNodeStack.clear();
 buildStack(root);
 }

 /** @return whether we have a next smallest number */
 bool hasNext() {
 return treeNodeStack.size() > pos;
 }

 /** @return the next smallest number */
 int next() {
 return treeNodeStack[pos++]->val;
 }

};

[leetcode_204]Count Primes

Thu, 27 Aug 2015 13:25:23 +0000

Count the number of primes less than a given number n. The Sieve of Eratosthenes works well here.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


class Solution {
public:
 int * flag;
 int countPrimes(int n) {
 flag = new int[n + 10];
 for (int i = 1;i < n;i++)
 {
 flag[i] = 0;
 }
 for (int i = 2;i < n;i++)
 {
 if (0 == flag[i])
 {
 flag[i] = 1;
 for (int j = 2;j * i < n; j++)
 {
 flag[j * i] = -1;
 }
 }
 }
 int count = 0;
 for (int i = 1;i < n; i++)
 {
 if (1 == flag[i])
 {
 count++;
 }
 }
 return count;
 }
};

[leetcode_189]Rotate Array

Thu, 27 Aug 2015 13:24:07 +0000

Rotate an array based on input k. Note that k can be negative or greater than the array length, so take the modulus first. Then output the doubled array starting at offset size-k.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


class Solution {
public:
 void rotate(vector<int>& nums, int k) {
 if (nums.size() <= 0)
 {
 return ;
 }
 k %= nums.size();
 vector<int> dNums(nums.size() * 2);
 for (int i = 0;i < nums.size() * 2; i++)
 {
 dNums[i] = nums[i % nums.size()];
 }
 for (int i = 0;i < nums.size(); i++)
 {
 nums[i] = dNums[i + nums.size() - k];
 }
 }
};

[leetcode_168]Excel Sheet Column Title

Thu, 27 Aug 2015 13:22:04 +0000

Convert a number to an Excel column title. At first I thought it was a simple base-26 conversion, but you need to consider that there is no 0 in this numeral system. So I temporarily used @ to represent 0, which requires an additional conversion step afterward.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


class Solution {
public:
 string convertToTitle(int n) {
 string title = "";
 while (n > 0)
 {
 title += 'A' + n % 26 - 1;
 n /= 26;
 }
 int pos0 = 0;
 while (pos0 < title.length())
 {
 int pos = pos0;
 while (title[pos] == '@' && pos < title.length())
 {
 title[pos] = 'Z';
 if (pos + 1 < title.length() && title[pos + 1] != '@')
 {
 title[pos+1]--;
 pos++;
 }
 else
 {
 title = title.substr(0, pos);
 break;
 }
 }
 pos0++;
 }
 int s = 0;
 int e = title.length() - 1;
 while (s < e)
 {
 char tmp = title[s];
 title[s] = title[e];
 title[e] = tmp;
 s++;
 e--;
 }
 return title;
 }
};

[LeetCode 228] Summary Ranges

Thu, 27 Aug 2015 13:17:31 +0000

A simple simulation problem – merge intervals.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


class Solution {
public:
 string convertIntToStr(int num)
 {
 char str[255];
 sprintf(str, "%d", num);
 return str;
 }

 vector<string> summaryRanges(vector<int>& nums) {
 vector<string> ranges;
 ranges.clear();
 if (nums.size() <= 0)
 {
 return ranges;
 }
 int start = nums[0];
 int end = nums[0];
 for (int i = 1;i < nums.size(); i++)
 {
 if (nums[i] - nums[i-1] == 1)
 {
 end = nums[i];
 }
 else
 {
 string item = convertIntToStr(start);
 if (end == start)
 {
 ranges.push_back(item);
 }
 else
 {
 item += "-";
 item += convertIntToStr(end);
 ranges.push_back(item);
 }
 start = nums[i];
 end = start;
 }
 }
 string item = convertIntToStr(start);
 if (end == start)
 {
 ranges.push_back(item);
 }
 else
 {
 item += "-";
 item += convertIntToStr(end);
 ranges.push_back(item);
 }
 return ranges;
 }
};

[leetcode_190]Reverse Bits

Fri, 21 Aug 2015 14:19:09 +0000

Convert a positive integer to binary, reverse the bit order, then output it as a decimal. A simulation problem.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class Solution {
public:
 uint32_t reverseBits(uint32_t n) {
 //To binary
 vector<int> nums(32, 0);
 int index = 0;
 while(n > 0)
 {
 nums[index++] = n % 2;
 n /= 2;
 }

 uint32_t ans = 0;
 for (int i = 0; i < nums.size(); i++)
 {
 ans += nums[i] * (uint32_t)pow(2.0, (int)(nums.size() - i - 1));
 }
 return ans;
 }
};

[leetcode_202]Happy Number

Fri, 21 Aug 2015 14:17:58 +0000

Determine whether a number n is a happy number. A happy number is defined by repeatedly summing the squares of its digits and checking if the result equals 1. If it doesn’t equal 1, repeat the process. In practice, this process will form a cycle. [This is a guess, not formally proven.]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


class Solution {
public:
 map<int, bool> flag;
 bool isHappy(int n)
 {
 if (n == 1)
 {
 return true;
 }
 map<int, bool>::iterator it = flag.find(n);
 if (it != flag.end())
 {
 return false;
 }
 else
 {
 flag.insert(map<int, bool>::value_type(n, true));
 }
 int tmpNum = 0;
 while (n > 0)
 {
 tmpNum += (n % 10) * (n % 10);
 n /= 10;
 }
 return isHappy(tmpNum);
 }
};

[leetcode_231]Power of Two

Fri, 21 Aug 2015 14:16:13 +0000

Determine whether a number is a power of two. This can be done with bit manipulation – just shift the bits.

class Solution {
public:
bool isPowerOfTwo(int n) {
if (n <= 0)
{
return false;
}
while(true)
{
if (n == 1) {
return true;
}
if (n % 2 != 0) {
return false;
}
n >>= 1;
}
}
};

[leetcode_263]Ugly Number

Fri, 21 Aug 2015 14:14:39 +0000

Determine whether a number is an ugly number. Solved using simulation.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


class Solution {
public:
 bool isUgly(int num) {
 if (num <= 0)
 {
 return false;
 }
 while(true)
 {
 if(num%2 == 0)
 {
 num /= 2;
 }
 else if(num%3 == 0)
 {
 num /= 3;
 }
 else if(num%5 == 0)
 {
 num /= 5;
 }
 else
 {
 if (num == 1)
 {
 return true;
 }
 else
 {
 return false;
 }
 }
 }
 }
};

[leetcode_225]Implement Stack using Queues

Fri, 21 Aug 2015 14:13:33 +0000

Simulate a stack. Took a shortcut by using a vector to solve the problem.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Stack {
public:
 vector<int> stack;
 // Push element x onto stack.
 void push(int x) {
 stack.push_back(x);
 }

 // Removes the element on top of the stack.
 void pop() {
 stack.pop_back();
 }

 // Get the top element.
 int top() {
 return stack[stack.size() - 1];
 }

 // Return whether the stack is empty.
 bool empty() {
 return stack.empty();
 }
};

[leetcode_153]Find Minimum in Rotated Sorted Array

Fri, 21 Aug 2015 14:12:27 +0000

This is an interesting problem. Given a sorted array: 1,2,3,4,5,6,7, but it has been rotated, for example: 4,5,6,7,1,2,3. The task is to find the minimum element. An O(n) solution is always possible. I remember being asked a similar question during a Didi interview last year. I was sure it was binary search at the time, but felt I didn’t explain it clearly. This time, the approach is much clearer.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


class Solution {
public:
 void binarySearch(vector<int>& nums, int left, int right, int &min)
 {
 if (left > right)
 {
 return ;
 }
 int mid = (left + right) / 2;
 if (nums[mid] >= min)
 {
 binarySearch(nums, left, mid - 1, min);
 binarySearch(nums, mid+1, right, min);
 }
 else
 {
 min = nums[mid];
 binarySearch(nums, left, mid - 1, min);
 }
 }

 int findMin(vector<int>& nums) {
 int min = nums[0];
 binarySearch(nums, 0, nums.size() - 1, min);
 return min;
 }
};

[leetcode_242]Valid Anagram

Fri, 21 Aug 2015 14:08:11 +0000

Determine whether two strings contain the same letters with the same frequency.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


class Solution {
public:
 bool isAnagram(string s, string t) {
 vector&lt;int&gt; sCount(26, 0);
 for (int i = 0;i &lt; s.length();i++)
 {
 sCount[s[i] - 'a']++;
 }
 for (int i = 0;i &lt; t.length();i++)
 {
 sCount[t[i] - 'a']--;
 }
 for (int i = 0;i &lt; sCount.size(); i++)
 {
 if (0 != sCount[i])
 {
 return false;
 }
 }
 return true;
 }
};

[leetcode_169] Majority Element

Wed, 19 Aug 2015 13:03:04 +0000

Find the element that appears more than half the time in a given array (guaranteed to exist). Pay attention to whether the array length is odd or even. A hash map does the job.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


class Solution {
public:
 int majorityElement(vector<int>& nums) {
 map<int, int> m_nums;
 m_nums.clear();
 for (int i = 0; i < nums.size(); i++)
 {
 auto it = m_nums.find(nums[i]);
 if (it == m_nums.end())
 {
 m_nums.insert({nums[i], 1});
 }
 else
 {
 m_nums.erase(nums[i]);
 m_nums.insert({nums[i], ++(it->second)});
 }
 }

 for (auto it = m_nums.begin(); it != m_nums.end(); it++)
 {
 if (it->second >= nums.size() / 2 + 1)
 {
 return it->first;
 }
 }
 }
};

[leetcode_217] Contains Duplicate

Wed, 19 Aug 2015 13:01:16 +0000

Determine whether a given array contains duplicate elements. A hash table solves this. I actually used a map, which is a binary search tree in C++. The O(log n) solution, so the performance isn’t the best.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class Solution {
public:
 bool containsDuplicate(vector<int>& nums) {
 map<int, bool> m_nums;
 m_nums.clear();
 for (int i = 0; i < nums.size(); i++)
 {
 map<int, bool>::iterator it = m_nums.find(nums[i]);
 if (it == m_nums.end())
 {
 m_nums.insert(map<int, bool>::value_type(nums[i], true));
 }
 else
 {
 return true;
 }
 }
 return false;
 }
};

[leetcode_171] Excel Sheet Column Number

Wed, 19 Aug 2015 12:59:48 +0000

Find the actual column number represented by an Excel column label like “AB”. It’s essentially base-26 conversion.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


class Solution {
public:
 int titleToNumber(string s) {
 int sum = 0;
 int size = s.length();
 for (int i = 0; i < size; i++) {
 sum += (s[i] - 'A' + 1) * (int)pow(26.0, (size - i - 1));
 }
 return sum;
 }
};

[leetcode_226]Invert Binary Tree

Wed, 19 Aug 2015 12:58:35 +0000

Inverting a binary tree is essentially a post-order traversal of the tree with swapping of left and right child nodes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


class Solution {
public:
 void swap(TreeNode & left, TreeNode *& right)
 {
 TreeNode * tmp = left;
 left = right;
 right = tmp;
 }
 TreeNode * invertTree(TreeNode* root) {
 if (root == NULL)
 return NULL;
 if (root->left != NULL)
 invertTree(root->left);
 if (root->right != NULL)
 invertTree(root->right);
 swap(root->left, root->right);
 return root;
 }
};

[leetcode_235]Lowest Common Ancestor of a Binary Search Tree

Wed, 19 Aug 2015 12:57:17 +0000

Find the lowest common ancestor of two nodes in a binary tree. I’ve done similar problems before, but it’s been a while since I last solved algorithm problems, so I thought it through again. The approach is depth-first search to find the two paths, then find their intersection. I was initially worried about time limit exceeded, but the AC was quite fast.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


class Solution {
public:
 bool isFind;
 vector<TreeNode *> pV, qV;
 void FindK(TreeNode *node, TreeNode* k, vector<TreeNode *> &kV)
 {
 kV.push_back(node);
 if (isFind || node == k)
 {
 isFind = true;
 return;
 }
 if (NULL != node->left)
 {
 FindK(node->left, k, kV);
 if (isFind)
 {
 return;
 }
 kV.pop_back();
 }
 if (NULL != node->right)
 {
 FindK(node->right, k, kV);
 if (isFind)
 {
 return;
 }
 kV.pop_back();
 }
 }
 TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
 if (NULL == root)
 {
 return root;
 }
 pV.clear();
 qV.clear();
 isFind = false;
 FindK(root, p, pV);
 isFind = false;
 FindK(root, q, qV);
 int i = 0;
 int minSize = pV.size() > qV.size() ? qV.size() : qV.size();
 for (i = 0;i < minSize; i++)
 {
 if (pV[i] != qV[i])
 {
 break;
 }
 }
 return pV[i - 1];
 }
};

[leetcode_191] Number of 1 Bits

Wed, 19 Aug 2015 12:55:17 +0000

Count the number of 1s in the binary representation of an integer. A straightforward simulation.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Solution {
public:
 int hammingWeight(uint32_t n) {
 int count = 0;
 while(n > 0)
 {
 count += n%2;
 n /= 2;
 }
 return count;
 }
};

[leetcode_237]Delete Node in a Linked List

Wed, 19 Aug 2015 12:53:27 +0000

Delete a specified node in a singly linked list. When I first read the problem, I thought at least both the head node and the target node should be given. But after guessing, I realized the problem likely requires copying the values of subsequent nodes forward to overwrite, rather than performing a true linked list deletion.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class Solution {
public:
 void deleteNode(ListNode* node) {
 ListNode * next = node->next;
 ListNode * before = NULL;
 while(next != NULL)
 {
 node->val = next->val;
 before = node;
 node = next;
 next = next->next;
 }
 before->next = NULL;
 }
};

[leetcode_258]Add Digits

Wed, 19 Aug 2015 12:38:32 +0000

I couldn’t figure out the O(1) approach, so here’s the simulation method: Repeatedly sum all the digits until the sum is less than 10.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


class Solution {
public:
 int addDigits(int num) {
 int sum = 0;
 while(num > 0)
 {
 sum += num % 10;
 num /= 10;
 }
 if (sum >= 10)
 {
 return addDigits(sum);
 }
 else
 {
 return sum;
 }
 }
};

[leetcode_151]Reverse Words in a String

Sat, 23 May 2015 03:22:13 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


class Solution
{
public:
 int getFirstLetter(string &s,int start)
 {
 int i;
 for(i = start;i < s.length();i++)
 {
 if(s[i] != ' ')return i;
 }
 return i;
 }
 int getFirstBlank(string &s,int start)
 {
 int i;
 for(i = start;i < s.length();i++)
 {
 if(s[i] == ' ')return i;
 }
 return i;
 }
 void reverseWords(string &s) {
 vector<string> splits;
 splits.clear();
 int i = 0;
 while(i < s.length())
 {
 i = getFirstLetter(s,i);
 if(i >= s.length())break;
 int next = getFirstBlank(s,i+1);
 if(next >= s.length())
 {
 next = s.length()-1;
 splits.push_back(s.substr(i,next-i+1));
 break;
 }
 splits.push_back(s.substr(i,next-i));
 i = next;
 }
 s = "";
 for(int i = splits.size()-1;i >= 0;i--)
 {
 s += splits[i];
 if(i != 0)s += " ";
 }
 }
};

[leetcode] A Screenshot to Commemorate

Sat, 23 May 2015 03:21:17 +0000

[leetcode_68]Text Justification

Sat, 23 May 2015 03:20:29 +0000

So excited! Finally AC’d all LeetCode problems at once! Although the journey had its twists and turns, I’m still thrilled!
This is a simulation problem – formatting strings according to specified rules. The great thing about LeetCode is that you can see the test data, understand the problem statement thoroughly, and debug step by step. Getting it AC on the first try is actually quite difficult.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89


class Solution {
public:
 vector<string> fullJustify(vector<string> &words, int L) {
 vector<vector<string>> result;
 result.clear();
 vector<string> ans;
 ans.clear();
 if (L == 0) {
 ans.push_back("");
 return ans;
 }
 for (int i = 0; i < words.size(); i++) {
 vector<string> item;
 item.clear();
 int sum = 0;
 while (true) {
 if (item.size() > 0) sum += 1;
 if (sum >= L) {
 i--;
 break;
 }
 if (i >= words.size()) break;
 item.push_back(words[i]);
 sum += words[i].length();
 if (sum > L) {
 item.pop_back();
 i--;
 break;
 }
 i++;
 }
 result.push_back(item);
 }
 for (int i = 0; i < result.size(); i++) {
 string item = "";
 if (i != result.size() - 1) item = genString(result[i], L);
 else
 item = genStringLast(result[i], L);
 ans.push_back(item);
 }
 return ans;
 }
private:
 string genStringLast(vector<string> &item, int L) {
 int sum = 0;
 string str = "";
 for (int i = 0; i < item.size(); i++) {
 str += item[i];
 sum += item[i].size();
 if (i != item.size() - 1) {
 str += " ";
 sum += 1;
 }
 }
 for (int i = 0; i < L - sum; i++)
 str += " ";
 return str;
 }
 string genString(vector<string> &item, int L) {
 int sum = 0;
 for (int i = 0; i < item.size(); i++)
 sum += item[i].size();
 string str = "";
 if (item.size() == 1) {
 int countS = L - sum;
 str += item[0];
 for (int j = 0; j < countS; j++)
 str += " ";
 return str;
 }
 int spaces;
 if (item.size() > 1) spaces = (L - sum) / (item.size() - 1);
 else
 spaces = 0;
 int ex = L - sum - spaces * (item.size() - 1);
 for (int i = 0; i < item.size(); i++) {
 str += item[i];
 int countS;
 if (i < ex)
 countS = 1 + spaces;
 else
 countS = spaces;
 if (i != item.size() - 1)
 for (int j = 0; j < countS; j++)
 str += " ";
 }
 return str;
 }
};

[leetcode_146]LRU Cache

Sat, 23 May 2015 03:19:36 +0000

Use a doubly linked list to simulate a queue, then two maps to store key-value and key-ListNode for optimized lookup time.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95


struct ListNodel {
 int key;
 ListNodel *before;
 ListNodel *next;
 ListNodel(int x) : key(x), before(NULL), next(NULL) {}
};

class LRUCache{
public:
 map<int, int> mapkv;
 map<int, ListNodel*> mapkl;
 int capacityq;
 ListNodel * head, *tail;

 LRUCache(int capacity) {
 capacityq = capacity;
 mapkv.clear();
 mapkl.clear();
 head = NULL;
 tail = NULL;
 }

 int get(int key) {
 map<int, int>::iterator it = mapkv.find(key);
 if (it != mapkv.end()) {
 update(key);
 return it->second;
 } else {
 return -1;
 }
 }

 void set(int key, int value) {
 map<int, int>::iterator it = mapkv.find(key);
 if (it != mapkv.end()) {
 it->second = value;
 update(key);
 } else {
 if (mapkv.size() < capacityq) {
 insertKeyValue(key, value);
 } else {
 ListNodel * tmp = head;
 head = head->next;
 mapkl.erase(tmp->key);
 mapkv.erase(tmp->key);
 delete(tmp);
 insertKeyValue(key, value);
 }
 }
 }

private:
 void insertKeyValue(int key, int value) {
 mapkv.insert(map<int, int>::value_type(key, value));
 if (head == NULL) {
 ListNodel * tmp = new ListNodel(key);
 mapkl.insert(map<int, ListNodel*>::value_type(key, tmp));
 head = tmp;
 tail = tmp;
 head->next = tail;
 tail->before = head;
 tail->next = NULL;
 } else {
 ListNodel * tmp = new ListNodel(key);
 mapkl.insert(map<int, ListNodel*>::value_type(key, tmp));
 tmp->before = tail;
 tail->next = tmp;
 tmp->next = NULL;
 tail = tmp;
 }
 }

 void update(int key) {
 map<int, ListNodel*>::iterator it = mapkl.find(key);
 ListNodel * tmp = it->second;
 if (tmp == head) {
 if (head->next != NULL) {
 head = head->next;
 tail->next = tmp;
 tmp->before = tail;
 tmp->next = NULL;
 tail = tmp;
 }
 } else if (tmp != tail) {
 ListNodel * tmpb = tmp->before;
 ListNodel * tmpn = tmp->next;
 tmpb->next = tmpn;
 tmpn->before = tmpb;
 tmp->before = tail;
 tail->next = tmp;
 tmp->next = NULL;
 tail = tmp;
 }
 }
};

[leetcode_44]Wildcard Matching

Sat, 23 May 2015 03:18:44 +0000

DFS kept timing out, even with memoization. Here is the code for the record:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


class Solution {
public:
 bool isMatch(const char *s, const char *p) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 const char *tmp = p;
 int cnt = 0;
 while (*tmp != '\0') if (*(tmp++) != '*') cnt++;
 if (cnt > strlen(s)) return false;

 if(strlen(s) == 0) {
 for(int i = 0;i < strlen(p);i++) {
 if(p[i] != '*')return false;
 }
 return true;
 }

 int **dp;
 dp = new int*[strlen(s) + 1];
 for(int i = 0; i <= strlen(s); i++) {
 dp[i] = new int[strlen(p) + 1];
 }
 dp[0][0] = 1;
 int i = 0;
 while(p[i++] == '*') dp[0][i] = 1;
 for(int i = 1; i <= strlen(s); i++) {
 for(int j = 1; j <= strlen(p); j++) {
 if(dp[i-1][j-1] == 1 && (s[i-1] == p[j-1] || p[j-1] == '?')) {
 dp[i][j] = 1;
 }
 if(p[j-1] == '*' && (dp[i][j-1] == 1 || dp[i-1][j-1] == 1 || dp[i-1][j] == 1)) {
 dp[i][j] = 1;
 }
 }
 }
 if(dp[strlen(s)][strlen(p)] == 1) return true;
 else
 return false;
 }
};

[leetcode_130]Surrounded Regions

Sat, 23 May 2015 03:17:52 +0000

Another BFS problem. Start from the boundary to find ‘O’s; any ‘O’ not visited is surrounded by ‘X’.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73


struct Pointp {
 int x;
 int y;
 Pointp() : x(0), y(0) {}
 Pointp(int a, int b) : x(a), y(b) {}
};
class Solution {
public:
 int lenm,lenn;
 int **map;
 void solve(vector<vector<char>> &board) {
 lenm = board.size();
 if(lenm <= 1)return ;
 lenn = board[0].size();
 map = new int *[lenm];
 for(int i = 0;i < lenm;i++) {
 map[i] = new int[lenn];
 }
 for(int i = 0;i < lenm;i++) {
 for(int j = 0;j < lenn;j++) {
 if(board[i][j] == 'O')map[i][j] = 0;
 else
 if(board[i][j] == 'X')map[i][j] = 1;
 }
 }
 for(int i = 0;i < lenm;i++) {
 for(int j = 0;j < lenn;j++) {
 if((i == 0 || j == 0 || i == lenm-1 || j == lenn-1)&&(map[i][j] == 0)) {
 map[i][j] = 2;
 bfs(i,j);
 }
 }
 }
 for(int i = 0;i < lenm;i++) {
 for(int j = 0;j < lenn;j++) {
 if(map[i][j] != 2)board[i][j] = 'X';
 }
 }
 //for(int i = 0;i < lenm;i++) {
 // for(int j = 0;j < lenn;j++) {
 // cout << board[i][j] << ' ';
 // }
 // cout << endl;
 //}
 }
private:
 void bfs(int x,int y) {
 int walk[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
 vector<Pointp>arr,arrs;
 arr.clear();
 arrs.clear();
 Pointp p(x,y);
 arr.push_back(p);
 while(true) {
 arrs.clear();
 for(int i = 0;i < arr.size();i++) {
 for(int j = 0;j < 4;j++) {
 int x = arr[i].x + walk[j][0];
 int y = arr[i].y + walk[j][1];
 if((x >= 0 && x <= lenm-1)&&(y >= 0 && y <= lenn-1)&&map[x][y] == 0) {
 map[x][y] = 2;
 arrs.push_back(Pointp(x,y));
 }
 }
 }
 if(arrs.size() == 0)break;
 arr.clear();
 for(int i = 0;i < arrs.size();i++) {
 arr.push_back(arrs[i]);
 }
 }
 }
};

[leetcode_140]Word Break II

Sat, 23 May 2015 03:16:58 +0000

Again using BFS. This problem requires a DP check to determine whether a solution exists. I also learned this from reading others’ blogs; otherwise it would keep getting TLE.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67


class Solution {
public:
 bool **map;
 set<int> wordlens;
 vector<string> result;
 vector<string> wordBreak(string s, unordered_set<string> &dict) {
 wordlens.clear();
 unordered_set<string>::iterator it;
 for(it = dict.begin(); it != dict.end(); it++) {
 string itstr = *it;
 wordlens.insert(itstr.length());
 }
 result.clear();
 map = new bool*[s.length()];
 for(int i = 0; i < s.length(); i++) {
 map[i] = new bool[s.length()];
 for(int j = 0; j < s.length(); j++) {
 map[i][j] = false;
 }
 }
 for(int start = 0; start < s.length(); start++) {
 for(int len = 1; len <= s.length() - start; len++) {
 string tmp = s.substr(start, len);
 if(dict.find(tmp) != dict.end()) {
 map[start][start + len - 1] = true;
 }
 }
 }
 for(int i = 0; i < s.length(); i++) {
 for(int j = 0; j <= i; j++) {
 for(int k = j; k < i; k++) {
 if(map[j][k] && map[k + 1][i]) map[j][i] = true;
 }
 }
 }
 // for(int i = 0; i < s.length(); i++) {
 // for(int j = 0; j < s.length(); j++) {
 // cout << map[i][j] << ' ';
 // }
 // cout << endl;
 // }
 if(map[0][s.length() - 1] == false) return result;
 string item = "";
 findSen(s, 0, dict, item);
 return result;
 }
private:
 void findSen(string &s, int start, unordered_set<string> &dict, string &item) {
 if(start >= s.length()) {
 result.push_back(item);
 return;
 }
 set<int>::iterator it;
 for(it = wordlens.begin(); it != wordlens.end(); it++) {
 int len = *it;
 if(start + len > s.length()) return;
 string tmp = string(s, start, len);
 if(dict.find(tmp) != dict.end()) {
 string itembp = item;
 if(start != 0) item += " ";
 item += tmp;
 findSen(s, start + len, dict, item);
 item = itembp;
 }
 }
 }
};

[leetcode_126]Word Ladder II

Sat, 23 May 2015 03:16:05 +0000

BFS + path storage. The main effort was optimizing for time. Managed to get it down to 1500ms using map – so satisfying.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97


struct NodeString {
 vector<NodeString *> before;
 string now;
};
class Solution {
public:
 vector<vector<string>> result;
 vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 result.clear();
 if (dict.find(start) == dict.end()) {
 dict.insert(start);
 }
 if (dict.find(end) == dict.end()) {
 dict.insert(end);
 }
 map<string, NodeString *> maps;
 maps.clear();
 maps.insert(map<string, NodeString *>::value_type(start, NULL));
 vector<NodeString *> strs, strsc;
 strs.clear();
 NodeString *nodeString = new NodeString();
 nodeString->before.clear();
 nodeString->now = start;
 strs.push_back(nodeString);
 bool isFind = false;
 while (true) {
 map<string, NodeString *> mapstmp;
 mapstmp.clear();
 strsc.clear();
 for (int i = 0; i < strs.size(); i++) {
 string item = strs[i]->now;
 for (int j = 0; j < item.length(); j++) {
 for (char c = 'a'; c <= 'z'; c++) {
 string tmp = item;
 if (c != item[j]) {
 tmp[j] = c;
 if (dict.find(tmp) != dict.end()) {
 if (maps.find(tmp) == maps.end()) {
 NodeString *nodetmp = new NodeString();
 nodetmp->before.clear();
 nodetmp->before.push_back(strs[i]);
 nodetmp->now = tmp;
 if (tmp == end) {
 isFind = true;
 vector<string> items;
 items.clear();
 // items.push_back(end);
 genResult(nodetmp, items);
 continue;
 }
 strsc.push_back(nodetmp);
 maps.insert(map<string, NodeString *>::value_type(tmp, nodetmp));
 mapstmp.insert(map<string, NodeString *>::value_type(tmp, nodetmp));
 } else {
 if (tmp != start) {
 map<string, NodeString *>::iterator it = mapstmp.find(tmp);
 if (it != mapstmp.end())
 it->second->before.push_back(strs[i]);
 }
 }
 }
 }
 }
 }
 }

 if (strsc.size() == 0 || isFind) break;
 strs.clear();
 for (int i = 0; i < strsc.size(); i++) {
 strs.push_back(strsc[i]);
 }
 }
 return result;
 }

private:
 void genResult(NodeString *nodeString, vector<string> &items) {
 if (nodeString->before.size() == 0) {
 items.push_back(nodeString->now);
 vector<string> itemsr;
 itemsr.clear();
 vector<string>::reverse_iterator rit;
 for (rit = items.rbegin(); rit != items.rend(); rit++) {
 itemsr.push_back(*rit);
 }
 result.push_back(itemsr);
 items.pop_back();
 } else {
 for (int i = 0; i < nodeString->before.size(); i++) {
 items.push_back(nodeString->now);
 genResult(nodeString->before[i], items);
 items.pop_back();
 }
 }
 }
};

[leetcode_127]Word Ladder

Sat, 23 May 2015 03:15:01 +0000

Shortest path in a graph T+T
I only learned this from reading others’ blogs. Before that, I was naively using BFS+map,
which kept timing out.
Later I also thought of finding adjacent nodes, and I was just one step away from the shortest path solution. Quite embarrassing.
Here is the TLE code for now; I’ll revise it to use shortest path tomorrow.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


class Solution {
public:
 int ladderLength(string start, string end, unordered_set<string> &dict) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 if(dict.find(start) == dict.end()) {
 dict.insert(start);
 }
 if(dict.find(end) == dict.end()) {
 dict.insert(end);
 }
 map<string,bool> maps;
 maps.clear();
 maps.insert(map<string,bool>::value_type(start,true));
 vector<string> strs,strsc;
 strs.clear();
 strs.push_back(start);
 int count = 1;
 while(true) {
 strsc.clear();
 count++;
 for(int i = 0;i < strs.size();i++) {
 string item = strs[i];
 for(int j = 0;j < item.length();j++) {
 for(char c = 'a';c <= 'z';c++) {
 string tmp = item;
 if(c != item[j]) {
 tmp[j] = c;
 if(dict.find(tmp) != dict.end() && maps.find(tmp) == maps.end()) {
 strsc.push_back(tmp);
 if(tmp == end) return count;
 maps.insert(map<string,bool>::value_type(tmp,true));
 }
 }
 }
 }
 }
 if(strsc.size() == 0) break;
 strs.clear();
 for(int i = 0;i < strsc.size();i++) {
 strs.push_back(strsc[i]);
 }
 }
 return 0;
 }
};

[leetcode_76]Minimum Window Substring

Sat, 23 May 2015 03:14:00 +0000

Two pointers: the first pointer starts at the first character, and we enumerate the second pointer’s position from left to right. Once all target characters are covered, slide the first pointer forward to see if the condition still holds. Find the minimum window that satisfies the condition.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


class Solution {
public:
 int letters1[256];
 int letters2[256];
 string minWindow(string S, string T) {
 for(int k = 0;k < 256;k++) {
 letters1[k] = 0;
 letters2[k] = 0;
 }
 for(int k = 0;k < T.length();k++) {
 letters1[T[k]]++;
 letters2[T[k]]++;
 }
 int min = S.length()+T.length();
 int start,end;
 int count = T.length();
 int i = 0;
 for(int j = 0;j < S.length();j++) {
 if(letters2[S[j]] > 0) {
 letters1[S[j]]--;
 if(letters1[S[j]] >= 0)count--;
 }
 if(count == 0) {
 while(true) {
 if(letters2[S[i]] > 0) {
 if(letters1[S[i]] < 0)
 letters1[S[i]]++;
 else
 break;
 }
 i++;
 }
 if(j - i + 1 < min) {
 min = j - i + 1;
 start = i;
 end = j;
 }
 }
 }
 if(min == S.length()+T.length())return "";
 return string(S,start,end - start + 1);
 }
};

[leetcode_30]Substring with Concatenation of All Words

Sat, 23 May 2015 03:12:59 +0000

Solved using brute force.
Used a map to look up whether the current fixed-length substring is one that is “needed” (i.e., needs to be found).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86


class Solution {
public:
 bool *flag;
 int len;
 vector<int> result;
 vector<int> copy;
 int sum;
 vector<int> findSubstring(string S, vector<string> &L) {
 result.clear();
 if(L.size() <= 0) return result;
 map<string,int> mapr;
 mapr.clear();
 vector<vector<int>> rtable;
 rtable.clear();
 len = L[0].size();
 map<string,int>::iterator it;
 for(int i = 0; i < L.size(); i++) {
 it = mapr.find(L[i]);
 if(it != mapr.end()) {
 it->second += 1;
 }
 else
 mapr.insert(map<string,bool>::value_type(L[i],1));
 }
 copy.clear();
 sum = 0;
 for(it = mapr.begin(); it != mapr.end(); it++) {
 copy.push_back(it->second);
 sum += it->second;
 }
 bfs(mapr, S, 0);
 return result;
 }
private:
 void bfs(map<string,int> &mapr, string &S, int start) {
 if(S.length() - start < sum * len) return;
 int position;
 map<string,int>::iterator it;
 int min = S.length();
 for(it = mapr.begin(); it != mapr.end(); it++) {
 string item = it->first;
 if((position = S.find(item,start)) == string::npos) return;
 if(position < min)
 min = position;
 }
 int i = 0;
 int end;
 if(bfsStep(mapr,min,S,end)) {
 end = min + 1;
 result.push_back(min);
 }
 end = min + 1;
 if(end >= S.length()) return;
 return bfs(mapr, S, end);
 }
 void resetMapr(map<string,int> &mapr) {
 int i = 0;
 map<string,int>::iterator it;
 for(it = mapr.begin(); it != mapr.end(); it++) {
 it->second = copy[i++];
 }
 }
 bool bfsStep(map<string,int> &mapr, int pos, string &S, int &end) {
 int count = 0;
 map<string,int>::iterator it;
 int i;
 for(i = pos; i < S.length(); i+=len) {
 it = mapr.find(string(S, i, len));
 if(it == mapr.end() || it->second <= 0) {
 end = i+len;
 resetMapr(mapr);
 return false;
 }
 it->second--;
 count++;
 if(count == sum) {
 resetMapr(mapr);
 return true;
 }
 }
 resetMapr(mapr);
 if(count == sum) return true;
 end = i;
 return false;
 }
};

[leetcode_91]Decode Ways

Sat, 23 May 2015 03:11:56 +0000

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.

Initially I used search, which timed out.

Then I realized that if we search from the end, many redundant states can not only be stored but also avoid redundant computation.

Also pay attention to the case where 0 is present.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class Solution {
public:
 int counts[10000];
 int numDecodings(string s) {
 if(s.length() <= 0 || (s.length() == '1' && s[0] == '0'))return 0;
 if(s[s.length()-1] != '0')counts[s.length() - 1] = 1;
 else counts[s.length()-1] = 0;
 counts[s.length()] = 1;
 for(int i = s.length()-2;i >= 0;i--) {
 if(s[i] == '0') {
 counts[i] = 0;
 continue;
 }
 if(s[i] == '1' || (s[i] == '2'&&s[i+1] <= '6'))counts[i] = counts[i+1] + counts[i+2];
 else
 counts[i] = counts[i+1];
 }
 return counts[0];
 }
};

[leetcode_149]Max Points on a Line

Sat, 23 May 2015 03:08:49 +0000

Determine the maximum number of points from a set that lie on the same line.
Seeing the low acceptance rate made me nervous, but the other problems were getting harder and I could not solve them.
So I came up with an O(n^3) approach – could it pass? I thought about optimizing: represent each line as:
ax + by + c = 0
where a is always positive.
The optimization was to use a hash_map to check whether a given (a, b, c) has already been computed. It is not a great optimization.
But the result was surprising: without optimization it ran in 16ms, with optimization 284ms. The reason is that I used map, whose lookup is O(log n) instead of O(1).
Anyway, it did not pass on the first try either – note the edge case of duplicate points.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65


class Solution {
public:
 int maxPoints(vector<Point> &points) {
 vector<Point> pointstmp;
 pointstmp.clear();
 int counts[1000];
 for(int i = 0; i < points.size(); i++) {
 int tmp = 0;
 int j;
 for(j = 0; j < pointstmp.size(); j++) {
 if(pointstmp[j].x == points[i].x && pointstmp[j].y == points[i].y) {
 break;
 }
 }
 if(j < pointstmp.size()) {
 counts[j]++;
 } else {
 pointstmp.push_back(points[i]);
 counts[pointstmp.size()-1] = 1;
 }
 }
 if(pointstmp.size() == 0) return 0;
 if(pointstmp.size() == 1) return counts[0];
 if(pointstmp.size() == 2) return counts[0] + counts[1];
 int ans = 2;
 map<vector<int>, bool> mapv;
 mapv.clear();
 for(int i = 0; i < pointstmp.size()-2; i++) {
 for(int j = i+1; j < pointstmp.size()-1; j++) {
 int x1 = pointstmp[i].x;
 int y1 = pointstmp[i].y;
 int x2 = pointstmp[j].x;
 int y2 = pointstmp[j].y;
 if(x1 == x2 && y1 == y2) continue;
 int a = y1 - y2;
 int b = -(x1 - x2);
 int c = (x1 - x2) * y1 - (y1 - y2) * x1;
 // if(a < 0) {
 // a = a * (-1);
 // b = b * (-1);
 // c = c * (-1);
 // }
 // vector<int> tmp;
 // tmp.clear();
 // tmp.push_back(a);
 // tmp.push_back(b);
 // tmp.push_back(c);
 // if(mapv.find(tmp) != mapv.end()) continue;
 // mapv.insert(map<vector<int>, bool>::value_type(tmp, true));
 int count = counts[i] + counts[j];
 for(int k = j+1; k < pointstmp.size(); k++) {
 int x = pointstmp[k].x;
 int y = pointstmp[k].y;
 if(isInLine(a, b, c, x, y)) count += counts[k];
 }
 if(count > ans) ans = count;
 }
 }
 return ans;
 }
private:
 bool isInLine(int a, int b, int c, int x, int y) {
 return a * x + b * y + c == 0;
 }
};

[leetcode_132]Palindrome Partitioning II

Sat, 23 May 2015 03:07:49 +0000

Initially used search, TLE:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


class Solution {
public:
 int ans;
 int minCut(string s) {
 ans = 0xffffff;
 if(s.length() <= 0)return ans;
 bool *flag = new bool[s.length()+1];
 for(int i = 0;i <= s.length();i++)
 flag[i] = false;
 flag[0] = true;
 PartitionStep(s,1,flag);
 return ans;
 }
private:
 void PartitionStep(string s,int step,bool *flag) {
 if(step == s.length()) {
 int i;
 flag[step] = true;
 for(i = step-1;i >= 0;i--) {
 if(flag[i] == true)break;
 }
 if(IsPalindrome(s,i,step-1)) {
 int count = 0;
 for(int i = 0;i <=step;i++) {
 if(flag[i] == true)count++;
 }
 if(count-2 < ans)ans = count-2;
 }
 flag[step] =false;
 return ;
 }
 flag[step] = true;
 int i;
 for(i = step-1;i >= 0;i--) {
 if(flag[i] == true)break;
 }
 if(IsPalindrome(s,i,step-1)) {
 PartitionStep(s,step+1,flag);
 }
 flag[step] = false;
 PartitionStep(s,step+1,flag);
 }
 bool IsPalindrome(string s,int i,int j) {
 while(i < j) {
 if(s[i] != s[j])return false;
 i++;
 j--;
 }
 return true;
 }
};

Later I used DP. I must admit I studied someone else’s approach:
http://blog.csdn.net/doc_sgl/article/details/13418125

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


class Solution {
public:
 int minCut(string s) {
 int lens = s.length();
 bool **isP;
 isP = new bool *[lens];
 for(int i = 0;i < lens;i++) {
 isP[i] = new bool [lens];
 for(int j = 0;j < lens;j++) {
 isP[i][j] = false;
 }
 }
 for(int i = 0;i < lens;i++)
 isP[i][i] = true;

 int * dp = new int[lens+1];
 for(int i = lens;i >= 0;i--)
 dp[i] = lens - 1 - i;
 for(int i = lens-1;i >= 0;i--) {
 for(int j = i;j < lens;j++) {
 if(((j - i) <= 2 || isP[i+1][j-1]) && s[i] == s[j]) {
 isP[i][j] = true;
 dp[i] = dp[i] > dp[j+1]+1?dp[j+1]+1:dp[i];
 }
 }
 }
 return dp[0];
 }
};

[leetcode_124]Binary Tree Maximum Path Sum

Sat, 23 May 2015 03:06:12 +0000

Find the maximum path sum in a binary tree.
Given a binary tree, find the maximum path sum.

The path may start and end at any node in the tree.

For example:
Given the below binary tree,

Return 6.

Recursively explore all cases. For each node, the answer is: max(node value alone, left subtree max contribution + node value, left subtree max contribution + node value + right subtree max contribution, node value + right subtree max contribution).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


class Solution {
public:
 int result;
 int maxPathSum(TreeNode *root) {
 result = 0x80000001;
 if(root != NULL) {
 queryNodes(root);
 }
 return result;
 }
private:
 void queryNodes(TreeNode *node) {
 if(node->left == NULL && node->right == NULL) {
 if(node->val > result) result = node->val;
 return;
 }
 if(node->left == NULL) {
 queryNodes(node->right);
 node->val = node->val + node->right->val >= node->val ? node->val + node->right->val : node->val;
 if(node->val > result) result = node->val;
 return;
 }
 if(node->right == NULL) {
 queryNodes(node->left);
 node->val = node->val + node->left->val >= node->val ? node->val + node->left->val : node->val;
 if(node->val > result) result = node->val;
 return;
 }
 queryNodes(node->right);
 queryNodes(node->left);
 if(node->val > result) result = node->val;
 if(node->val + node->left->val > result) result = node->val + node->left->val;
 if(node->val + node->right->val > result) result = node->val + node->right->val;
 if(node->val + node->right->val + node->left->val > result) result = node->val + node->right->val + node->left->val;
 int max = node->val + node->left->val >= node->val + node->right->val ? node->val + node->left->val : node->val + node->right->val;
 node->val = max >= node->val ? max : node->val;
 }
};

[leetcode_143]Reorder List

Sat, 23 May 2015 03:05:13 +0000

Basic singly linked list operations including reversing and calculating length.
The problem requires:
1->2->3->4 => 1->4->2->3, an interleaving operation.
Given a singly linked list L: L0->L1->…->Ln-1->Ln,
reorder it to: L0->Ln->L1->Ln-1->L2->Ln-2->…

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


class Solution {
public:
 void reorderList(ListNode *head) {
 int len = getLength(head);
 if(len <= 2)return ;
 int pos = len%2==0?len/2:len/2+1;
 ListNode * headend = getListNode(head,pos-1);
 ListNode * head2 = getListNode(head,pos);
 headend -> next = NULL;
 head2 = reverseListNode(head2);
 ListNode * headc = head;
 while(head2 != NULL) {
 ListNode * headnext = head->next;
 ListNode * head2next = head2->next;
 head->next = head2;
 head2->next = headnext;
 head = headnext;
 head2 = head2next;
 }
 head = headc;
 }
private:
 ListNode * reverseListNode(ListNode * head) {
 ListNode * before = head;
 ListNode * now = head->next;
 while(now != NULL) {
 ListNode * next = now->next;
 now->next = before;
 before = now;
 now = next;
 }
 head->next = NULL;
 return before;
 }
 int getLength(ListNode *head) {
 int len = 0;
 while(head != NULL) {
 len++;
 head = head->next;
 }
 return len;
 }
 ListNode *getListNode(ListNode *head,int pos) {
 int i = 0;
 while(i < pos) {
 head = head->next;
 i++;
 }
 return head;
 }
};

[leetcode_10]Regular Expression Matching

Sat, 23 May 2015 03:04:11 +0000

Search with pruning. However, there was a strange issue where one test case would not pass. I had to add a pruning condition specifically for that test case to get AC. So I should really look into the DP approach. At the time I kept trying to use a greedy method, but clearly there are many places requiring backtracking, so the greedy approach does not work well. Also note that a* should be treated as a unit – it represents the empty string or a string of multiple as.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


class Solution {
public:
 bool result;
 bool isMatch(const char *s, const char *p) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 result = false;
 int lens = strlen(s);
 int lenp = strlen(p);
 if(p[lenp-1] != '*' && s[lens-1] != p[lenp-1] && p[lenp-1]!='.')return result;
 matchStep(s,p);
 return result;
 }
private:
 void matchStep(const char * s,const char * p) {
 if(result)return;
 if(*s == '\0' && *p == '\0') {
 result = true;
 return;
 }
 if(*s == '\0') {
 if(*(p+1) == '*') {
 matchStep(s,p+2);
 return ;
 }
 }
 if(*s == '\0' || *p == '\0')return;
 if(*(p+1) != '\0') {
 if(*(p+1) != '*') {
 if(*s == *p || *p == '.') {
 matchStep(s+1,p+1);
 }
 else
 return;
 }
 else {
 if(*s != *p && *p != '.') {
 matchStep(s,p+2);
 }
 else {
 matchStep(s,p+2);
 matchStep(s+1,p);
 matchStep(s+1,p+2);
 }
 }
 }
 else {
 if(*s == *p || *p == '.') {
 matchStep(s+1,p+1);
 }
 else
 return;
 }
 }
};

[leetcode_28]Implement strStr()

Sat, 23 May 2015 03:02:31 +0000

I originally wanted to use KMP, but my getNext implementation was terrible and timed out.
I have been really exhausted lately. I will take a break for a while. I passed using naive pattern matching instead.
After some time I will practice again. For now I will read Kernighan and Ritchie’s “The C Programming Language” and “Computer Systems: A Programmer’s Perspective.” I am truly tired and under a lot of pressure.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


class Solution {
public:
 char *strStr(char *haystack, char *needle) {
 int lenh = strlen(haystack);
 int lenn = strlen(needle);
 if(lenh == 0 && lenn == 0)return haystack;
 for(int i = 0;i < lenh;i++) {
 if(strlen(haystack + i) >= lenn&&isEqual(haystack,i,needle))return haystack + i;
 }
 return NULL;
 }
private:
 bool isEqual(char *haystack,int i,char * needle) {
 int j;
 for(j = 0;j < strlen(needle);j++) {
 if(needle[j] != haystack[i+j])break;
 }
 if(j == strlen(needle))return true;
 else return false;
 }
};

KMP:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


class Solution {
public:
 int lenh;
 int lenn;
 int *next;
 char *strStr(char *haystack, char *needle) {
 lenh = strlen(haystack);
 lenn = strlen(needle);
 if(lenn == 0)return haystack;
 if(lenh < lenn)return NULL;
 next = new int[lenn];
 getNext(needle);
 int k = 0;
 int j = 0;
 while(j < lenh) {
 if(k == -1 || needle[k] == haystack[j]) {
 k++;
 j++;
 if(k == lenn)return haystack + j - lenn;
 }
 else
 k = next[k];
 }
 return NULL;
 }
private:
 void getNext(char *needle) {
 int k = -1;
 int j = 0;
 next[j] = k;
 while(j < lenn-1) {
 if(k == -1 || needle[k] == needle[j]) {
 k++;
 j++;
 next[j] = k;
 }
 else
 k = next[k];
 }
 }
};

[leetcode_65]Valid Number

Sat, 23 May 2015 03:00:04 +0000

This problem asks you to determine whether a string is a valid number. However, the test cases are quite tricky… Perhaps I am just not skilled enough – my definition didn’t match the expected output, and I had to fix it many times. No wonder the acceptance rate for this problem is so low.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99


class Solution {
public:
 bool isNumber(const char *s) {
 string str = "";
 int len = strlen(s);
 int i = 0;
 for(;i < len;i++) {
 if(s[i] == ' ')continue;
 else break;
 }
 for(;i < len;i++) {
 str.push_back(s[i]);
 }
 for(int i = str.length()-1;i >= 0;i--) {
 if(str[i] == ' ') {
 str.erase(i);
 }
 else
 break;
 }
 return isNumberString(str);
 }
private:
 bool isNumberString(string s) {
 // Does it have a sign?
 // Does it have a decimal point?
 // Does it contain 'e'?
 // Does it have leading zeros?
 int len = s.length();
 if(len <= 0)return false;
 if(len == 1) {
 if(s[0] < '0' || s[0] > '9')return false;
 else return true;
 }
 int start = 0;
 if(s[0] == '+' || s[0] == '-') {
 start = 1;
 }
 bool isZeroAllowed = true;
 bool isPotAllowed = false;
 bool isEallowed = false;

 bool once = true;

 if(s[start] == '.') {
 if(len >= start + 2) {
 if(s[start + 1] >= '0' && s[start + 1] <= '9') {
 isZeroAllowed = true;
 isPotAllowed = false;
 isEallowed = true;
 once = false;
 start = start + 2;
 }
 else
 return false;
 }
 else
 return false;
 }
 for(int i = start;i < len;i++) {
 if(s[i] == '.' && isPotAllowed == false) {
 return false;
 }
 if(s[i] == '.' && isPotAllowed == true) {
 isPotAllowed = false;
 continue;
 }
 if(s[i] == 'e' && isEallowed == false) {
 return false;
 }
 if(s[i] == 'e' && isEallowed == true) {
 isEallowed = false;
 isPotAllowed = false;
 once = false;
 if(i + 1 >= len)return false;
 if(s[i+1] == '-' || s[i+1] == '+') {
 if(i+2 >= len)return false;
 if(s[i+2] < '0' || s[i+2] > '9')return false;
 i+=2;
 continue;
 }
 if(s[i+1] < '0' || s[i+1] > '9')return false;
 continue;
 }
 if(s[i] >= '0' && s[i] <= '9') {
 if(once == true) {
 isZeroAllowed = true;
 isPotAllowed = true;
 isEallowed = true;

 once = false;
 }
 continue;
 }
 return false;
 }
 return true;
 }
};

[leetcode_29]Divide Two Integers

Sat, 23 May 2015 02:58:15 +0000

Simulate integer division without using multiplication, modulo, or division operators.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


class Solution {
public:
 double exp[100];
 int divide(int dividend, int divisor) {
 return divided(dividend, divisor);
 }
private:
 int divided(double dividend, double divisor) {
 int flag = 1;
 if((dividend > 0 && divisor < 0) || (dividend < 0 && divisor > 0))
 flag = -1;
 if(dividend < 0) {
 dividend = abs(dividend);
 }
 if(divisor < 0) {
 divisor = abs(divisor);
 }
 int i = 0;
 exp[i++] = divisor;
 while(exp[i-1] < dividend) {
 exp[i++] = exp[i-1] + exp[i-1];
 }
 int ans = 0;
 i--;
 while(i >= 0) {
 if(dividend >= exp[i]) {
 ans += (int)pow(2.0, i);
 dividend -= exp[i];
 }
 else {
 i--;
 }
 }
 if(flag == -1) return ~ans + 1;
 else return ans;
 }
};

[leetcode_150] Evaluate Reverse Polish Notation

Sat, 23 May 2015 02:57:15 +0000

Reverse Polish Notation – can be solved using a stack.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


class Solution {
public:
 int evalRPN(vector<string> &tokens) {
 stack<int> st;
 for(int i = 0; i < tokens.size(); i++) {
 if(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/") {
 int num1 = st.top();
 st.pop();
 int num2 = st.top();
 st.pop();
 if(tokens[i] == "+") {
 st.push(num1 + num2);
 }
 else if(tokens[i] == "-") {
 st.push(num2 - num1);
 }
 else if(tokens[i] == "*") {
 st.push(num1 * num2);
 }
 else if(tokens[i] == "/") {
 st.push(num2 / num1);
 }
 }
 else {
 st.push(genNum(tokens[i]));
 }
 }
 return st.top();
 }
private:
 int genNum(string s) {
 int flag = 1;
 if(s[0] == '-') {
 flag = -1;
 s = string(s, 1);
 }
 int num = 0;
 for(int i = s.length() - 1; i >= 0; i--) {
 num += (s[i] - '0') * (int)pow(10.0, (int)s.length() - 1 - i);
 }
 return num * flag;
 }
};

[leetcode_135]Candy

Sat, 23 May 2015 02:56:07 +0000

Children are standing in a line to receive candy. Each child must receive at least one candy, and each child has a rating. Children with higher ratings must have more candy than their neighbors.
What is the minimum number of candies needed?
Simulate in order: assume the first child gets one candy. If the next child has a lower rating, the next child gets one fewer, and the previous child’s count increases by one. We need to track how many children before each child have consecutively higher ratings.
If the next child has a higher rating, they get one more candy than the previous child. Simulate accordingly. However, I got Wrong Answer many times T_T.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


class Solution {
public:
 int candy(vector<int> &ratings) {
 int len = ratings.size();
 if(len == 0 || len == 1)return len;
 vector<int>bigger(ratings.size(),0);
 int count = 1;
 int now = 1;
 int max = 0;
 int i;
 for(i = 1;i < ratings.size();i++) {
 if(ratings[i] > ratings[i-1]) {
 if(max != 0) {
 if(bigger[i-1] < max-1) {
 count += max-1 - bigger[i-1];
 }
 }
 max = 0;
 bigger[i] = 0;
 now += 1;
 count += now;
 }
 else
 if(ratings[i] < ratings[i-1]) {
 bigger[i] = bigger[i-1] + 1;
 if(now == 1) {
 count += bigger[i] + now;
 }
 else {
 max = now;
 now = 1;
 count += bigger[i] + now - (max-1);
 }
 }
 else {
 if(max != 0) {
 if(bigger[i-1] < max-1) {
 count += max-1 - bigger[i-1];
 }
 }
 max = 0;
 bigger[i] = 0;
 now = 1;
 count += 1;
 }
 }
 if(max != 0) {
 if(bigger[i-1] < max-1) {
 count += max-1 - bigger[i-1];
 }
 }
 return count;
 }
};

[leetcode_71]Simplify Path

Sat, 23 May 2015 02:55:03 +0000

Simplify the input path to a Unix-style path. This can be solved using a stack.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


class Solution {
public:
 string simplifyPath(string path) {
 vector<string> paths;
 paths.clear();
 char * split = strtok(const_cast<char*>(path.c_str()), "/");
 while(split != NULL) {
 paths.push_back(split);
 split = strtok(NULL, "/");
 }
 stack<char*> st;
 for(int i = 0; i < paths.size(); i++) {
 if(strcmp(paths[i], ".") == 0) continue;
 if(strcmp(paths[i], "..") == 0) {
 if(!st.empty()) st.pop();
 }
 else {
 st.push(paths[i]);
 }
 }
 paths.clear();
 while(!st.empty()) {
 paths.push_back(st.top());
 st.pop();
 }
 string spath = "";
 for(int i = paths.size() - 1; i >= 0; i--) {
 spath = spath + string("/");
 spath = spath + string(paths[i]);
 }
 if(spath == "")
 spath = spath + string("/");
 return spath;
 }
};

[leetcode_139]Word Break

Sat, 23 May 2015 02:53:55 +0000

Given a dictionary, determine whether the input word can be segmented into words found in the dictionary.
Brute force with pruning.
Initially it timed out. I added an extra check to verify whether all characters in the current substring exist in the dictionary. But I feel like I may have exploited a weakness in the test data.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


class Solution {
public:
 bool result;
 bool letters[26];
 bool wordBreak(string s, unordered_set<string> &dict) {
 result = false;
 for(int i = 0;i < 26;i++)
 letters[i] = false;
 for(string it:dict) {
 for(int i = 0;i < it.length();i++) {
 letters[it[i] - 'a'] = true;
 }
 }
 for(int i = s.length();i > 0;i--) {
 if(existLetters(string(s,0,i)) == false)return false;
 if(dict.find(string(s,0,i)) != dict.end()) {
 if(i == s.length())return true;
 else {
 wordBreakStep(s,i,dict);
 }
 }
 }
 return result;
 }
private:
 bool existLetters(string s) {
 for(int i = 0;i < s.length();i++) {
 if(letters[s[i] - 'a'] == false)return false;
 }
 return true;
 }
 void wordBreakStep(string s,int start,unordered_set<string> &dict) {
 if(result == true)return;
 for(int i = s.length() - start;i > 0;i--) {
 if(existLetters(string(s,start,i)) == false)return;
 if(dict.find(string(s,start,i)) != dict.end()) {
 if(i == s.length()-start) {
 result = true;
 return;
 }
 else {
 wordBreakStep(s,start + i,dict);
 }
 }
 }
 }
};

[leetcode_97]Interleaving String

Sat, 23 May 2015 02:52:47 +0000

Given strings s1 and s2, determine whether s3 is formed by interleaving s1 and s2 while preserving their original order.
Initially I tried simulation, but there is a problem: what if s1[p1] and s2[p2] are both equal to s3[p3]? In that case, we would need to save state and perform a search.
As expected, it timed out.
I found online that DP can be used:
f[i][j] = f[i-1][j] + s1[i] && s1[i] == s3[k]
f[i][j] = f[i][j-1](i+j = k) && s2[j] == s3[j]
The k-th character in s3 is fully matched only when it equals either the i-th character of s1 or the j-th character of s2.
Enumerate all cases, at most n^2.
Output f[i][j] where i = s1.length(), j = s2.length(), and i+j = s3.length().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class Solution {
public:
 bool ***f;
 bool isInterleave(string s1, string s2, string s3) {
 if(s1.length() + s2.length() != s3.length())return false;
 bool f[500][500];
 for(int i = 0;i < 500;i++) {
 for(int j = 0;j < 500;j++) {
 f[i][j] = false;
 }
 }
 f[0][0] = true;
 for(int i = 1;i <= s3.length();i++) {
 for(int j = 0;j < i;j++) {
 if(f[j][i-1-j] && i-1-j<=s2.length() && j+1 <= s1.length() && s1[j] == s3[i-1]) {
 f[j+1][i-1-j] = true;
 }
 if(f[j][i-1-j] && j <= s1.length() && i-1-j+1 <= s2.length() && s2[i-1-j] == s3[i-1]) {
 f[j][i-1-j+1] = true;
 }
 }
 }
 return f[s1.length()][s2.length()];
 }
};

[leetcode_32]Longest Valid Parentheses

Sat, 23 May 2015 02:51:31 +0000

Find the longest substring that forms a valid parentheses sequence. This can be solved using a stack.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class Solution {
public:
 int longestValidParentheses(string s) {
 stack<int> st;
 st.push(-1);
 int max = 0;
 int i = 0;
 while(i < s.length()) {
 int top = st.top();
 if(top == -1) {
 st.push(i);
 }
 else {
 if(s[top] == '(' && s[i] == ')') {
 st.pop();
 }
 else {
 st.push(i);
 }
 }
 i++;
 }
 int now = s.length();
 while(!st.empty()) {
 int before = st.top();
 st.pop();
 if((now - 1 - before) % 2 == 0 && now - 1 - before > max)
 max = now - 1 - before;
 now = before;
 }
 return max;
 }
};

[leetcode_79]Word Search

Sat, 23 May 2015 02:44:16 +0000

A simple search problem.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


class Solution {
public:
 bool result;
 bool exist(vector<vector<char>> &board, string word) {
 vector<vector<int>> flag;
 flag.clear();
 for(int i = 0; i < board.size(); i++) {
 vector<int> item(board[i].size(), 0);
 flag.push_back(item);
 }
 result = false;
 int pos = 0;
 for(int i = 0; i < board.size(); i++) {
 for(int j = 0; j < board[i].size(); j++) {
 if(flag[i][j] == 0 && board[i][j] == word[pos]) {
 flag[i][j] = 1;
 pos++;
 existStep(board, flag, word, i, j, pos);
 pos--;
 flag[i][j] = 0;
 }
 }
 }
 return result;
 }
private:
 void existStep(vector<vector<char>> &board, vector<vector<int>> &flag, string word, int x, int y, int pos) {
 if(result) return;
 if(pos >= word.length()) {
 result = true;
 return;
 }
 int walk[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
 for(int i = 0; i < 4; i++) {
 int xn = x + walk[i][0];
 int yn = y + walk[i][1];
 if(xn < 0 || xn >= board.size() || yn < 0 || yn >= board[0].size()) continue;
 if(flag[xn][yn] == 1 || board[xn][yn] != word[pos]) continue;
 flag[xn][yn] = 1;
 pos++;
 existStep(board, flag, word, xn, yn, pos);
 pos--;
 flag[xn][yn] = 0;
 }
 }
};

[leetcode_85] Maximal Rectangle

Sat, 23 May 2015 02:43:10 +0000

I solved this problem using brute force. The stack-based algorithm for finding the largest rectangle in a histogram seemed to have a high worst-case complexity.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


class Solution {
public:
 int maximalRectangle(vector<vector<char>> &matrix) {
 int max = 0;
 int **map = new int*[matrix.size()];
 for(int i = 0; i < matrix.size(); i++) {
 map[i] = new int[matrix[0].size()];
 }
 for(int i = 0; i < matrix.size(); i++) {
 int height = 0;
 for(int j = matrix[0].size() - 1; j >= 0; j--) {
 if(matrix[i][j] == '1') map[i][j] = ++height;
 else {
 height = 0;
 map[i][j] = height;
 }
 }
 }
 for(int i = 0; i < matrix.size(); i++) {
 for(int j = 0; j < matrix[0].size(); j++) {
 int width = map[i][j];
 max = Max(max, width);
 for(int k = i + 1; k < matrix.size(); k++) {
 if(map[k][j] == 0) break;
 else {
 width = Min(width, map[k][j]);
 max = Max(max, width * (k - i + 1));
 }
 }
 }
 }
 return max;
 }
private:
 int Max(int a, int b) {
 return a > b ? a : b;
 }
 int Min(int a, int b) {
 return a < b ? a : b;
 }
};

[leetcode_43] Multiply Strings

Sat, 23 May 2015 02:42:03 +0000

Big integer multiplication.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


class Solution {
public:
 string multiply(string num1, string num2) {
 string ans = "";
 int inbit;
 // gen table
 vector<vector<int>> table;
 table.clear();
 for(int i = num1.length()-1; i >= 0; i--) {
 vector<int> item;
 item.clear();
 inbit = 0;
 for(int k = 0; k < num1.length()-1-i; k++)
 item.push_back(0);
 for(int j = num2.length()-1; j >= 0; j--) {
 int tmp = (num1[i] - '0') * (num2[j] - '0') + inbit;
 inbit = tmp / 10;
 item.push_back(tmp % 10);
 }
 if(inbit != 0)
 item.push_back(inbit);
 table.push_back(item);
 }
 // calc ansint
 vector<int> ansint;
 ansint.clear();
 int len = table[table.size()-1].size();
 inbit = 0;
 for(int i = 0; i < len; i++) {
 int tmp = inbit;
 for(int j = 0; j < table.size(); j++) {
 if(table[j].size() > i) {
 tmp += table[j][i];
 }
 }
 inbit = tmp / 10;
 ansint.push_back(tmp % 10);
 }
 if(inbit != 0)
 ansint.push_back(inbit);
 bool flag = false;
 for(int i = ansint.size()-1; i >= 0; i--) {
 if(ansint[i] == 0 && i != 0 && flag == false) continue;
 ans.push_back(ansint[i] + '0');
 flag = true;
 }
 return ans;
 }
};

[leetcode_93]Restore IP Addresses

Sat, 23 May 2015 02:40:56 +0000

Output all possible IP addresses that can be formed from a digit string. Watch out for the case with leading zeros.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


class Solution {
public:
 vector<string> restoreIpAddresses(string s) {
 vector<string> ans;
 ans.clear();
 if(s.length() > 12)return ans;
 vector<int> split;
 split.clear();
 split.push_back(0);
 for(int i = 0;i < s.length();i++) {
 int num = genInt(split[split.size()-1],i,s);
 if(num >= 0&&num <= 255) {
 split.push_back(i);
 searchS(s,split,ans);
 split.pop_back();
 }
 }
 return ans;
 }
private:
 int genInt(int start,int end,string s) {
 string numstr(s,start,end-start+1);
 if(numstr.length() >= 4)return -1;
 if(end > start && s[start] == '0')return -1;
 int num = 0;
 bool flag = false;
 for(int i = numstr.length()-1;i >= 0;i--) {
 flag = true;
 num += (numstr[i] - '0')*(int)pow(10.0,(int)numstr.length() - 1 - i);
 }
 if(!flag)return -1;
 return num;
 }
 void searchS(string s,vector<int>& split,vector<string>& ans) {
 if(split.size() == 5) {
 string tmp = s;
 for(int i = 1;i < split.size()-1;i++) {
 tmp.insert(tmp.begin()+split[i]+i,'.');
 }
 ans.push_back(tmp);
 return;
 }
 if(split.size() == 4) {
 int numlast = genInt(split[split.size()-1]+1,s.length()-1,s);
 if(numlast >= 0&&numlast <= 255) {
 split.push_back(s.length()-1);
 searchS(s,split,ans);
 split.pop_back();
 }
 return;
 }
 for(int i = split[split.size()-1]+1;i < s.length();i++) {
 int num = genInt(split[split.size()-1]+1,i,s);
 if(num >= 0&&num <= 255) {
 split.push_back(i);
 searchS(s,split,ans);
 split.pop_back();
 }
 }
 }
};

[leetcode_54]Spiral Matrix

Sat, 23 May 2015 02:39:49 +0000

Output a matrix in spiral order. Watch out for edge cases with single rows and single columns.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86


class Solution {
public:
 vector<int> spiralOrder(vector<vector<int>> &matrix) {
 vector<int> ans;
 ans.clear();
 if(matrix.size() <= 0) return ans;
 int count = 0;
 int sum = matrix.size() * matrix[0].size();
 int px = 0;
 int py = 0;

 int xa = 0;
 int xb = matrix.size() - 1;
 int ya = 0;
 int yb = matrix[0].size() - 1;

 int dir = 0;
 while(count < sum) {
 ans.push_back(matrix[px][py]);
 switch(dir) {
 case 0:
 if(py == yb) {
 dir++;
 dir %= 4;
 xa++;
 px++;
 break;
 }
 py++;
 if(py == yb) {
 dir++;
 dir %= 4;
 xa++;
 }
 break;
 case 1:
 if(px == xb) {
 dir++;
 dir %= 4;
 yb--;
 py--;
 break;
 }
 px++;
 if(px == xb) {
 dir++;
 dir %= 4;
 yb--;
 }
 break;
 case 2:
 if(py == ya) {
 dir++;
 dir %= 4;
 xb--;
 px--;
 break;
 }
 py--;
 if(py == ya) {
 dir++;
 dir %= 4;
 xb--;
 }
 break;
 case 3:
 if(px == xa) {
 dir++;
 dir %= 4;
 ya++;
 py++;
 break;
 }
 px--;
 if(px == xa) {
 dir++;
 dir %= 4;
 ya++;
 }
 break;
 }
 count++;
 }
 return ans;
 }
};

[leetcode_57]Insert Interval

Sat, 23 May 2015 02:38:39 +0000

Insert an interval, then output the merged result.
I took a shortcut here by directly reusing the merge function from the previous problem.
However, the problem states the intervals are already sorted, so the time complexity could be reduced to O(n).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


int cmp(Interval a, Interval b) {
 if (a.start == b.start)
 return a.end < b.end;
 return a.start < b.start;
}

class Solution {
public:
 vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) {
 intervals.push_back(newInterval);
 return merge(intervals);
 }
private:
 vector<Interval> merge(vector<Interval> &intervals) {
 sort(intervals.begin(), intervals.end(), cmp);
 vector<Interval> ans;
 ans.clear();
 if (intervals.size() <= 0) return ans;
 Interval item = intervals[0];
 for (int i = 1; i < intervals.size(); i++) {
 if (item.end < intervals[i].start) {
 ans.push_back(item);
 item = intervals[i];
 } else {
 if (item.end < intervals[i].end)
 item.end = intervals[i].end;
 }
 }
 ans.push_back(item);
 return ans;
 }
};

[leetcode_56]Merge Intervals

Sat, 23 May 2015 02:37:38 +0000

Merge intervals. First, sort as a preprocessing step.
Then iterate through each interval and check if it can be merged with the following ones.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


int cmp(Interval a, Interval b) {
 if(a.start == b.start)
 return a.end < b.end;
 return a.start < b.start;
}

class Solution {
public:
 vector<Interval> merge(vector<Interval> &intervals) {
 sort(intervals.begin(), intervals.end(), cmp);
 vector<Interval> ans;
 ans.clear();
 if(intervals.size() <= 0) return ans;
 Interval item = intervals[0];
 for(int i = 1; i < intervals.size(); i++) {
 if(item.end < intervals[i].start) {
 ans.push_back(item);
 item = intervals[i];
 }
 else {
 if(item.end < intervals[i].end)
 item.end = intervals[i].end;
 }
 }
 ans.push_back(item);
 return ans;
 }
};

[leetcode_37]Sudoku Solver

Sat, 23 May 2015 02:36:30 +0000

Sudoku solver – haha, I had a problem that tormented me for a long time before, and I had written this solver, so I just adapted it.
First, there are published papers showing that puzzles with fewer than 17 given cells have no unique solution.
Then, just use brute force. The trick is: start searching from the cells with the fewest possibilities.

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153


struct Pointxy {
 int x;
 int y;
 int val;
};
int cmp(Pointxy a, Pointxy b) {
 return a.val < b.val;
}
class Solution {
public:
 int bitarray[9];
 int map[9][9];
 bool result;
 int CountOnes(int v)
 {
 int number = 0;
 while(v)
 {
 v &= (v-1);
 number++;
 }
 return number;
 }
 int GetRegionOfBoard(int x, int y) {
 if(x >= 0 && x < 3) {
 if(y >= 0 && y < 3)return 0;
 if(y >= 3 && y < 6)return 1;
 if(y >= 6 && y < 9)return 2;
 }
 if(x >= 3 && x < 6) {
 if(y >= 0 && y < 3)return 3;
 if(y >= 3 && y < 6)return 4;
 if(y >= 6 && y < 9)return 5;
 }
 if(x >= 6 && x < 9) {
 if(y >= 0 && y < 3)return 6;
 if(y >= 3 && y < 6)return 7;
 if(y >= 6 && y < 9)return 8;
 }
 }
 bool RefeshMap(int x, int y){
 int set_tmp = 0;
 for(int i = 0; i < 9; i++) {
 if(CountOnes(map[x][i]) == 1) {
 set_tmp = set_tmp | map[x][i];
 }
 if(CountOnes(map[i][y]) == 1) {
 set_tmp = set_tmp | map[i][y];
 }
 }
 int region = GetRegionOfBoard(x, y);
 int x_r = (region / 3 + 1) * 3;
 int y_r = (region % 3 + 1) * 3;
 for(int i = x_r-3; i < x_r; i++) {
 for(int j = y_r-3; j < y_r; j++) {
 if(CountOnes(map[i][j]) == 1) {
 set_tmp = set_tmp | map[i][j];
 }
 }
 }
 if(set_tmp == 511)return false;
 map[x][y] = 511 - set_tmp;
 return true;
 }
 void Move(Pointxy pxy[81], int index, vector<vector<char>> &board) {
 if(result == true)return;
 if(index <= 0) {
 result = true;
 return;
 } else {
 sort(pxy, pxy+index, cmp);
 int pi = pxy[0].x;
 int pj = pxy[0].y;
 for(int ibit = 0; ibit < 9; ibit++) {
 if(result == true)return;
 if(map[pi][pj] & bitarray[ibit]) {
 if(pi == 0 && pj == 6) {
 int hujiulin = 1;
 }
 board[pi][pj] = ibit+1+'0';
 map[pi][pj] -= bitarray[ibit];
 int xtmp[81];
 int ytmp[81];
 int indextmp = 0;
 for(int i = 1; i < index; i++) {
 int xi = pxy[i].x;
 int yi = pxy[i].y;
 if(xi == pi || yi == pj || GetRegionOfBoard(xi, yi) == GetRegionOfBoard(pi, pj)) {
 if(map[xi][yi] & bitarray[ibit]) {
 xtmp[indextmp] = xi;
 ytmp[indextmp++] = yi;
 map[xi][yi] -= bitarray[ibit];
 }
 }
 }
 Pointxy pxyt[81];
 int indext = 0;
 for(int i = 1; i < index; i++) {
 pxyt[indext].x = pxy[i].x;
 pxyt[indext].y = pxy[i].y;
 pxyt[indext].val = CountOnes(map[pxyt[indext].x][pxyt[indext].y]);
 indext++;
 }
 Move(pxyt, indext, board);
 for(int i = 0; i < indextmp; i++) {
 int xi = xtmp[i];
 int yi = ytmp[i];
 map[xi][yi] += bitarray[ibit];
 }
 map[pi][pj] += bitarray[ibit];
 }
 }
 }
 }
 void solveSudoku(vector<vector<char>> &board) {
 for(int i = 0; i < 9; i++) {
 bitarray[i] = (int)pow(2.0, i);
 }
 int count = 0;
 for(int i = 0; i < 9; i++) {
 for(int j = 0; j < 9; j++) {
 if(board[i][j] == '.') {
 map[i][j] = 511;
 } else {
 map[i][j] = bitarray[board[i][j] - '0'-1];
 count++;
 }
 }
 }
 if(count < 17)return;
 Pointxy pxy[81];
 int index = 0;
 for(int i = 0; i < 9; i++) {
 for(int j = 0; j < 9; j++) {
 if(map[i][j] == 511) {
 if(RefeshMap(i, j) == false)return;
 pxy[index].x = i;
 pxy[index].y = j;
 pxy[index++].val = CountOnes(map[i][j]);
 }
 if(CountOnes(map[i][j]) == 1) {
 int k = 0;
 for(k = 0; k < 9; k++) {
 if(map[i][j] == bitarray[k])break;
 }
 board[i][j] = k+1+'0';
 }
 }
 }
 result = false;
 Move(pxy, index, board);
 }
};

[leetcode_138]Copy List with Random Pointer

Sat, 23 May 2015 02:35:14 +0000

Deep copy of a linked list with random pointers.
Using two passes with a map solves this problem in O(n log n) time complexity.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63


class Solution {
public:
 RandomListNode *copyRandomList(RandomListNode *head) {
 int length = getRandomList(head);
 if(length == 0)
 return NULL;
 int index = 0;
 RandomListNode * headb1 = head;
 map<RandomListNode *, int> map_ri;
 map_ri.clear();
 while(head != NULL) {
 map_ri.insert(map<RandomListNode *, int>::value_type(head, index++));
 head = head->next;
 }
 int *pos = new int[length];
 map<RandomListNode *, int>::iterator itri;
 index = 0;
 head = headb1;
 while(head != NULL) {
 itri = map_ri.find(head->random);
 if(itri == map_ri.end())
 pos[index++] = -1;
 else
 pos[index++] = itri->second;
 head = head->next;
 }
 head = headb1;
 map<int, RandomListNode *> map_r;
 map_r.clear();
 index = 0;
 RandomListNode *copy = new RandomListNode(head->label);
 RandomListNode *copymove = copy;
 map_r.insert(map<int, RandomListNode *>::value_type(index++, copymove));
 head = head->next;
 while(head != NULL) {
 RandomListNode * tmp = new RandomListNode(head->label);
 copymove->next = tmp;
 copymove = copymove->next;
 map_r.insert(map<int, RandomListNode *>::value_type(index++, copymove));
 head = head->next;
 }
 copymove = copy;
 index = 0;
 while(copymove != NULL) {
 map<int, RandomListNode *>::iterator it = map_r.find(pos[index++]);
 if(it == map_r.end())
 copymove->random = NULL;
 else
 copymove->random = it->second;
 copymove = copymove->next;
 }
 return copy;
 }
private:
 int getRandomList(RandomListNode *head) {
 int length = 0;
 while(head != NULL) {
 head = head->next;
 length++;
 }
 return length;
 }
};

[leetcode_87]Scramble String

Sat, 23 May 2015 02:33:57 +0000

I’m quite happy that I solved this one independently – the previous two problems had really shaken my confidence. One had a test case I couldn’t pass, and the other had an approach I couldn’t figure out.
Initially I thought of brute force: enumerate every split point, and as long as the left and right substrings are equal after sorting, it works.
Simulate this idea and find where the left-left equal strings occur.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


int cmp(char a,char b) {
 return a < b;
}
class Solution {
public:
 bool isScramble(string s1, string s2) {
 if(s1.length() != s2.length())return false;
 string s1t = s1;
 string s2t = s2;
 sort(s1.begin(),s1.end(),cmp);
 sort(s2.begin(),s2.end(),cmp);
 if(s1 != s2)return false;
 return checkIs(s1t,s2t) || checkIs(s2t,s1t) || checkIs(string(s1t.rbegin(),s1t.rend()),s2t) || checkIs(s2t,string(s1t.rbegin(),s1t.rend()));
 }
private:
 bool checkIs(string s1,string s2) {
 if(s1.length() <= 0)return true;
 if(s1.length() == 1) {
 if(s1[0] == s2[0])return true;
 else return false;
 }
 int i = 0;
 while(i < s1.length()) {
 if(s2[i] != s1[0]) {
 i++;
 continue;
 }
 string s1b(s1,1,i);
 string s2b(s2,0,i);
 sort(s1b.begin(),s1b.end(),cmp);
 sort(s2b.begin(),s2b.end(),cmp);
 if(s1b != s2b) {
 i++;
 continue;
 }
 else
 break;
 }
 if(i == s1.length())return false;
 if(i == s1.length()-1) {
 string s1t = string(s1,1,i);
 string s2t = string(s2,0,i);
 return checkIs(s1t,s2t) || checkIs(s2t,s1t) || checkIs(string(s1t.rbegin(),s1t.rend()),s2t) || checkIs(s2t,string(s1t.rbegin(),s1t.rend()));
 }
 string s1e(s1,i+1);
 string s2e(s2,i+1);
 sort(s1e.begin(),s1e.end(),cmp);
 sort(s2e.begin(),s2e.end(),cmp);
 if(s1e != s2e)return false;
 string s1t = string(s1,1,i);
 string s2t = string(s2,0,i);
 bool flag1 = checkIs(s1t,s2t) || checkIs(s2t,s1t) || checkIs(string(s1t.rbegin(),s1t.rend()),s2t) || checkIs(s2t,string(s1t.rbegin(),s1t.rend()));
 s1t = string(s1,i+1);
 s2t = string(s2,i+1);
 bool flag2 = checkIs(s1t,s2t) || checkIs(s2t,s1t) || checkIs(string(s1t.rbegin(),s1t.rend()),s2t) || checkIs(s2t,string(s1t.rbegin(),s1t.rend()));
 return flag1 && flag2;
 }
};

[leetcode_84]Largest Rectangle in Histogram

Sat, 23 May 2015 02:32:36 +0000

Find the largest rectangle area in a histogram.
Use a stack-based approach. Always keep the stack in increasing order; if not, pop and calculate.
Reference:
http://blog.csdn.net/doc_sgl/article/details/11805519

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


class Solution {
public:
 int largestRectangleArea(vector<int> &height) {
 if(height.size() <= 0) return 0;
 height.push_back(-1);
 int max = 0x80000000;
 vector<int> stack;
 stack.clear();
 stack.push_back(0);
 for(int i = 1; i < height.size(); i++) {
 if(height[stack[stack.size()-1]] <= height[i]) stack.push_back(i);
 else {
 while(stack.size() > 0 && height[stack[stack.size() - 1]] > height[i]) {
 int heighttmpi = stack[stack.size()-1];
 stack.pop_back();
 if(stack.size() == 0) {
 if(height[heighttmpi] * (i-0) > max) max = height[heighttmpi] * (i-0);
 }
 else {
 if(height[heighttmpi] * (i-stack[stack.size()-1]-1) > max) max = height[heighttmpi] * (i-stack[stack.size()-1]-1);
 }
 }
 }
 stack.push_back(i);
 }
 return max;
 }
};

[leetcode_148]Sort List

Sat, 23 May 2015 02:28:03 +0000

Sort a singly linked list.
Using quicksort, one particular test case timed out. Frustrating.
Later I found that even another expert’s custom quicksort couldn’t pass that test case. So I followed his approach and wrote a heap sort instead, but the space complexity is no longer constant.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


class Solution {
public:
 ListNode *sortList(ListNode *head) {
 if(head == NULL || head->next == NULL) return head;
 map<int, vector<ListNode *>> map_nodes;
 map_nodes.clear();
 while(head != NULL) {
 if(map_nodes.find(head->val) == map_nodes.end()) {
 vector<ListNode *> item;
 item.clear();
 item.push_back(head);
 map_nodes.insert(pair<int, vector<ListNode *>>(head->val, item));
 } else {
 map<int, vector<ListNode *>>::iterator it = map_nodes.find(head->val);
 it->second.push_back(head);
 }
 head = head->next;
 }
 map<int, vector<ListNode *>>::iterator it = map_nodes.begin();
 head = it->second[0];
 ListNode *tmp = head;
 for(int i = 1; i < it->second.size(); i++) {
 tmp->next = it->second[i];
 tmp = tmp->next;
 }
 for(; it != map_nodes.end(); it++) {
 tmp->next = it->second[0];
 tmp = tmp->next;
 for(int i = 1; i < it->second.size(); i++) {
 tmp->next = it->second[i];
 tmp = tmp->next;
 }
 }
 tmp->next = NULL;
 return head;
 }
};

[leetcode_60]Permutation Sequence

Sat, 23 May 2015 02:26:50 +0000

Find the k-th permutation of [1, 2, 3, …, n].

Brute force times out. In fact, at each digit you can eliminate a batch of candidates without searching one by one.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


class Solution {
public:
 string getPermutation(int n, int k) {
 count = 0;
 flag = new bool[n+1];
 for(int i = 1;i <= n;i++) {
 flag[i] = false;
 }
 string ans = "";
 string result = "";
 for(int i = 1;i <= n;i++) {
 if(result != "") break;
 if(k > factorial(n-1) + count) {
 count += factorial(n-1);
 continue;
 }
 if(flag[i] == false) {
 flag[i] = true;
 ans.push_back(i + '0');
 getPermutationStep(n, k, 1, ans);
 ans.erase(ans.end()-1);
 flag[i] = false;
 }
 }
 return result;
 }
private:
 int count;
 bool *flag;
 string result;
 void getPermutationStep(int n, int k, int now, string ans) {
 if(result != "") return;
 if(now == n) {
 count++;
 if(k <= count) {
 result = ans;
 }
 return;
 }
 for(int i = 1;i <= n;i++) {
 if(flag[i] == false) {
 if(now==1 && k > factorial(n-now-1) + count) {
 count += factorial(n-now-1);
 continue;
 }
 flag[i] = true;
 ans.push_back(i + '0');
 getPermutationStep(n, k, now+1, ans);
 ans.erase(ans.end()-1);
 flag[i] = false;
 }
 }
 }
}
int factorial(int x) {
 int ans = 1;
 for(int i = 1;i <= x;i++) {
 ans *= i;
 }
 return ans;
}

[leetcode_61]Rotate List

Sat, 23 May 2015 02:25:25 +0000

Rotate a singly linked list by k nodes.
Initially got WA, then realized k needs to be taken modulo the list length.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


class Solution {
public:
 ListNode *rotateRight(ListNode *head, int k) {
 int height = heightList(head);
 if(height == 0)return head;
 k %= height;
 if(height < k || head == NULL || head->next == NULL || k == 0)return head;
 k = height - k;
 ListNode * before = head;
 ListNode * now = head->next;
 k--;
 while(k > 0) {
 k--;
 before = now;
 now = now->next;
 }
 ListNode * tmp = head;
 while(tmp->next != NULL) {
 tmp = tmp->next;
 }
 tmp->next = head;
 before->next = NULL;
 return now;
 }
private:
 int heightList(ListNode * head) {
 int height = 0;
 while(head != NULL) {
 head = head->next;
 height++;
 }
 return height;
 }
};

[leetcode_18]4Sum

Sat, 23 May 2015 02:24:26 +0000

Given an array, find all unique quadruplets whose sum equals the target number.
O(n^3*logn) barely passes. There should be a faster approach.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


int cmp(int a, int b) {
 return a < b;
}
class Solution {
public:
 vector<vector<int>> fourSum(vector<int> &num, int target) {
 sort(num.begin(), num.end(), cmp);
 vector<vector<int>> ans;
 ans.clear();
 if (num.size() <= 3) return ans;
 for (int i = 0; i < num.size() - 3; i++) {
 for (int j = i + 1; j < num.size() - 2; j++) {
 for (int k = j + 1; k < num.size() - 1; k++) {
 int val = target - (num[i] + num[j] + num[k]);
 if (val >= num[k + 1] && findTarget(k + 1, num.size() - 1, val, num)) {
 vector<int> item;
 item.clear();
 item.push_back(num[i]);
 item.push_back(num[j]);
 item.push_back(num[k]);
 item.push_back(val);
 if (!checkExist(ans, item))
 ans.push_back(item);
 }
 }
 }
 }
 return ans;
 }

private:
 bool checkExist(vector<vector<int>> &ans, vector<int> &item) {
 for (int i = 0; i < ans.size(); i++) {
 if (item == ans[i]) return true;
 }
 return false;
 }
 bool findTarget(int left, int right, int target, vector<int> &num) {
 if (left > right) return false;
 int mid = (left + right) / 2;
 if (num[mid] == target) return true;
 else if (num[mid] > target) {
 return findTarget(left, mid - 1, target, num);
 } else {
 return findTarget(mid + 1, right, target, num);
 }
 }
};

[leetcode_123]Best Time to Buy and Sell Stock III

Sat, 23 May 2015 02:23:19 +0000

The third problem in the Best Time to Buy and Sell Stock series. The previous two problems allow unlimited transactions and only one transaction, respectively.
This problem allows two transactions.
With two transactions, you can split the problem at some point, turning it into two single-transaction problems. But this approach times out with O(n^2) complexity.
An alternative approach:
Process forward and backward using the single-transaction method, then store the max value at each point. This gives a linear solution.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74


class Solution {
public:
 int maxProfit(vector<int> &prices) {
 if(prices.size() <= 1) return 0;
 vector<int> dis;
 dis.clear();
 for(int i = 0; i < prices.size()-1; i++) {
 int val = prices[i+1] - prices[i];
 dis.push_back(val);
 }
 vector<int> cost;
 cost.clear();
 if(dis[0] <= 0) {
 cost.push_back(0);
 }
 else {
 cost.push_back(dis[0]);
 }
 for(int i = 1; i < dis.size(); i++) {
 if(cost[i-1] + dis[i] >= 0) {
 cost.push_back(cost[i-1] + dis[i]);
 }
 else {
 cost.push_back(0);
 }
 }
 int maxnow = 0;
 for(int i = 0; i < cost.size(); i++) {
 if(cost[i] < maxnow)
 cost[i] = maxnow;
 else {
 maxnow = cost[i];
 }
 }

 vector<int> cost_back;
 cost_back.clear();
 if(dis[dis.size()-1] <= 0) {
 cost_back.push_back(0);
 }
 else {
 cost_back.push_back(dis[dis.size()-1]);
 }
 for(int i = dis.size() - 2; i >= 0; i--) {
 if(cost_back[dis.size()-2-i] + dis[i] >= 0) {
 cost_back.push_back(cost_back[dis.size()-2-i] + dis[i]);
 }
 else {
 cost_back.push_back(0);
 }
 }
 maxnow = 0;
 for(int i = 0; i < cost_back.size(); i++) {
 if(cost_back[i] < maxnow)
 cost_back[i] = maxnow;
 else {
 maxnow = cost_back[i];
 }
 }
 int max = 0;
 for(int i = 0; i < cost.size(); i++) {
 if(cost.size() - 2 - i >= 0 && cost.size() - 2 - i < cost.size()) {
 if(max < cost[i] + cost_back[cost.size()-2-i]) {
 max = cost[i] + cost_back[cost.size()-2-i];
 }
 }
 else {
 if(max < cost[i])
 max = cost[i];
 }
 }
 return max;
 }
};

[leetcode_99]Recover Binary Search Tree

Sat, 23 May 2015 02:22:12 +0000

Two nodes in a binary search tree have been swapped, and you need to restore the tree.
I’m not sure if my approach is correct – I only restored them at the value level. But the problem says not to break the structure?
The idea is simple: in-order traversal + linear array correction.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84


class Solution {
public:
 void recoverTree(TreeNode *root) {
 if(root == NULL)return ;
 treeArray.clear();
 inOrder(root);
 int x,y;
 int flag = 0;
 for(int i = 0;i < treeArray.size();i++) {
 if(i == 0 && treeArray[i] > treeArray[i+1] && i < treeArray.size()-1) {
 if(flag == 0) {
 x = i;
 flag = 1;
 }
 else {
 y = i;
 }
 continue;
 }
 if(i == treeArray.size()-1 && treeArray[i] < treeArray[i-1] && i > 0) {
 if(flag == 0) {
 x = i;
 flag = 1;
 }
 else {
 y = i;
 }
 continue;
 }
 if( i > 0 && i < treeArray.size()-1 && treeArray[i] > treeArray[i-1] && treeArray[i] > treeArray[i+1]) {
 if(flag == 0) {
 x = i;
 flag = 1;
 }
 else {
 y = i;
 }
 continue;
 }
 if( i > 0 && i < treeArray.size()-1 && treeArray[i] < treeArray[i-1] && treeArray[i] < treeArray[i+1] ) {
 if(flag == 0) {
 x = i;
 flag = 1;
 }
 else {
 y = i;
 }
 continue;
 }
 }
 if(flag == 0) {
 for(int i = 0;i < treeArray.size()-1;i++) {
 if(treeArray[i] > treeArray[i+1]) {
 x = i;
 y = i+1;
 break;
 }
 }
 }
 queryTree(root,x,y);
 }
private:
 vector<int> treeArray;
 void inOrder(TreeNode * root) {
 if(root->left != NULL)
 inOrder(root->left);
 treeArray.push_back(root->val);
 if(root->right != NULL)
 inOrder(root->right);
 }
 void queryTree(TreeNode * root,int x,int y) {
 if(root->val == treeArray[x]) {
 root->val = treeArray[y];
 }
 else
 if (root->val == treeArray[y]){
 root->val = treeArray[x];
 }
 if(root->left != NULL)
 queryTree(root->left,x,y);
 if(root->right != NULL)
 queryTree(root->right,x,y);
 }
};

[leetcode_125]Valid Palindrome

Sat, 23 May 2015 02:20:45 +0000

Determine whether a sentence is a palindrome: case-insensitive, ignoring non-alphanumeric characters.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


class Solution {
public:
 bool isPalindrome(string s) {
 for(int i = 0; i < s.length(); i++) {
 if(s[i] >= 'A' && s[i] <= 'Z') {
 s[i] = 'a' + s[i] - 'A';
 }
 }
 int i = 0;
 int j = s.length() - 1;
 while(i < j) {
 while(!isALetter(s[i]) && i < j) i++;
 while(!isALetter(s[j]) && i < j) j--;
 if(i >= j) break;
 if(s[i] != s[j])
 return false;
 else {
 i++;
 j--;
 }
 }
 return true;
 }
private:
 bool isALetter(char c) {
 if((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))
 return true;
 else
 return false;
 }
};

[leetcode_41]First Missing Positive

Sat, 23 May 2015 02:19:42 +0000

Initially I could only solve it using a map. But obviously that doesn’t meet the constant space requirement.
Reference:
http://blog.unieagle.net/2012/09/20/leetcode题目：first-missing-positive/

The DIY hash approach is clever.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class Solution {
public:
 int firstMissingPositive(int A[], int n) {
 for(int i = 0; i < n; i++) {
 if(A[i] <= 0)
 A[i] = n+2;
 }
 for(int i = 0; i < n; i++) {
 if(abs(A[i]) - 1 < n && A[abs(A[i]) - 1] > 0)
 A[abs(A[i]) - 1] *= (-1);
 }
 for(int i = 1; i <= n; i++) {
 if(A[i-1] >= 0)
 return i;
 }
 return n + 1;
 }
};

[leetcode_69]Sqrt(x)

Sat, 23 May 2015 02:18:28 +0000

Simulate sqrt. Note that multiplying two ints may cause overflow.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


class Solution {
public:
 int sqrt(int x) {
 //x >= 0 0 ~ x/2
 if(x <= 0)return 0;
 int left = 1;
 int right = x / 2;
 bsearch(left, right, x);
 return ans;
 }
private:
 int ans;
 void bsearch(int left, int right, int x) {
 if(left >= right) {
 ans = left;
 if(1.0 * ans * ans > x)
 ans--;
 return;
 }
 int mid = (left + right) / 2;
 if(1.0 * mid * mid == x) {
 ans = mid;
 return;
 }
 else
 if(1.0 * mid * mid > x) {
 bsearch(left, mid-1, x);
 }
 else
 if(1.0 * mid * mid < x) {
 bsearch(mid+1, right, x);
 }
 }
};

[leetcode_23]Merge k Sorted Lists

Sat, 23 May 2015 02:17:22 +0000

K-way merge sort. Watch out for various boundary conditions: such as NULL pointers or empty vectors.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81


class Solution {
public:
 ListNode *mergeKLists(vector<ListNode *> &lists) {
 if(lists.size() <= 0)
 return NULL;
 while(lists.size() > 1) {
 vector<ListNode *>lists_tmp;
 lists_tmp.clear();
 ListNode * tmp;
 int i = 0;
 while (true) {
 tmp = merge2Lists(lists[2*i],lists[2*i+1]);
 lists_tmp.push_back(tmp);
 i++;
 if(2*i+1 == lists.size()) {
 lists_tmp.push_back(lists[2*i]);
 break;
 }
 if(2*i+1 > lists.size()) {
 break;
 }
 }
 lists.clear();
 lists = lists_tmp;
 }
 return lists[0];
 }
private:
 ListNode *merge2Lists(ListNode * list1,ListNode * list2) {
 ListNode * list = NULL;
 ListNode * list_c = NULL;
 while(list1 != NULL && list2 != NULL) {
 if(list1->val < list2->val) {
 if(list == NULL) {
 list = list1;
 list_c = list;
 }
 else {
 list_c->next = list1;
 list_c = list_c->next;
 }
 list1 = list1->next;
 }
 else {
 if(list == NULL) {
 list = list2;
 list_c = list;
 }
 else {
 list_c->next = list2;
 list_c = list_c->next;
 }
 list2 = list2->next;
 }
 }
 while(list1!=NULL) {
 if(list_c == NULL) {
 list_c = list1;
 list = list_c;
 list1 = list1->next;
 continue;
 }
 list_c->next = list1;
 list_c= list_c->next;
 list1 = list1->next;
 }
 while(list2!=NULL) {
 if(list_c == NULL) {
 list_c = list2;
 list = list_c;
 list2 = list2->next;
 continue;
 }
 list_c->next = list2;
 list_c= list_c->next;
 list2 = list2->next;
 }
 if(list_c != NULL)list_c->next = NULL;
 return list;
 }
};

[leetcode_45]Jump Game II

Sat, 23 May 2015 02:16:14 +0000

Keep expanding the farthest reachable position.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
 int jump(int A[], int n) {
 if (n <= 1) return 0;
 int min = -1;
 int max = 0;
 int maxstep = 0;
 int count = 0;
 while (true) {
 count++;
 for (int i = min + 1; i <= max; i++) {
 if (i + A[i] >= n - 1) {
 return count;
 }
 if (i + A[i] >= maxstep)
 maxstep = i + A[i];
 }
 min = max;
 max = maxstep;
 }
 return -1;
 }
};

[leetcode_49]Anagrams

Sat, 23 May 2015 02:14:55 +0000

Given multiple strings, find the groups of strings that are anagrams of each other.
Anagrams: eat ate eta
The approach for this problem is: sort, then sort again.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


int cmp(int a, int b) {
 return a < b;
}
struct Item {
 int index;
 string val;
};
int cmpitem(Item a, Item b) {
 return a.val < b.val;
}
class Solution {
public:
 vector<string> anagrams(vector<string> &strs) {
 vector<Item> strs_cpy;
 strs_cpy.clear();
 for(int i = 0; i < strs.size(); i++) {
 Item item;
 item.index = i;
 item.val = strs[i];
 sort(item.val.begin(), item.val.end(), cmp);
 strs_cpy.push_back(item);
 }
 sort(strs_cpy.begin(), strs_cpy.end(), cmpitem);
 vector<string> ans;
 ans.clear();
 int index = 0;
 for(int i = 1; i < strs_cpy.size(); i++) {
 if(strs_cpy[i].val == strs_cpy[index].val) {
 if(i - index == 1) {
 ans.push_back(strs[strs_cpy[index].index]);
 }
 ans.push_back(strs[strs_cpy[i].index]);
 } else {
 index = i;
 }
 }
 return ans;
 }
};

[leetcode_140] Combination Sum II

Fri, 22 May 2015 12:13:52 +0000

Find a series of numbers in an array that sum up to the target.
Search with pruning. Pay attention to deduplication and ascending order.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


int cmp(int a,int b) {
 return a < b;
}
class Solution {
public:
 vector<vector<int>>ans;
 vector<vector<int>> combinationSum2(vector<int> &num, int target) {
 ans.clear();
 sort(num.begin(),num.end(),cmp);
 vector<int> seq;
 seq.clear();
 addStep(num,0,0,target,seq);
 return ans;
 }
private:
 bool isSeqInAns(vector<int> &seq) {
 for(int i = 0;i < ans.size();i++) {
 if(ans[i] == seq)return false;
 }
 return true;
 }
 void addStep(vector<int> &num,int sum,int k,int target,vector<int> &seq) {
 if(sum == target) {
 if(isSeqInAns(seq))
 ans.push_back(seq);
 return;
 }
 if(k >= num.size()) {
 return ;
 }
 if(sum + num[k] <= target) {
 seq.push_back(num[k]);
 addStep(num,sum+num[k],k+1,target,seq);
 seq.pop_back();
 }
 addStep(num,sum,k+1,target,seq);
 }
};

[leetcode_115] Distinct Subsequences

Fri, 22 May 2015 12:11:50 +0000

Given strings S and T, count how many distinct subsequences of S equal T (i.e., how many ways can you delete characters from S to form T).
Initially, brute-force search timed out. I hadn’t mastered the right technique.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


struct PointS {
 int index;
 int count;
};
class Solution {
public:
 int ans;
 vector<PointS> seq;
 int numDistinct(string S, string T) {
 ans = 0;
 if(T.length() <= 0)return ans;
 seq.clear();
 for(int i = 0;i < S.length();i++) {
 if(S[i] == T[T.length()-1]) {
 PointS item;
 item.index = i;
 item.count = 1;
 seq.push_back(item);
 }
 }
 matchStep(T.length() - 2,S,T,seq);
 return ans;
 }
private:
 void matchStep (int now,string S,string T,vector<PointS>& seq) {
 if(now == -1) {
 for(int i = 0;i < seq.size();i++) {
 PointS item = seq[i];
 ans += item.count;
 }
 return ;
 }
 vector<PointS> seq_c;
 seq_c.clear();
 int i = 0;
 int bottom = 0;
 int sum = 0;
 for(int i = 0;i < seq.size();i++)
 sum += seq[i].count;
 while(i < seq.size()) {
 for(int j = bottom;j < seq[i].index;j++) {
 if(S[j] == T[now]) {
 PointS item;
 item.index = j;
 item.count = sum;
 seq_c.push_back(item);
 }
 }
 bottom = seq[i].index;
 sum -= seq[i].count;
 i++;
 }
 seq.clear();
 matchStep (now - 1,S,T,seq_c);
 }
};

[leetcode_134] Gas Station

Fri, 22 May 2015 12:10:46 +0000

100 problems done! A small milestone to celebrate.
First, check whether a feasible solution exists.
Then start from each node and find the first one that can reach the end.
Got AC. I believe the approach is correct, but I’m not 100% certain.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


class Solution {
public:
 int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 int ans = -1;
 int sum = 0;
 for(int i = 0;i < gas.size();i++) {
 sum += gas[i];
 sum -= cost[i];
 }
 if(sum < 0)return ans;

 int now = 0;
 int i = 0;
 ans = 0;
 while(i < gas.size()) {
 now += gas[i] - cost[i];
 if(now < 0) {
 i++;
 now = 0;
 ans = i;
 }
 else
 i++;
 }
 return ans;
 }
};

[leetcode_25] Reverse Nodes in k-Group

Fri, 22 May 2015 12:09:33 +0000

Singly linked list — reverse every k nodes. If the remaining length is less than k, do not reverse.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


class Solution {
public:
 int len;
 ListNode *reverseKGroup(ListNode *head, int k) {
 len = getLength(head);
 if(len < k || head == NULL || k <= 1) {
 return head;
 }
 ListNode ** tmp = new ListNode *[2];
 tmp = reverseKStep(head,k);
 len -= k;
 head = tmp[0];

 ListNode * beforebackup = tmp[1];
 while(len >= k) {
 tmp = reverseKStep(beforebackup->next,k);
 len -= k;
 beforebackup->next = tmp[0];
 beforebackup = tmp[1];
 }
 return head;
 }

private:
 // Returns two pointers: the first is the head, the second is the last node
 ListNode **reverseKStep(ListNode *before,int k) {
 ListNode * beforebackup = before;
 ListNode * now = before->next;
 int count = 1;
 while(now != NULL && count < k) {
 count++;
 ListNode * next = now->next;
 now->next = before;
 before = now;
 now = next;
 }
 beforebackup->next = now;
 ListNode ** ans = new ListNode *[2];
 ans[0] = before;
 ans[1] = beforebackup;
 return ans;
 }
 int getLength(ListNode *head) {
 int lentmp = 0;
 while(head != NULL) {
 head = head->next;
 lentmp++;
 }
 return lentmp;
 }
};

[leetcode_72]Edit Distance

Fri, 22 May 2015 12:08:23 +0000

This is a dynamic programming problem. Reference:
http://blog.csdn.net/abcjennifer/article/details/7735272
By the time I got to this problem, I honestly felt like I couldn’t keep going. The problem itself isn’t that complex, but I felt like my brain was too slow.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


class Solution {
public:
 int minDistance(string word1, string word2) {
 len1 = word1.length();
 len2 = word2.length();
 initdptable();
 for(int i = 1;i <= len1;i++) {
 for(int j = 1;j <= len2;j++) {
 dpTable[i][j] = getMin(word1[i-1] == word2[j-1] ? dpTable[i-1][j-1]:dpTable[i-1][j-1] + 1,dpTable[i-1][j]+1,dpTable[i][j-1]+1);
 }
 }
 //displaydptable();
 return dpTable[len1][len2];
 }
private:
 int **dpTable;
 int len1,len2;
 int getMin(int a,int b,int c) {
 int min = a;
 if(min > b)min = b;
 if(min > c)min = c;
 return min;
 }
 void initdptable() {
 dpTable = new int *[len1+1];
 for(int i = 0;i <= len1;i++) {
 dpTable[i] = new int[len2+1];
 }
 for(int i = 0;i <= len1;i++) {
 dpTable[i][0] = i;
 }
 for(int i = 0;i <= len2;i++) {
 dpTable[0][i] = i;
 }
 }
 void displaydptable() {
 for(int i = 0;i <= len1;i++) {
 for(int j = 0;j <= len2;j++) {
 cout << dpTable[i][j] << " ";
 }
 cout << endl;
 }
 }
};

[leetcode_131]Palindrome Partitioning

Fri, 22 May 2015 12:07:00 +0000

Find all partitions such that every substring in each partition is a palindrome.
The basic approach is:

Search
At each position, either split or don’t. Once a split is made, check whether the newly formed substring is a palindrome. If yes, continue searching; if not, the split is invalid.
When the end is reached, record the result.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67


class Solution {
public:
 vector<vector<string>> ans;
 vector<vector<string>> partition(string s) {
 ans.clear();
 if(s.length() <= 0) return ans;
 bool *flag = new bool[s.length()+1];
 for(int i = 0; i <= s.length(); i++)
 flag[i] = false;
 flag[0] = true;
 PartitionStep(s, 1, flag);
 return ans;
 }
private:
 void PartitionStep(string s, int step, bool *flag) {
 if(step == s.length()) {
 int i;
 flag[step] = true;
 for(i = step-1; i >= 0; i--) {
 if(flag[i] == true) break;
 }
 if(IsPalindrome(s, i, step-1)) {
 GenAnsItem(s, flag);
 }
 flag[step] = false;
 return;
 }
 flag[step] = true;
 int i;
 for(i = step-1; i >= 0; i--) {
 if(flag[i] == true) break;
 }
 if(IsPalindrome(s, i, step-1)) {
 PartitionStep(s, step+1, flag);
 }
 flag[step] = false;
 PartitionStep(s, step+1, flag);
 }

 bool IsPalindrome(string s, int i, int j) {
 while(i < j) {
 if(s[i] != s[j]) return false;
 i++;
 j--;
 }
 return true;
 }

 void GenAnsItem(string s, bool *flag) {
 vector<string> item;
 item.clear();
 int i = 1;
 int before = 0;
 while(i <= s.length()) {
 if(flag[i] == true) {
 string tmp = "";
 for(int j = before; j < i; j++) {
 tmp.push_back(s[j]);
 }
 item.push_back(tmp);
 before = i;
 }
 i++;
 }
 ans.push_back(item);
 }
};

[leetcode_82]Remove Duplicates from Sorted List II

Fri, 22 May 2015 12:05:39 +0000

Remove all nodes from a sorted singly linked list that have duplicate values.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


class Solution {
public:
 ListNode *deleteDuplicates(ListNode *head) {
 while(head != NULL && head->next != NULL && head->val == head->next->val) {
 while(head != NULL && head->next != NULL && head->val == head->next->val) {
 head = head->next;
 }
 if(head != NULL) {
 head = head->next;
 }
 }
 if(head == NULL || head->next == NULL)return head;
 ListNode * now = head->next;
 ListNode * node = head;
 while(now != NULL && now->next != NULL){
 while(now != NULL && now->next != NULL && now->val == now->next->val) {
 while(now != NULL && now->next != NULL && now->val == now->next->val) {
 now = now->next;
 }
 if(now != NULL) {
 now = now->next;
 }
 }
 node->next = now;
 node = node->next;
 if(node == NULL)break;
 now = node->next;
 }
 return head;
 }
};

[leetcode_17]Letter Combinations of a Phone Number

Fri, 22 May 2015 12:04:25 +0000

Given a digit string, return all possible letter combinations that the digits could represent on a phone keypad.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


class Solution {
public:
 vector<string> ans;
 vector<string> letterCombinations(string digits) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 vector<string> map = GenMap();
 ans.clear();
 string item = "";
 letterCStep(digits, 0, item, map);
 return ans;
 }
private:
 void letterCStep(string digits, int step, string item, vector<string>& map) {
 if (step >= digits.length()) {
 ans.push_back(item);
 return;
 } else {
 int index = digits[step] - '0';
 for (int i = 0; i < map[index].size(); i++) {
 item.push_back(map[index][i]);
 letterCStep(digits, step + 1, item, map);
 item.erase(item.end() - 1);
 }
 }
 }
 vector<string> GenMap() {
 vector<string> map;
 map.clear();
 map.push_back(" ");
 map.push_back("");
 map.push_back("abc");
 map.push_back("def");
 map.push_back("ghi");
 map.push_back("jkl");
 map.push_back("mno");
 map.push_back("pqrs");
 map.push_back("tuv");
 map.push_back("wxyz");
 return map;
 }
};

[leetcode_106]Construct Binary Tree from Preorder and Inorder Traversal

Fri, 22 May 2015 12:03:11 +0000

Construct a binary tree from preorder and inorder traversal sequences, guaranteed no duplicate values. Be careful not to exceed memory limits.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


class Solution {
public:
 TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 if(preorder.size() <= 0 || inorder.size() <= 0)
 return NULL;
 TreeNode * root = buildTreeStep(preorder,0,preorder.size()-1,inorder,0,inorder.size()-1);
 return root;
 }
private:
 TreeNode *buildTreeStep(vector<int> &preorder,int prea,int preb, vector<int> &inorder,int ina,int inb) {
 if(prea > preb || ina > inb)
 return NULL;
 int root = preorder[prea];
 int i;
 for(i = ina;i <= inb;i++) {
 if(inorder[i] == root) {
 break;
 }
 }
 //inorderleft:ina,i-1
 //inorderright,i+1,inb
 //preorderleft:prea+1,prea+1+(i-1)-ina
 //preorderright:prea+(i-1)-ina+1,preb
 TreeNode * node = new TreeNode(root);
 node->left = buildTreeStep(preorder,prea+1,prea+1+(i-1)-ina,inorder,ina,i-1);
 node->right = buildTreeStep(preorder,prea+1+(i-1)-ina+1,preb,inorder,i+1,inb);
 return node;
 }
};

[leetcode_106]Construct Binary Tree from Inorder and Postorder Traversal

Fri, 22 May 2015 12:01:32 +0000

Construct a binary tree from inorder and postorder traversal sequences, guaranteed no duplicate values. Be careful not to exceed memory limits.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


class Solution {
public:
 TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 if(inorder.size() <= 0 || postorder.size() <= 0)
 return NULL;
 TreeNode * root = buildTreeStep(inorder,0,inorder.size()-1,postorder,0,postorder.size()-1);
 return root;
 }
private:
 TreeNode *buildTreeStep(vector<int> &inorder,int ina,int inb,vector<int>&postorder,int poa,int pob) {
 if(ina > inb || poa > pob)
 return NULL;
 int root = postorder[pob];
 int i;
 for(i = ina;i <= inb;i++) {
 if(inorder[i] == root)break;
 }
 //inleft: ina i-1
 //inright:i+1 inb
 //poleft:poa,(i-1) - ina + poa
 //poright:(i-1) - ina + poa + 1,pob-1
 TreeNode * node = new TreeNode(root);
 node->left = buildTreeStep(inorder,ina,i-1,postorder,poa,(i-1)-ina+poa);
 node->right = buildTreeStep(inorder,i+1,inb,postorder,(i-1) - ina+poa+1,pob-1);
 return node;<br />
 }
};

[leetcode_36]Valid Sudoku

Fri, 22 May 2015 11:59:32 +0000

This problem was quite frustrating.
At first I misunderstood the problem and thought it was asking whether a Sudoku puzzle has a valid solution – enumeration? Brute force.
I wrote a version using set collections that kept timing out:

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136


struct PointOfBoard {
 set<int>set_p;
 bool IsExist;
 int val;
 PointOfBoard():IsExist(false),val(-1){set_p.clear();}
};
class Solution {
public:
 PointOfBoard POB[9][9];
 int x[81];
 int y[81];
 int index;
 bool result;
 int GetRegionOfBoard(int x,int y) {
 if(x>= 0 && x < 3) {
 if(y >= 0 && y < 3)return 0;
 if(y >= 3 && y < 6)return 1;
 if(y >= 6 && y < 9)return 2;
 }
 if(x >= 3 && x < 6) {
 if(y >= 0 && y < 3)return 3;
 if(y >= 3 && y < 6)return 4;
 if(y >= 6 && y < 9)return 5;
 }
 if(x >= 6 && x < 9) {
 if(y >= 0 && y < 3)return 6;
 if(y >= 3 && y < 6)return 7;
 if(y >= 6 && y < 9)return 8;
 }
 }
 bool GetSetOfPOB(int x,int y){
 set<int>set_tmp;
 set_tmp.clear();
 for(int i = 0;i < 9;i++) {
 if(POB[x][i].IsExist) {
 int val = POB[x][i].val;
 if(set_tmp.find(val) == set_tmp.end())
 set_tmp.insert(val);
 }
 if(POB[i][y].IsExist) {
 int val = POB[i][y].val;
 if(set_tmp.find(val) == set_tmp.end())
 set_tmp.insert(val);
 }
 }
 int region = GetRegionOfBoard(x,y);
 int x_r = (region / 3 + 1)*3;
 int y_r = (region % 3 + 1)*3;
 for(int i = x_r-3;i < x_r;i++) {
 for(int j = y_r-3;j < y_r;j++) {
 if(POB[i][j].IsExist) {
 int val = POB[i][j].val;
 if(set_tmp.find(val) != set_tmp.end())
 set_tmp.insert(val);
 }
 }
 }
 if(set_tmp.size() == 9)return false;
 set<int>::iterator it;
 for(int i = 1;i <= 9;i++) {
 if(set_tmp.find(i) == set_tmp.end())POB[x][y].set_p.insert(i);
 }
 if(POB[x][y].set_p.size() <= 0)return false;
 return true;
 }
 void Move(int step) {
 if(step >= index) {
 result = true;
 return;
 }
 else {
 if(result == true)return;
 int pi = x[step];
 int pj = y[step];
 set<int>::iterator it;
 for(it = POB[pi][pj].set_p.begin();it != POB[pi][pj].set_p.end();it++) {
 if(result == true)return;
 int val = (int)(*it);
 POB[pi][pj].val = val;
 int xtmp[81];
 int ytmp[81];
 int indextmp = 0;
 for(int i = step+1;i < index;i++) {
 int xi = x[i];
 int yi = y[i];
 if(xi == pi || yi == pj || GetRegionOfBoard(xi,yi) == GetRegionOfBoard(pi,pj)) {
 if(POB[xi][yi].set_p.find(val) != POB[xi][yi].set_p.end()) {
 xtmp[indextmp] = xi;
 ytmp[indextmp++] = yi;
 POB[xi][yi].set_p.erase(val);
 }
 }
 }
 Move(step+1);
 for(int i = 0;i < indextmp;i++) {
 int xi = xtmp[i];
 int yi = ytmp[i];
 POB[xi][yi].set_p.insert(val);
 }
 POB[pi][pj].val = -1;
 }
 }
 }
 bool isValidSudoku(vector<vector<char>> &board) {
 for(int i = 0;i < 9;i++) {
 for(int j = 0;j < 9;j++) {
 if(board[i][j] == '.') {
 POB[i][j].IsExist = false;
 }
 else {
 POB[i][j].IsExist = true;
 POB[i][j].val = board[i][j] - '0';
 }
 }
 }
 for(int i = 0;i < 9;i++) {
 for(int j = 0;j < 9;j++) {
 if(POB[i][j].IsExist == false) {
 if(GetSetOfPOB(i,j) == false)return false;
 }
 }
 }
 index = 0;
 for(int i = 0;i < 9;i++) {
 for(int j = 0;j < 9;j++) {
 if(POB[i][j].IsExist == false) {
 x[index] = i;
 y[index++] = j;
 }
 }
 }
 result = false;
 Move(0);
 return result;
 }
};

Later I saw someone else’s code using binary int representation, so I wrote another version:

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150


struct Pointxy {
 int x;
 int y;
 int val;
};
int cmp(Pointxy a,Pointxy b) {
 return a.val < b.val;
}
class Solution {
public:
 int bitarray[9];
 int map[9][9];
 bool result;
 int CountOnes(int v)
 {
 int number = 0;
 while(v)
 {
 v &= (v-1);
 number++;
 }
 return number;
 }
 int GetRegionOfBoard(int x,int y) {
 if(x>= 0 && x < 3) {
 if(y >= 0 && y < 3)return 0;
 if(y >= 3 && y < 6)return 1;
 if(y >= 6 && y < 9)return 2;
 }
 if(x >= 3 && x < 6) {
 if(y >= 0 && y < 3)return 3;
 if(y >= 3 && y < 6)return 4;
 if(y >= 6 && y < 9)return 5;
 }
 if(x >= 6 && x < 9) {
 if(y >= 0 && y < 3)return 6;
 if(y >= 3 && y < 6)return 7;
 if(y >= 6 && y < 9)return 8;
 }
 }
 bool RefeshMap(int x,int y){
 int set_tmp = 0;
 for(int i = 0;i < 9;i++) {
 if(CountOnes(map[x][i]) == 1) {
 set_tmp = set_tmp | map[x][i];
 }
 if(CountOnes(map[i][y]) == 1) {
 set_tmp = set_tmp | map[x][i];
 }
 }
 int region = GetRegionOfBoard(x,y);
 int x_r = (region / 3 + 1)*3;
 int y_r = (region % 3 + 1)*3;
 for(int i = x_r-3;i < x_r;i++) {
 for(int j = y_r-3;j < y_r;j++) {
 if(CountOnes(map[i][j]) == 1) {
 set_tmp = set_tmp | map[i][j];
 }
 }
 }
 if(set_tmp == 511)return false;
 map[x][y] = 511 - set_tmp;
 return true;
 }
 void Move(Pointxy pxy[81],int index) {
 if(result == true)return;
 if(index <= 0) {
 result = true;
 return;
 }
 else {
 sort(pxy,pxy+index,cmp);
 int pi = pxy[0].x;
 int pj = pxy[0].y;
 for(int ibit = 0;ibit < 9;ibit++) {
 if(result == true)return;
 if(map[pi][pj] & bitarray[ibit]) {
 map[pi][pj] -= bitarray[ibit];
 int xtmp[81];
 int ytmp[81];
 int indextmp = 0;
 for(int i = 1;i < index;i++) {
 int xi = pxy[i].x;
 int yi = pxy[i].y;
 if(xi == pi || yi == pj || GetRegionOfBoard(xi,yi) == GetRegionOfBoard(pi,pj)) {
 if(map[xi][yi] & bitarray[ibit]) {
 xtmp[indextmp] = xi;
 ytmp[indextmp++] = yi;
 map[xi][yi] -= bitarray[ibit];
 }
 }
 }
 Pointxy pxyt[81];
 int indext = 0;
 for(int i = 1;i < index;i++) {
 pxyt[indext].x = pxy[i].x;
 pxyt[indext].y = pxy[i].y;
 pxyt[indext++].val = CountOnes(map[pxyt[indext].x][pxyt[indext].y]);
 }
 Move(pxyt,indext);
 for(int i = 0;i < indextmp;i++) {
 int xi = xtmp[i];
 int yi = ytmp[i];
 map[xi][yi] += bitarray[ibit];
 }
 map[pi][pj] += bitarray[ibit];
 }
 }
 }
 }
 bool isValidSudoku(vector<vector<char>> &board) {
 for(int i = 0;i < 9;i++) {
 bitarray[i] = (int)pow(2.0,i);
 }
 int count = 0;
 for(int i = 0;i < 9;i++) {
 for(int j = 0;j < 9;j++) {
 if(board[i][j] == '.') {
 map[i][j] = 511;
 }
 else {
 map[i][j] = bitarray[board[i][j] - '0'-1];
 count++;
 }
 }
 }
 if(count < 17)return false;
 for(int i = 0;i < 9;i++) {
 for(int j = 0;j < 9;j++) {
 if(map[i][j] == 511) {
 if(RefeshMap(i,j) == false)return false;
 }
 }
 }
 Pointxy pxy[81];
 int index = 0;
 for(int i = 0;i < 9;i++) {
 for(int j = 0;j < 9;j++) {
 if(CountOnes(map[i][j]) != 1) {
 pxy[index].x = i;
 pxy[index].y = j;
 pxy[index].val = CountOnes(map[i][j]);
 }
 }
 }
 result = false;
 Move(pxy,index);
 return result;
}
};

WA??? That doesn’t make sense???
The final WA was on a case that was obviously unsolvable.
With no other option, I looked at other people’s code. Turns out the problem only asks to validate whether the current state of the Sudoku board satisfies the rules – the problem is so much simpler!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73


class Solution {
public:
 int bitarray[9];
 int map[9][9];
 bool result;
 int GetRegionOfBoard(int x,int y) {
 if(x>= 0 && x < 3) {
 if(y >= 0 && y < 3)return 0;
 if(y >= 3 && y < 6)return 1;
 if(y >= 6 && y < 9)return 2;
 }
 if(x >= 3 && x < 6) {
 if(y >= 0 && y < 3)return 3;
 if(y >= 3 && y < 6)return 4;
 if(y >= 6 && y < 9)return 5;
 }
 if(x >= 6 && x < 9) {
 if(y >= 0 && y < 3)return 6;
 if(y >= 3 && y < 6)return 7;
 if(y >= 6 && y < 9)return 8;
 }
 }
 bool CheckRows() {
 for(int i = 0;i < 9;i++) {
 int tmp = 0;
 for(int j = 0;j < 9;j++) {
 if(tmp & map[i][j])return false;
 tmp |= map[i][j];
 }
 }
 return true;
 }
 bool CheckCols() {
 for(int j = 0;j < 9;j++) {
 int tmp = 0;
 for(int i = 0;i < 9;i++) {
 if(tmp & map[i][j])return false;
 tmp |= map[i][j];
 }
 }
 return true;
}
bool CheckRegion() {
 for(int region = 0;region < 9;region++) {
 int x_r = (region / 3 + 1)*3;
 int y_r = (region % 3 + 1)*3;
 int tmp = 0;
 for(int i = x_r-3;i < x_r;i++) {
 for(int j = y_r-3;j < y_r;j++) {
 if(tmp & map[i][j])return false;
 tmp = tmp | map[i][j];
 }
 }
 }
 return true;
}
bool isValidSudoku(vector<vector<char>> &board) {
 for(int i = 0;i < 9;i++) {
 bitarray[i] = (int)pow(2.0,i);
 }
 for(int i = 0;i < 9;i++) {
 for(int j = 0;j < 9;j++) {
 if(board[i][j] == '.') {
 map[i][j] = 0;
 }
 else {
 map[i][j] = bitarray[board[i][j] - '0'-1];
 }
 }
 }
 return CheckRows() && CheckCols() && CheckRegion();
}
};

[leetcode_92]Reverse Linked List II

Fri, 22 May 2015 11:57:25 +0000

Given a singly linked list, reverse the nodes from position m to n. Do not allocate extra space.
Initially I misread the problem and thought it was about swapping two nodes at positions m and n, which resulted in WA.
However, I realized that swapping is actually a step in the reversal process, so I made a few modifications to the code and got AC. Pay special attention to the cases where m=1 and n-m=1.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75


class Solution {
public:
 ListNode *reverseBetween(ListNode *head, int m, int n) {
 int length = GetLengthListNode(head);
 if(length <= 0 || m >= n || length < n) return head;
 while(m < n) {
 head = reverseBetweenStep(head,m,n);
 m++;
 n--;
 }
 return head;
 }
private:
 ListNode *reverseBetweenStep(ListNode *head, int m, int n) {
 if(n-m == 1) {
 if(m == 1) {
 ListNode * mlistNode = head;
 ListNode * nlistNode = GetListNodeFromPos(head,n);
 ListNode * ntmpnext = nlistNode->next;
 nlistNode->next = mlistNode;
 mlistNode->next = ntmpnext;
 return nlistNode;
 }
 else {
 ListNode * beforem = GetListNodeFromPos(head,m-1);
 ListNode * mlistNode = GetListNodeFromPos(head,m);
 ListNode * nlistNode = GetListNodeFromPos(head,n);
 ListNode * ntmpnext = nlistNode->next;
 nlistNode->next = mlistNode;
 mlistNode->next = ntmpnext;
 beforem->next = nlistNode;
 return head;<br />
 }
 }
 if(m == 1) {
 ListNode * mlistNode = head;
 ListNode * beforen = GetListNodeFromPos(head,n-1);
 ListNode * nlistNode = GetListNodeFromPos(head,n);
 ListNode * ntmpnext = nlistNode->next;
 nlistNode->next = mlistNode->next;
 mlistNode->next = ntmpnext;
 beforen->next = mlistNode;
 return nlistNode;
 }
 else {
 ListNode * beforem = GetListNodeFromPos(head,m-1);
 ListNode * mlistNode = GetListNodeFromPos(head,m);
 ListNode * beforen = GetListNodeFromPos(head,n-1);
 ListNode * nlistNode = GetListNodeFromPos(head,n);

 ListNode * mtmpnext = mlistNode->next;
 ListNode * ntmpnext = nlistNode->next;
 nlistNode->next = mlistNode->next;
 mlistNode->next = ntmpnext;
 beforen->next = mlistNode;
 beforem->next = nlistNode;
 return head;
 }
 }
};
ListNode * GetListNodeFromPos(ListNode *head,int pos) {
 pos--;
 while(pos--) {
 head = head->next;
 }
 return head;
}
int GetLengthListNode(ListNode *listNode) {
 int Length = 0;
 while(listNode != NULL) {
 listNode = listNode->next;
 Length++;
 }
 return Length;
};

[leetcode_67]Add Binary

Fri, 22 May 2015 11:56:02 +0000

90 problems done – it really hasn’t been easy.
Binary addition of two strings. Use an int to store the carry.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


class Solution {
public:
 string addBinary(string a, string b) {
 string ans = "";
 int lenMin = a.length() < b.length()?a.length():b.length();
 int inbit = 0;
 for(int i = 0;i < lenMin;i++) {
 int aVal = a[a.length()-1-i] - '0';
 int bVal = b[b.length()-1-i] - '0';
 int sum = inbit + aVal + bVal;
 inbit = sum / 2;
 ans.push_back(sum%2 + '0');
 }
 if(a.length() > b.length()) {
 for(int i = lenMin;i < a.length();i++) {
 int Val = a[a.length()-1-i] - '0' + inbit;
 inbit = Val / 2;
 ans.push_back(Val%2 + '0');
 }
 }
 else {
 for(int i = lenMin;i < b.length();i++) {
 int Val = b[b.length()-1-i] - '0' + inbit;
 inbit = Val / 2;
 ans.push_back(Val%2 + '0');
 }
 }
 if(inbit != 0) {
 ans.push_back(inbit + '0');
 }
 string ansr(ans.rbegin(),ans.rend());
 return ansr;
 }
};

[leetcode_31]Next Permutation

Fri, 22 May 2015 11:54:52 +0000

Given an array, find the next permutation of the sequence. If the sequence is already the largest permutation, output the smallest sorted order.
The key is to have a clear approach.

Find the first element worth swapping – it should be as close to the least significant position as possible, and there must be a larger element after it. Then find the smallest element after it that is larger and swap them.
Finally, sort all elements after the swapped position in ascending order.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


int cmp(int a,int b) {
 return a < b;
}
class Solution {
public:
 void nextPermutation(vector<int> &num) {
 bool IsSwap = false;
 for(int i = num.size()-1;i >= 0;i--) {
 int index = -1;
 int max = 0xffff;
 for(int j = i+1;j < num.size();j++) {
 if(num[j] > num[i] && num[j] < max) {
 index = j;
 max = num[j];
 IsSwap = true;
 }
 }
 if(IsSwap) {
 int tmp = num[index];
 num[index] = num[i];
 num[i] = tmp;
 sort(num.begin()+i+1,num.end(),cmp);
 break;
 }
 }
 if(IsSwap == false) {
 sort(num.begin(),num.end(),cmp);
 }
 }
};

[leetcode_147]Insertion Sort List

Fri, 22 May 2015 11:52:49 +0000

Insertion sort on a singly linked list. A simple problem in theory, but my implementation turned out messy. Maybe I should take a break from LeetCode for now. Starting the thesis topic tomorrow.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


class Solution {
public:
 int GetCount(ListNode *head) {
 int count = 0;
 while(head != NULL) {
 count++;
 head=head->next;
 }
 return count;
 }
 ListNode *insertionSortList(ListNode *head) {
 if(head == NULL)return head;
 ListNode * now = head->next;
 ListNode * before = head;
 int count = GetCount(head);
 while(now != NULL) {
 ListNode * tmpnow = now->next;
 if(now->val <= head->val) {
 ListNode * tmp = now->next;
 before->next = now->next;
 now->next = head;
 head = now;
 now = tmpnow;
 }
 else {
 ListNode * beforetmp = head;
 ListNode * tmp = beforetmp->next;
 while(tmp != now && tmp->val <= now->val) {
 beforetmp = beforetmp->next;
 tmp = tmp->next;
 }
 if(tmp != now) {
 beforetmp->next = now;
 before->next = now->next;
 now->next = tmp;
 now = tmpnow;
 }
 else {
 before = now;
 now = tmpnow;
 }
 }
 }
 ListNode * chead = head;
 for(int i = 1;i < count;i++) {
 chead = chead->next;
 }
 chead->next = NULL;
 return head;
 }
};

[leetcode_98] Validate Binary Search Tree

Fri, 22 May 2015 11:51:21 +0000

Determine whether a binary tree is a valid BST.
Based on BST properties, recursively validate.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


class Solution {
public:
 bool result;
 enum Flag {left, right, leftright};
 void isValidBSTStep(TreeNode * root, int val1, int val2, Flag flag) {
 switch(flag){
 case left:
 if(root->val <= val1) {
 result = false;
 return;
 }
 break;
 case right:
 if(root->val >= val2) {
 result = false;
 return;
 }
 break;
 case leftright:
 if(root->val <= val1 || root->val >= val2) {
 result = false;
 return;
 }
 break;
 }
 if(root->left != NULL) {
 if(flag == left || flag == leftright)
 isValidBSTStep(root->left, val1, root->val, leftright);
 else
 isValidBSTStep(root->left, 0, root->val, right);
 }
 if(root->right != NULL ){
 if(flag == right || flag == leftright)
 isValidBSTStep(root->right, root->val, val2, leftright);
 else
 isValidBSTStep(root->right, root->val, 0, left);
 }
 }
 bool isValidBST(TreeNode *root) {
 result = true;
 if(root == NULL) return result;
 if(root->left != NULL) {
 isValidBSTStep(root->left, 0, root->val, right);
 }
 if(root->right != NULL ){
 isValidBSTStep(root->right, root->val, 0, left);
 }
 return result;
 }
};

[leetcode_39]Combination Sum

Fri, 22 May 2015 11:49:33 +0000

Unbounded knapsack problem?
Given input 2 3 6 7,
output all combinations of 2, 3, 6, 7 that sum to 7.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


int cmp(int a,int b) {
 return a < b;
}
struct ValNode {
 ValNode():IsExist(false){set_v.clear();}
 vector<vector<int>>set_v;
 bool IsExist;
};
class Solution {
public:
 bool CheckIsExist(vector<int>&item_tmp,vector<vector<int>>&set_v) {
 sort(item_tmp.begin(),item_tmp.end(),cmp);
 for(int i = 0;i < set_v.size();i++) {
 if(item_tmp == set_v[i])return true;
 }
 return false;
 }
 vector<vector<int>> combinationSum(vector<int> &candidates, int target) {
 int max = target;
 ValNode *valnodes = new ValNode[max+1];
 valnodes[0].IsExist = true;
 vector<int>item;
 item.clear();
 valnodes[0].set_v.push_back(item);
 for(int i = 0;i <= target;i++) {
 if(valnodes[i].IsExist) {
 for(int j = 0;j < candidates.size();j++) {
 if(i + candidates[j] <= target) {
 valnodes[i+candidates[j]].IsExist = true;
 for(int k = 0;k < valnodes[i].set_v.size();k++) {
 vector<int>item_tmp;
 item_tmp.clear();
 item_tmp = valnodes[i].set_v[k];
 item_tmp.push_back(candidates[j]);
 if(!CheckIsExist(item_tmp,valnodes[i+candidates[j]].set_v))
 valnodes[i+candidates[j]].set_v.push_back(item_tmp);
 }
 }
 }
 }
 }
 return valnodes[max].set_v;
 }
};

[leetcode_95]Unique Binary Search Trees II

Fri, 22 May 2015 11:47:39 +0000

Given n, generate all structurally unique BSTs that store values 1 to n.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


class Solution {
public:
 vector<TreeNode *> genTreeNodes(int left,int right) {
 vector<TreeNode *> nodes;
 nodes.clear();
 if(left > right) {
 nodes.push_back(NULL);
 return nodes;
 }
 if(left == right) {
 TreeNode * node = new TreeNode(left);
 nodes.push_back(node);
 return nodes;
 }
 for(int i = left;i<= right;i++) {
 vector<TreeNode *>lefts,rights;
 lefts.clear();
 rights.clear();
 lefts = genTreeNodes(left,i-1);
 rights = genTreeNodes(i+1,right);
 // Enumerate all combinations of left and right subtrees
 for(int l = 0;l < lefts.size();l++) {
 for(int r = 0; r < rights.size();r++) {
 TreeNode *node = new TreeNode(i);
 node->left = lefts[l];
 node->right = rights[r];
 nodes.push_back(node);
 }
 }
 }
 return nodes;
 }
 vector<TreeNode *> generateTrees(int n) {
 vector<TreeNode *>nodes;
 nodes.clear();
 nodes = genTreeNodes(1,n);
 return nodes;
 }
};

[leetcode_50]Pow(x, n)

Fri, 22 May 2015 11:46:03 +0000

Implement pow. Watch out for timeout and negative n.
Use binary exponentiation to achieve O(log n) complexity.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


class Solution {
public:
 double powstep(double x,int n) {
 if(n == 0)return 1.0;
 if(n == 1)return x;
 if(n == 2)return x*x;
 if(n % 2 == 0) {
 return powstep(powstep(x,n/2),2);
 }
 else {
 return x * powstep(powstep(x,n/2),2);
 }
 }
 double pow(double x, int n) {
 int flag = 1;
 if(n < 0)
 flag = -1;
 n = (-1)*n;
 double ans = powstep(x,n);
 if(flag == -1)
 ans = 1.0 / ans;
 return ans;
 }
};

[leetcode_86]Partition List

Fri, 22 May 2015 11:44:30 +0000

Partition a singly linked list. Choose a value x, then place all nodes with values less than x before those with values greater than or equal to x, while preserving the original relative order within each group.
Approach:
First, find the first node with a value less than x and move it to the front.
Then, find the first node with a value greater than or equal to x.
From there, enumerate the remaining nodes: if a node’s value is greater than or equal to x, skip it; if it is less than x, move it before the first node with a value greater than or equal to x.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


class Solution {
public:
 ListNode *partition(ListNode *head, int x) {
 if(head == NULL || head->next == NULL)
 return head;
 ListNode * beforenode;
 ListNode * minnode, *maxnode; // find the 1st minnode
 if(head->val < x) {
 minnode = head;
 }
 else {
 beforenode = head;
 minnode = head->next;
 while(minnode != NULL && minnode->val >= x) {
 beforenode = minnode;
 minnode = minnode->next;
 }
 if(minnode == NULL) return head;
 beforenode->next = minnode->next;
 minnode->next = head; // now the head is minnode;
 }
 beforenode = minnode;
 maxnode = minnode->next;
 while(maxnode != NULL && maxnode->val < x) {
 beforenode = maxnode;
 maxnode = maxnode->next;
 }
 if(maxnode == NULL || maxnode->next == NULL) return minnode;
 // now find minnode and maxnode. the head is minnode
 head = minnode;
 ListNode * now = maxnode->next;
 while(now != NULL) {
 if(now->val >= x) {
 maxnode = now;
 now = now->next;
 }
 else {
 ListNode * tmp = beforenode->next;
 maxnode->next = now->next;
 beforenode->next = now;
 now->next = tmp;
 now = maxnode->next;
 beforenode = beforenode->next;
 }
 }
 return head;
 }
};

[leetcode_103]Binary Tree Zigzag Level Order Traversal

Fri, 22 May 2015 11:43:17 +0000

Serialize a binary tree, but alternate the output direction between left-to-right and right-to-left for each level.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


class Solution {
public:
 enum Direciton {left,right};
 vector<vector<int>> zigzagLevelOrder(TreeNode *root) {
 vector<vector<int>> result;
 result.clear();
 vector<TreeNode*> seq,seq_c;
 seq.clear();
 if(root != NULL)seq.push_back(root);
 Direciton direction = left;
 while(seq.size() > 0) {
 seq_c.clear();
 vector<int>item;
 item.clear();
 if(direction == left) {
 direction = right;
 for(int i = 0; i < seq.size();i++) {
 item.push_back(seq[i]->val);
 if(seq[i]->left != NULL) {
 seq_c.push_back(seq[i]->left);
 }
 if(seq[i]->right != NULL) {
 seq_c.push_back(seq[i]->right);
 }
 }
 }
 else {
 direction = left;
 for(int i = seq.size()-1; i >= 0; i--) {
 item.push_back(seq[i]->val);
 }
 for(int i = 0; i < seq.size();i++) {
 if(seq[i]->left != NULL) {
 seq_c.push_back(seq[i]->left);
 }
 if(seq[i]->right != NULL) {
 seq_c.push_back(seq[i]->right);
 }
 }
 }
 result.push_back(item);
 seq = seq_c;
 }
 return result;
 }
};

[leetcode_114]Flatten Binary Tree to Linked List

Fri, 22 May 2015 11:42:05 +0000

Flatten a binary tree.
Flattening means transforming:

into:

Each node’s right child points to the next node of a pre-order traversal.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


class Solution {
public:
 TreeNode * flattenStep(TreeNode *root) {
 if(root-&gt;left == NULL &amp;&amp; root-&gt;right == NULL)
 return root;
 TreeNode * tmp = NULL;
 if(root-&gt;right != NULL)
 tmp = flattenStep(root-&gt;right);
 if(root-&gt;left != NULL)
 root-&gt;right = flattenStep(root-&gt;left);
 else
 root-&gt;right = NULL;
 root-&gt;left = NULL;
 if(tmp != NULL) {
 TreeNode * tmpright = root;
 while(tmpright-&gt;right != NULL)
 tmpright = tmpright-&gt;right;
 tmpright-&gt;right = tmp;
 }
 return root;
 }
 void flatten(TreeNode *root) {
 if(root == NULL)return;
 root = flattenStep(root);
 }
};

[leetcode_51]N-Queens

Fri, 22 May 2015 11:40:54 +0000

The N-Queens problem – output all solutions.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92


class Solution {
public:
 int count;
 int *x;
 int *y;
 int index;
 bool *rows, *cols, *ltrb, *rtlb;
 vector<vector<string>> ans;
 vector<string> item;
 void SetFalse(bool *arrayin, int n) {
 for(int i = 0; i < n; i++)
 arrayin[i] = false;
 }
 void Move(int row, int n) {
 for(int col = 0; col < n; col++) {
 if( rows[row] != true &&
 cols[col] != true &&
 ltrb[row+col] != true &&
 rtlb[n-1+row-col] != true) {
 if(row == n-1) {
 x[index] = row;
 y[index++] = col;
 item.clear();
 string subitem = "";
 for(int j = 0; j < n; j++) {
 subitem.push_back('.');
 }
 for(int i = 0; i < n; i++) {
 item.push_back(subitem);
 }
 for(int i = 0; i < index; i++) {
 item[x[i]][y[i]] = 'Q';
 }
 ans.push_back(item);
 index--;
 }
 else {
 rows[row] = true;
 cols[col] = true;
 ltrb[row+col] = true;
 rtlb[n-1+row-col] = true;
 x[index] = row;
 y[index++] = col;
 Move(row+1, n);
 index--;
 rows[row] = false;
 cols[col] = false;
 ltrb[row+col] = false;
 rtlb[n-1+row-col] = false;
 }
 }
 }
 }
 vector<vector<string>> solveNQueens(int n) {
 x = new int[n];
 y = new int[n];
 rows = new bool[n];
 SetFalse(rows, n);
 cols = new bool[n];
 SetFalse(cols, n);
 ltrb = new bool[n+n-1];
 SetFalse(ltrb, n+n-1);
 rtlb = new bool[n+n-1];
 SetFalse(rtlb, n+n-1);
 ans.clear();
 if(n == 1) {
 string subitem = "Q";
 vector<string> item;
 item.clear();
 item.push_back(subitem);
 ans.push_back(item);
 return ans;
 }
 int row = 0;
 index = 0;
 for(int col = 0; col < n; col++) {
 rows[row] = true;
 cols[col] = true;
 ltrb[row+col] = true;
 rtlb[n-1+row-col] = true;
 x[index] = row;
 y[index++] = col;
 Move(row+1, n);
 index--;
 rows[row] = false;
 cols[col] = false;
 ltrb[row+col] = false;
 rtlb[n-1+row-col] = false;
 }
 return ans;
 }
};

[leetcode_52]N-Queens II

Fri, 22 May 2015 11:39:37 +0000

The N-Queens problem – just output the number of solutions.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


class Solution {
public:
 int count;
 bool *rows,*cols,*ltrb,*rtlb;
 void SetFalse(bool *arrayin,int n) {
 for(int i = 0;i < n;i++)
 arrayin[i] = false;
 }
 void Move(int row,int n) {
 for(int col = 0;col < n;col++) {
 if( rows[row] != true &&
 cols[col] != true &&
 ltrb[row+col] != true&&
 rtlb[n-1+row-col] != true) {
 if(row == n-1)count++;
 else {
 rows[row] = true;
 cols[col] = true;
 ltrb[row+col] = true;
 rtlb[n-1+row-col] = true;
 Move(row+1,n);
 rows[row] = false;
 cols[col] = false;
 ltrb[row+col] = false;
 rtlb[n-1+row-col] = false;
 }
 }
 }
 }
 int totalNQueens(int n) {
 rows = new bool[n];//行
 SetFalse(rows,n);
 cols = new bool[n];//列
 SetFalse(cols,n);
 ltrb = new bool[n+n-1];
 SetFalse(ltrb,n+n-1);
 rtlb = new bool[n+n-1];
 SetFalse(rtlb,n+n-1);
 count = 0;
 if(n == 1)return 1;
 int row = 0;
 for(int col = 0;col < n;col++) {
 rows[row] = true;
 cols[col] = true;
 ltrb[row+col] = true;
 rtlb[n-1+row-col] = true;
 Move(row+1,n);
 rows[row] = false;
 cols[col] = false;
 ltrb[row+col] = false;
 rtlb[n-1+row-col] = false;
 }
 return count;
 }
};

[leetcode_128] Longest Consecutive Sequence

Fri, 22 May 2015 11:29:11 +0000

Find the longest consecutive subsequence in an unsorted array.
To be honest, I could not solve this problem in O(n) complexity on my own.
I understood the approach only after reading someone else’s code.
I had thought about using a hash, but I recalled that STL’s map has O(log n) lookup complexity, which would result in an overall O(n log n) complexity, so I gave up on that idea.
Today I took the time to properly understand what hash tables are, and the differences between map, set, hash_map, and hash_set. It was quite helpful.
I also learned about a library called Boost, which is a quasi-standard C++ library. Feel free to look it up if you are interested.
The final solution for this problem is hash + left-right expansion simulation.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


class Solution {
public:
 ListNode * GetListNthNode(ListNode * head, int n) {
 int k = 0;
 while(k < n) {
 k++;
 head = head->next;
 }
 return head;
 }
 int CountList(ListNode *head) {
 int count = -1;
 while(head != NULL) {
 head = head->next;
 count++;
 }
 return count;
 }
 TreeNode *BSearchT(int left, int right, ListNode * head) {
 if(right < left) return NULL;
 int mid = (left + right) / 2;
 TreeNode * root = new TreeNode(GetListNthNode(head, mid - left)->val);
 root->left = BSearchT(left, mid - 1, head);
 root->right = BSearchT(mid + 1, right, GetListNthNode(head, mid + 1 - left));
 return root;
 }
 TreeNode *sortedListToBST(ListNode *head) {
 if(head == NULL)
 return NULL;
 int n = CountList(head);
 int mid = (0 + n) / 2;
 TreeNode * root = new TreeNode(GetListNthNode(head, mid)->val);
 root->left = BSearchT(0, mid - 1, head);
 root->right = BSearchT(mid + 1, n, GetListNthNode(head, mid + 1));
 return root;
 }
};

[leetcode_109]Convert Sorted List to Binary Search Tree

Fri, 22 May 2015 11:27:51 +0000

This problem is a variation of http://blog.sina.com.cn/s/blog_672f71fc0101os5r.html.
The only difference is that the array is replaced with a singly linked list. When searching in the linked list, be careful to optimize: after each binary split, the head node remains the same for the left part, but for the right part, the head node needs to be updated to the mid node. Otherwise it will time out.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


class Solution {
public:
 ListNode * GetListNthNode(ListNode * head, int n) {
 int k = 0;
 while(k < n) {
 k++;
 head = head->next;
 }
 return head;
 }
 int CountList(ListNode *head) {
 int count = -1;
 while(head != NULL) {
 head = head->next;
 count++;
 }
 return count;
 }
 TreeNode *BSearchT(int left, int right, ListNode * head) {
 if(right < left) return NULL;
 int mid = (left + right) / 2;
 TreeNode * root = new TreeNode(GetListNthNode(head, mid - left)->val);
 root->left = BSearchT(left, mid - 1, head);
 root->right = BSearchT(mid + 1, right, GetListNthNode(head, mid + 1 - left));
 return root;
 }
 TreeNode *sortedListToBST(ListNode *head) {
 if(head == NULL)
 return NULL;
 int n = CountList(head);
 int mid = (0 + n) / 2;
 TreeNode * root = new TreeNode(GetListNthNode(head, mid)->val);
 root->left = BSearchT(0, mid - 1, head);
 root->right = BSearchT(mid + 1, n, GetListNthNode(head, mid + 1));
 return root;
 }
};

[leetcode_38]Count and Say

Fri, 22 May 2015 11:26:08 +0000

A simulation problem. Just iterate until n.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


class Solution {
public:
 string SayStep(string str) {
 string strstep = "";
 int index = 0;
 while(index < str.length()) {
 char c = str[index];
 int count_c = 1;
 int i;
 for(i = index+1;i < str.length();i++) {
 if(c == str[i])count_c++;
 else break;
 }
 index = i;
 strstep.push_back(count_c + '0');
 strstep.push_back(c);
 }
 return strstep;
 }
 string countAndSay(int n) {
 string str = "1";
 for(int i = 1; i < n;i++) {
 str = SayStep(str);
 }
 return str;
 }
};

[leetcode_55]Jump Game

Fri, 22 May 2015 11:24:56 +0000

Marking from front to back one by one will time out. After some thought, in certain cases the complexity is O(n^2).
However, marking from back to front is different – it is approximately O(n).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class Solution {
public:
 void FindMin(int A[],int n,bool flag[]) {
 if(n <= 0)return;
 int min = 0xffff;
 for(int i = n-1;i >= 0;i--) {
 if(A[i] + i >= n) {
 flag[i] = true;
 if(min > i)
 min = i;
 }
 }
 if(min == 0xffff || flag[0] == true)return;
 FindMin(A,min,flag);
 }
 bool canJump(int A[], int n) {
 bool * flag = new bool[n+1];
 if(n == 1)return true;
 for(int i = 0;i < n;i++) {
 flag[i] = false;
 }
 FindMin(A,n-1,flag);
 return flag[0];
 }
};

[leetcode_34]Search for a Range

Fri, 22 May 2015 11:23:45 +0000

A variation of binary search. Given a sorted array with duplicate numbers allowed, find the range of the target. If the target does not exist, output [-1,-1].

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class Solution {
public:
 void bSearch(int A[],int left,int right,int target,int flag,int &val) {
 if(left > right) return;
 int mid = (left + right) / 2;
 if(A[mid] == target) {
 val = mid;
 if(flag == 0) {
 bSearch(A, left, mid-1, target, flag, val);
 } else {
 bSearch(A, mid+1, right, target, flag, val);
 }
 } else {
 if(A[mid] < target) {
 bSearch(A, mid+1, right, target, flag, val);
 } else {
 bSearch(A, left, mid-1, target, flag, val);
 }
 }
 }

 vector<int> searchRange(int A[], int n, int target) {
 vector<int> ans;
 ans.clear();
 int left = -1;
 int right = -1;
 bSearch(A, 0, n-1, target, 0, left);
 bSearch(A, 0, n-1, target, 1, right);
 ans.push_back(left);
 ans.push_back(right);
 return ans;
 }
};

[leetcode_90]Subsets II

Fri, 22 May 2015 02:05:45 +0000

A variation of http://blog.sina.com.cn/s/blog_672f71fc0101phtr.html.
Duplicate numbers are allowed, but duplicate subsets must be removed from the result.
Initially got TLE. After a small optimization: when checking whether the current subset already exists, iterate from back to front and stop as soon as the size differs.
If it still timed out, the plan was to use a map.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


int cmp(int a,int b) {
 return a < b;
}
class Solution {
public:
 bool CheckIn(vector<int> item1,vector<int> item2) {
 if(item1.size() != item2.size())return false;
 for(int i = 0;i < item1.size();i++) {
 if(item1[i] != item2[i])return false;
 }
 return true;
 }
 void AddItemStep(int i,int k,vector<int>&S,vector<vector<int>>&ans,vector<int>&item) {
 if(item.size() == k) {
 for(int i = ans.size()-1;i >= 0&&item.size() == ans[i].size();i--) {
 if(CheckIn(item,ans[i]) == true)return;
 }
 ans.push_back(item);
 return;
 }
 else {
 if(i >= S.size())return;
 item.push_back(S[i]);
 AddItemStep(i+1,k,S,ans,item);
 item.pop_back();
 AddItemStep(i+1,k,S,ans,item);
 }
 }
 void AddItem(int k,vector<int> &S,vector<vector<int>>&ans) {
 int i = 0;
 vector<int> item;
 item.clear();
 AddItemStep(i,k,S,ans,item);
 }
 vector<vector<int>> subsetsWithDup(vector<int> &S) {
 sort(S.begin(),S.end(),cmp);
 vector<vector<int>>ans;
 ans.clear();
 vector<int>item;
 item.clear();
 ans.push_back(item);
 for(int i = 1;i <= S.size();i++) {
 AddItem(i,S,ans);
 }
 return ans;
 }
};

[leetcode_63]Unique Paths II

Fri, 22 May 2015 02:04:32 +0000

A variation of Unique Paths
http://blog.sina.com.cn/s/blog_672f71fc0101pf1c.html. With obstacles added, just add a check for them.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70


struct PPoint
{
 int x;
 int y;
};
class Solution {
public:
 bool CheckIn(int x,int y,PPoint *p,int top)
 {
 for(int i = 0;i < top;i++)
 {
 if(x == p[i].x && y == p[i].y)
 {
 return true;
 }
 }
 return false;
 }
 int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) {
 int m = obstacleGrid.size();
 if(m <= 0 )return 0;
 int n = obstacleGrid[0].size();
 if(obstacleGrid[0][0] == 1 || obstacleGrid[m-1][n-1] == 1)return 0;
 for(int i = 0;i < m;i++)
 for(int j = 0;j < n;j++)
 if(obstacleGrid[i][j] == 1)obstacleGrid[i][j] = -1;
 PPoint *p = new PPoint[m+n];
 PPoint *p_c = new PPoint[m+n];
 int index = 0;
 p[index].x = 0;
 p[index++].y = 0;
 obstacleGrid[0][0] = 1;
 while(true)
 {
 int top = 0;
 for(int i = 0;i < index;i++)
 {
 int x = p[i].x;
 int y = p[i].y;
 if(x + 1 < m && obstacleGrid[x+1][y] != -1)
 {
 obstacleGrid[x+1][y] += obstacleGrid[x][y];
 if(CheckIn(x+1,y,p_c,top) == false)
 {
 p_c[top].x = x+1;
 p_c[top++].y = y;
 }
 }
 if(y + 1 < n && obstacleGrid[x][y+1] != -1)
 {
 obstacleGrid[x][y+1] += obstacleGrid[x][y];
 if(CheckIn(x,y+1,p_c,top) == false)
 {
 p_c[top].x = x;
 p_c[top++].y = y+1;
 }
 }
 }
 if(top == 0)
 break;
 index = top;
 for(int i = 0;i < top;i++)
 {
 p[i].x = p_c[i].x;
 p[i].y = p_c[i].y;
 }
 }
 return obstacleGrid[m-1][n-1];
 }
};

[leetcode_14]Longest Common Prefix

Fri, 22 May 2015 01:58:14 +0000

Given a set of strings, find their longest common prefix.
Just compare them one by one.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


class Solution {
public:
 bool EqualAll(vector<string>& strs, int k) {
 for(int i = 1; i < strs.size(); i++) {
 if(strs[i][k] != strs[0][k]) return false;
 }
 return true;
 }
 string longestCommonPrefix(vector<string>& strs) {
 string ans = "";
 if(strs.size() <= 0) return ans;
 int len = 0xffff;
 for(int i = 0; i < strs.size(); i++) {
 if(strs[i].size() < len) len = strs[i].size();
 }
 for(int i = 0; i < len; i++) {
 if(EqualAll(strs, i))
 ans.push_back(strs[0][i]);
 else
 return ans;
 }
 return ans;
 }
};

[leetcode_113]Path Sum II

Fri, 22 May 2015 01:56:30 +0000

Given a binary tree root and a target value, find all paths from the root to leaf nodes where the path sum equals the target.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


class Solution {
public:
 void MoveOnPath(TreeNode *node,int sum,int &val,vector<int>&item,vector<vector<int>>&ans) {
 if(node == NULL) return;
 if(node->left == NULL && node->right == NULL) {
 if(sum == val) ans.push_back(item);
 return;
 }
 if(node->left != NULL) {
 val += node->left->val;
 item.push_back(node->left->val);
 MoveOnPath(node->left, sum, val, item, ans);
 val -= node->left->val;
 item.pop_back();
 }
 if(node->right != NULL) {
 val += node->right->val;
 item.push_back(node->right->val);
 MoveOnPath(node->right, sum, val, item, ans);
 val -= node->right->val;
 item.pop_back();
 }
 }
 vector<vector<int>> pathSum(TreeNode *root, int sum) {
 vector<vector<int>> ans;
 ans.clear();
 if(root == NULL) return ans;
 int val = 0;
 vector<int> item;
 item.clear();
 val += root->val;
 item.push_back(root->val);
 MoveOnPath(root, sum, val, item, ans);
 return ans;
 }
};

[leetcode_78]Subsets

Fri, 22 May 2015 01:55:18 +0000

Given an array, e.g., {1,2,3,4}, find all subsets of the set.
Got one WA because the result needs to be in ascending order.
A search approach works.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


int cmp(int a,int b) {
 return a < b;
}
class Solution {
public:
 void AddItemStep(int i,int k,vector<int>&S,vector<vector<int>>&ans,vector<int>&item) {
 if(item.size() == k) {
 ans.push_back(item);
 return;
 }
 else {
 if(i >= S.size())return;
 item.push_back(S[i]);
 AddItemStep(i+1,k,S,ans,item);
 item.pop_back();
 AddItemStep(i+1,k,S,ans,item);
 }
 }
 void AddItem(int k,vector<int> &S,vector<vector<int>>&ans) {
 int i = 0;
 vector<int> item;
 item.clear();
 AddItemStep(i,k,S,ans,item);
 }
 vector<vector<int>> subsets(vector<int> &S) {
 sort(S.begin(),S.end(),cmp);
 vector<vector<int>>ans;
 ans.clear();
 vector<int>item;
 item.clear();
 ans.push_back(item);
 for(int i = 1;i <= S.size();i++) {
 AddItem(i,S,ans);
 }
 return ans;
 }
};

[leetcode_58]Length of Last Word

Fri, 22 May 2015 01:54:03 +0000

Given a string s consisting of spaces and letters, find the length of the last word. A word is defined as consisting only of letters.

class Solution {
public:
int lengthOfLastWord(const char *s) {
int length = strlen(s);
int index = length - 1;
while(s[index] == ' ')index--;
int ans = 0;
for(int i = index;i >= 0&&s[i] != ' ';i--)
ans++;
return ans;
}
};

[leetcode_16]3Sum Closest

Fri, 22 May 2015 01:52:59 +0000

Given an array and a target, find three numbers in the array whose sum is closest to the target. A unique solution is guaranteed.
A brute-force approach will time out.
You can sort the array, use two nested loops for brute force, and then apply binary search for the third layer. This avoids the timeout.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


int cmp(int a,int b) {
 return a < b;
}
class Solution {
public:
 int bSearch(int tmp,int left,vector<int>&num,int right) {
 if(right - left <= 1) {
 if(abs(tmp - num[left]) < abs(tmp - num[right])) {
 return num[left];
 }
 else {
 return num[right];
 }
 }
 int mid = (left + right) / 2;
 if(num[mid] == tmp)return tmp;
 else
 if(num[mid] > tmp) {
 return bSearch(tmp,left,num,mid-1);
 }
 else {
 return bSearch(tmp,mid+1,num,right);
 }
 }
 int threeSumClosest(vector<int> &num, int target) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int sum = 0;
 int dis = 0xffff;
 sort(num.begin(),num.end(),cmp);
 for(int i = 0;i < num.size()-2;i++) {
 for(int j = i+1;j < num.size()-1;j++) {
 int tmp = num[i] + num[j];
 tmp += bSearch(target-tmp,j+1,num,num.size()-1);
 if(abs(tmp-target) < dis) {
 sum = tmp;
 dis = abs(tmp-target);
 }
 }
 }
 return sum;
 }
};

[leetcode_42] Trapping Rain Water

Fri, 22 May 2015 01:51:54 +0000

As required by the problem, calculate the amount of trapped water.
First, find the maximum value within a segment that is greater than the smaller of the two boundary values. If such a value exists, split the problem into left + max index and max index + right.
If no such maximum exists, it means both boundaries are larger than all middle elements, so simply sum up the trapped water.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


class Solution {
public:
 int sum;
 void WaterStep(int A[],int left,int right) {
 int min = A[left] > A[right] ? A[right] : A[left];
 int max = min;
 int index = -1;
 for(int i = left+1; i < right; i++) {
 if(A[i] > max) {
 index = i;
 max = A[i];
 }
 }
 if(index == -1) {
 for(int i = left+1; i < right; i++)
 sum += min - A[i];
 }
 else {
 WaterStep(A, left, index);
 WaterStep(A, index, right);
 }
 }
 int trap(int A[], int n) {
 sum = 0;
 WaterStep(A, 0, n-1);
 return sum;
 }
};

[leetcode_142] Linked List Cycle II

Fri, 22 May 2015 01:42:11 +0000

Determine whether a linked list has a cycle, and return the node where the cycle begins. If there is no cycle, return NULL.
Detecting whether a linked list has a cycle without allocating extra space was mentioned in a previous blog post:
http://blog.sina.com.cn/s/blog_672f71fc0101odsf.html
How to find the entry node of the cycle?
If we can calculate the number of nodes k in the cycle, then using the approach of removing the nth node from the end:
http://blog.sina.com.cn/s/blog_672f71fc0101pfx6.html
This problem can be solved.
Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


class Solution {
public:
 ListNode *detectCycle(ListNode *head) {
 if(head == NULL)
 return NULL;
 ListNode * p1 = head;
 ListNode * p2 = head->next;
 if(p2 == NULL)
 return NULL;
 p2 = head->next;
 while(true)
 {
 if(p2 == NULL)
 {
 return NULL;
 }
 else
 if(p1 == p2)
 {
 break;
 }
 else
 {
 p1 = p1->next;
 p2 = p2->next;
 if(p2 == NULL)return NULL;
 p2 = p2->next;
 }
 }
 int k = 1;
 p1 = p1->next;
 p2 = p2->next->next;
 while(p1 != p2)
 {
 p1 = p1->next;
 p2 = p2->next->next;
 k++;
 }
 p1 = head;
 p2 = head;
 for(int i = 0;i < k;i++)
 {
 p2 = p2->next;
 }
 while(p1 != p2)
 {
 p1 = p1->next;
 p2 = p2->next;
 }
 return p1;
 }
};

[leetcode_62] Unique Paths

Fri, 22 May 2015 01:18:11 +0000

The original image link for this problem is broken, but based on the description: given an m*n matrix, find how many paths exist from point (0, 0) to point (m-1, n-1).
The movement rule is that each step can only go right or down from the current position.
Breadth-first search.
Here is the code:
AC on the first try. The code performance is probably not optimal.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


struct PPoint {
 int x;
 int y;
};
class Solution {
public:
 bool CheckIn(int x, int y, PPoint *p, int top) {
 for(int i = 0; i < top; i++) {
 if(x == p[i].x && y == p[i].y) {
 return true;
 }
 }
 return false;
 }
 int uniquePaths(int m, int n) {
 int **map = new int*[m];
 for(int i = 0; i < m; i++) {
 map[i] = new int[n];
 }
 for(int i = 0; i < m; i++) {
 for(int j = 0; j < n; j++) {
 map[i][j] = 0;
 }
 }
 map[0][0] = 1;
 PPoint *p = new PPoint[m+n];
 PPoint *p_c = new PPoint[m+n];
 int index = 0;
 p[index].x = 0;
 p[index++].y = 0;
 while(true) {
 int top = 0;
 for(int i = 0; i < index; i++) {
 int x = p[i].x;
 int y = p[i].y;
 if(x + 1 < m) {
 map[x+1][y] += map[x][y];
 if(CheckIn(x+1, y, p_c, top) == false) {
 p_c[top].x = x+1;
 p_c[top++].y = y;
 }
 }
 if(y + 1 < n) {
 map[x][y+1] += map[x][y];
 if(CheckIn(x, y+1, p_c, top) == false) {
 p_c[top].x = x;
 p_c[top++].y = y+1;
 }
 }
 }
 if(top == 0) break;
 index = top;
 for(int i = 0; i < top; i++) {
 p[i].x = p_c[i].x;
 p[i].y = p_c[i].y;
 }
 }
 return map[m-1][n-1];
 }
};

[leetcode_75]Sort Colors

Thu, 21 May 2015 08:15:06 +0000

Three colors: red, white, and blue, represented by 0, 1, and 2 respectively.
Given an array of 0s, 1s, and 2s, sort it – but you cannot use any built-in sorting library.
The approach is to traverse the array, count the occurrences of 0, 1, and 2, then overwrite the original array accordingly.
Code below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


class Solution {
public:
 void sortColors(int A[], int n) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 int count0 = 0;
 int count1 = 0;
 int count2 = 0;

 for(int i = 0; i < n; i++) {
 switch(A[i]) {
 case 0:
 count0++;
 break;
 case 1:
 count1++;
 break;
 case 2:
 count2++;
 break;
 }
 }

 for(int i = 0; i < count0; i++) {
 A[i] = 0;
 }
 for(int i = count0; i < count0 + count1; i++) {
 A[i] = 1;
 }
 for(int i = count0 + count1; i < count0 + count1 + count2; i++) {
 A[i] = 2;
 }
 }
};

[leetcode_112]Path Sum

Thu, 21 May 2015 08:13:49 +0000

Given a binary tree and a number sum, compute the sum along each path from the root to every leaf node. Determine whether any leaf node’s path sum equals sum.
This problem can be solved with BFS by enumerating all paths, but watch the edge cases: it must be a leaf node, and consider the cases where the root has no children or is null.
Code below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


class Solution {
public:
 bool hasPathSum(TreeNode *root, int sum) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 TreeNode ** seq = new TreeNode*[10000];
 TreeNode ** rseq = new TreeNode*[10000];
 if(root == NULL)
 return false;
 else
 {
 if(root->left == NULL && root->right == NULL)
 {
 if(root->val == sum)
 return true;
 else
 return false;
 }
 int index = 0;
 seq[index++] = root;
 while(true)
 {
 int top = index;
 index = 0;
 for(int i = 0;i < top;i++)
 {
 if(seq[i] != NULL)
 {
 if(seq[i]->left != NULL)
 {
 seq[i]->left->val += seq[i]->val;
 rseq[index++] = seq[i]->left;
 if(seq[i]->left->val == sum && seq[i]->left->left == NULL && seq[i]->left->right == NULL)
 return true;
 }
 if(seq[i]->right != NULL)
 {
 seq[i]->right->val += seq[i]->val;
 rseq[index++] = seq[i]->right;
 if(seq[i]->right->val == sum && seq[i]->right->left == NULL && seq[i]->right->right == NULL)
 return true;
 }
 }
 }
 if(index == 0)
 break;
 for(int i = 0;i < index;i++)
 {
 seq[i] = rseq[i];
 }
 }
 return false;
 }
 }
};

[leetcode_107]Binary Tree Level Order Traversal II

Thu, 21 May 2015 08:12:31 +0000

Output the binary tree levels from bottom to top.
Code below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


class Solution {
public:
 vector<vector<int> > levelOrderBottom(TreeNode *root) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 vector<vector<int>> result;
 result.clear();
 TreeNode **seq = new TreeNode *[1000];
 TreeNode **rseq = new TreeNode *[1000];
 int index = 0;
 seq[index++] = root;
 while(true)
 {
 int top = index;
 index = 0;
 vector<int> tmp;
 tmp.clear();
 for(int i = 0 ;i< top;i++)
 {
 if(seq[i] != NULL)
 {
 tmp.push_back(seq[i]->val);
 if (seq[i]->left != NULL)
 {
 rseq[index++] = seq[i]->left;
 }
 if (seq[i]->right != NULL)
 {
 rseq[index++] = seq[i]->right;
 }
 }
 }
 if(tmp.size() > 0)
 result.push_back(tmp);
 if(index == 0)
 break;
 for(int i = 0;i < index;i++)
 {
 seq[i] = rseq[i];
 }
 }
 vector<vector<int>> ans;
 ans.clear();
 for(int i = result.size() - 1;i >= 0;i--)
 {
 ans.push_back(result[i]);
 }
 return ans;
 }
};

[leetcode_145]Binary Tree Postorder Traversal

Thu, 21 May 2015 08:11:21 +0000

Postorder traversal of a binary tree, with a focus on code quality. AC on the first try, no separate testing needed.
Code below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
 vector<int> postorderTraversal(TreeNode *root) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 vector<int> result;
 result.clear();
 if (NULL != root) {
 Traversal(root->left, result);
 Traversal(root->right, result);
 result.push_back(root->val);
 }
 return result;
 }

 void Traversal(TreeNode * now, vector<int>& result) {
 if (NULL != now) {
 Traversal(now->left, result);
 Traversal(now->right, result);
 result.push_back(now->val);
 }
 }
};

[leetcode_94]Binary Tree Inorder Traversal

Thu, 21 May 2015 08:10:09 +0000

Left-root-right, inorder traversal.
Code below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
 vector<int> result;
 vector<int> inorderTraversal(TreeNode *root) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 result.clear();
 if(root == NULL)
 return result;
 Traversal(root->left);
 result.push_back(root->val);
 Traversal(root->right);
 return result;
 }
 void Traversal(TreeNode * now)
 {
 if(now == NULL)
 return ;
 Traversal(now->left);
 result.push_back(now->val);
 Traversal(now->right);
 }
};

[leetcode_64]Minimum Path Sum

Thu, 21 May 2015 08:08:44 +0000

BFS approach. The earlier TLE was because I had written a DFS instead.
After switching, AC on the first try. Code below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66


class Solution {
public:
 int rows;
 int cols;
 int minnow;
 int minPathSum(vector<vector<int>> &grid) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 rows = grid.size()-1;
 cols = grid[0].size()-1;

 vector<vector<int>> copygrid(grid.size());
 int sum = 0;
 for(int i = 0; i < grid.size(); i++) {
 for(int j = 0; j < grid[0].size(); j++) {
 sum += grid[i][j];
 }
 }

 for(int i = 0; i < grid.size(); i++) {
 vector<int> tmp(grid[0].size());
 for(int j = 0; j < grid[0].size(); j++) {
 tmp[j] = sum;
 }
 copygrid[i] = tmp;
 }
 copygrid[0][0] = grid[0][0];

 int px[10000], py[10000];
 int cpx[20000], cpy[20000];
 int index = 0;
 px[index] = 0;
 py[index++] = 0;
 while(true) {
 int top = index;
 index = 0;
 for(int i = 0; i < top; i++) {
 int x = px[i];
 int y = py[i];
 if(x + 1 <= rows) {
 if(copygrid[x][y] + grid[x+1][y] < copygrid[x+1][y]) {
 copygrid[x+1][y] = copygrid[x][y] + grid[x+1][y];
 cpx[index] = x+1;
 cpy[index] = y;
 index++;
 }
 }
 if(y + 1 <= cols) {
 if(copygrid[x][y] + grid[x][y+1] < copygrid[x][y+1]) {
 copygrid[x][y+1] = copygrid[x][y] + grid[x][y+1];
 cpx[index] = x;
 cpy[index] = y+1;
 index++;
 }
 }
 }
 if(index == 0)
 break;
 for(int i = 0; i < index; i++) {
 px[i] = cpx[i];
 py[i] = cpy[i];
 }
 }
 return copygrid[rows][cols];
 }
};

[leetcode_88]Merge Sorted Array

Thu, 21 May 2015 08:07:29 +0000

Merge array B into array A. Both A and B are originally sorted, and the result should remain sorted.
Insertion sort.
Though I wonder why my insertion sort implementation turned out so verbose.
Code below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


class Solution {
public:
 void merge(int A[], int m, int B[], int n) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 for(int i = 0;i < n;i++)
 {
 Insert(A,m+i,B[i]);
 }
 }
 void Insert(int A[],int lengthA,int val)
 {
 if(lengthA == 0)
 {
 A[lengthA] = val;
 return;
 }
 if(val > A[lengthA-1])
 {
 A[lengthA] = val;
 return ;
 }
 int i;
 for(i = lengthA-1;i >= 0;i--)
 {
 if(val < A[i])
 {
 A[i+1] = A[i];
 }
 else
 {
 A[i+1] = val;
 break;
 }
 }
 if(i == -1)
 {
 A[0] = val;
 }
 }
};

[leetcode_21]Merge Two Sorted Lists

Thu, 21 May 2015 08:05:52 +0000

Merge two sorted singly linked lists.
AC on the first try.
Code below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73


class Solution {
public:
 ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 if(l1 == NULL)
 return l2;
 if(l2 == NULL)
 return l1;
 int val;
 if(l1->val < l2->val)
 {
 val = l1->val;
 l1 = l1->next;
 }
 else
 {
 val = l2->val;
 l2 = l2 ->next;
 }
 ListNode * l = new ListNode(val);
 ListNode * lcopy = l;
 int flag = 0;
 while(true)
 {
 if(l1 == NULL)
 {
 flag = 1;
 break;
 }
 if(l2 == NULL)
 {
 flag = 2;
 break;
 }
 if(l1->val < l2->val)
 {
 val = l1->val;
 l1 = l1->next;
 }
 else
 {
 val = l2->val;
 l2 = l2 ->next;
 }
 ListNode * tmp = new ListNode(val);
 lcopy->next = tmp;
 lcopy = lcopy->next;
 }
 if(flag == 1)
 {
 while(l2 != NULL)
 {
 val = l2->val;
 l2 = l2->next;
 ListNode * tmp = new ListNode(val);
 lcopy->next = tmp;
 lcopy = lcopy->next;
 }
 }
 if(flag == 2)
 {
 while(l1 != NULL)
 {
 val = l1->val;
 l1 = l1->next;
 ListNode * tmp = new ListNode(val);
 lcopy->next = tmp;
 lcopy = lcopy->next;
 }
 }
 return l;
 }
};

[leetcode_101]Symmetric Tree

Thu, 21 May 2015 08:04:08 +0000

I recall reading in “Programming Pearls” that you should first have an idea – an “aha!” moment of inspiration – then find a suitable data structure, and finally write the code. That’s my understanding of the process.
As for this problem, well… ever since I learned about binary tree serialization, I’ve been using it everywhere. But here it kept giving me WA – 188 out of 190 test cases passed.
Frustrating.
After struggling for a day, I couldn’t resist and looked at other people’s approaches. So little code! Painful.
It’s actually just recursion. The key insight during recursion is to mirror: compare the left child’s left subtree with the right child’s right subtree, and vice versa.
Code below. After changing the approach, AC on the first try.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


class Solution {
public:
 bool isSymmetric(TreeNode *root) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 if(root == NULL)
 return true;
 return CheckEqual(root->left,root->right);
 }
 bool CheckEqual(TreeNode * left,TreeNode * right)
 {
 if(left == NULL && right == NULL)
 return true;
 if((left == NULL && right != NULL)||(left != NULL && right == NULL))
 return false;
 if(left->val != right->val)
 return false;
 return CheckEqual(left->left,right->right)&&CheckEqual(left->right,right->left);
 }
};

[leetcode_96]Unique Binary Search Trees

Thu, 21 May 2015 08:02:33 +0000

Since it’s a binary search tree, we iterate based on choosing different roots.
Code below. AC on the first try, though it took me a while to figure it out.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
 int numTrees(int n) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 if(n == 1)return 1;
 if(n == 2)return 2;
 if(n == 3)return 5;
 int *num = new int[n + 1];
 num[0] = 1;
 num[1] = 1;
 num[2] = 2;
 num[3] = 5;
 for(int i = 4;i <= n;i++)
 {
 num[i] = 0;
 for(int j = 1;j <= i;j++)
 {
 num[i] += num[j-1]*num[i-j];
 }
 }
 return num[n];
 }
};

[leetcode_144]Binary Tree Preorder Traversal

Thu, 21 May 2015 08:01:09 +0000

Ugh. I got AC using recursion but it didn’t count as accepted – the problem wasn’t checked off. As someone with a bit of OCD, that’s painful. I’ll think of another approach later.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class Solution {
public:
 vector<int> ans;
 vector<int> preorderTraversal(TreeNode *root) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 ans.clear();
 fun(root);
 return ans;
 }
 void fun(TreeNode *root) {
 if (root != NULL) {
 ans.push_back(root->val);
 if (root->left != NULL)
 fun(root->left);
 if (root->right != NULL)
 fun(root->right);
 }
 }
};

[leetcode_102]Binary Tree Level Order Traversal

Thu, 21 May 2015 07:59:36 +0000

Binary tree serialization by level.

AC on the first try. Code below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


class Solution {
public:
 vector<vector<int> > levelOrder(TreeNode *root) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 vector<vector<int>> ans;
 ans.clear();
 TreeNode ** seq = new TreeNode *[100000];
 TreeNode ** rseq = new TreeNode *[100000];

 int index = 0;
 seq[index++] = root;
 int top = index;
 while(true)
 {
 index = 0;
 vector<int> tmp;
 tmp.clear();
 int flag = 0;
 for(int i = 0;i < top;i++)
 {
 if(seq[i] != NULL)
 {
 if(seq[i]->left != NULL)
 rseq[index++] = seq[i]->left;
 if(seq[i]->right != NULL)
 rseq[index++] = seq[i]->right;
 tmp.push_back(seq[i]->val);
 flag = 1;
 }
 }
 if(flag == 1)
 ans.push_back(tmp);
 else
 break;
 if(index == 0)
 break;
 for(int i = 0;i < index;i++)
 {
 seq[i] = rseq[i];
 }
 top = index;
 }
 return ans;
 }
};

[leetcode_116]Populating Next Right Pointers in Each Node

Thu, 21 May 2015 03:03:31 +0000

This problem gave me a new understanding of binary tree serialization.

1
2 3
4 5 6

A tree like this is serialized as: 1 2 3 4 # 5 6
Which means:
1 | 2 3 | 4 # 5 6
representing the first, second, and third levels respectively.
With this approach, we just need to enumerate level by level.
Watch out for out-of-bounds issues. Code below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


class Solution {
public:
 void connect(TreeLinkNode *root) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int height = -1;
 TreeLinkNode * rootheight = root;
 while(rootheight != NULL)
 {
 height++;
 rootheight = rootheight->left;
 }
 int NumOfNodes = (int)pow(2.0,height+1) - 1;
 TreeLinkNode ** LinkNodeArray = new TreeLinkNode *[NumOfNodes];
 int index = 0;
 LinkNodeArray[index++] = root;
 int bottom = 0;
 int top = index;
 while(true)
 {
 if(bottom == top)
 break;
 for(int i = bottom;i < top;i++)
 {
 if(LinkNodeArray[i] == NULL)
 continue;
 if(i == top-1)
 {
 LinkNodeArray[i] ->next = NULL;
 if(LinkNodeArray[i]->left != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->left;
 if(LinkNodeArray[i]->right != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->right;
 }
 else
 {
 LinkNodeArray[i] ->next = LinkNodeArray[i+1];
 if(LinkNodeArray[i]->left != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->left;
 if(LinkNodeArray[i]->right != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->right;
 }
 }
 bottom = top;
 top = index;
 }
 }
};

[leetcode_74]Search a 2D Matrix

Thu, 21 May 2015 03:01:41 +0000

Two binary searches, AC on the first try. Watch out for out-of-bounds issues.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


using namespace std;
class Solution {
public:
 bool searchMatrix(vector<vector<int>> &matrix, int target) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 if(matrix.size() <= 0)
 return false;
 if(target > matrix[matrix.size()-1][matrix[0].size()-1])
 return false;
 vector<int>cols(matrix.size());
 for(int i = 0; i < matrix.size(); i++) {
 cols[i] = matrix[i][matrix[0].size()-1];
 }
 int colindex = bsearch(0, (int)(matrix.size()), cols, target);
 if(colindex == -1)
 return true;
 int rowindex = bsearch(0, (int)(matrix[colindex].size()), matrix[colindex], target);
 if(rowindex == -1)
 return true;
 return false;
 }
 int bsearch(int left, int right, vector<int> seq, int target) {
 if(left > right) {
 return right + 1;
 }
 int mid = (left + right) / 2;
 if(seq[mid] == target) {
 return -1;
 } else if(seq[mid] < target) {
 return bsearch(mid+1, right, seq, target);
 } else {
 return bsearch(left, mid-1, seq, target);
 }
 }
};

[leetcode_141]Linked List Cycle

Thu, 21 May 2015 03:00:15 +0000

This problem asks you to determine whether a singly linked list has a cycle, without using extra space.
At first I really didn’t know how to solve it, so I looked at other people’s solutions.
The idea is to use two pointers: one advances one step at a time, the other advances two steps. If they reach NULL without ever being equal, there is no cycle. If they become equal, a cycle exists.
Code below. I honestly feel my pointer and linked list skills are pretty weak.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


class Solution {
public:
 bool hasCycle(ListNode *head) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 ListNode * step1 = head;
 ListNode * step2 = head;
 while(true)
 {
 if(step1 == NULL)
 {
 return false;
 }
 step1 = step1->next;

 if(step2 == NULL || step2->next == NULL)
 {
 return false;
 }

 step2 = step2->next->next;

 if(step1 == step2)
 {
 return true;
 }
 }
 }
};

[leetcode_119]Pascal's Triangle II

Thu, 21 May 2015 02:53:53 +0000

Note that k is 0-indexed.
Code below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


class Solution {
public:
 vector<int> getRow(int rowIndex) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 rowIndex++;
 vector<int> ans(rowIndex);
 if(rowIndex == 1)
 {
 ans[0] = 1;
 }
 else
 if(rowIndex == 2)
 {
 ans[0] = 1;
 ans[1] = 1;
 }
 else
 {
 ans[0] = 1;
 ans[1] = 2;
 ans[2] = 1;
 for(int i = 4;i <= rowIndex;i++)
 {
 ans[0] = 1;
 ans[i-1] = 1;
 for(int j = i-2;j >= 1;j--)
 {
 ans[j] = ans[j-1] + ans[j];
 }
 }
 }
 return ans;
 }
};

[leetcode_59] Spiral Matrix II

Thu, 21 May 2015 02:51:54 +0000

Output a spirally growing matrix. AC on the second try – watch out for the n=0 case.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86


class Solution {
public:
 vector<vector<int> > generateMatrix(int n) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 vector<vector<int>> ans(n);
 if(n == 0)
 {
 ans.clear();
 return ans;
 }
 int **map = new int*[n];
 for(int i = 0; i < n; i++)
 {
 map[i] = new int[n];
 }
 int val = 1;
 int x = 0;
 int y = 0;
 int dir = 1; // 1 right 2 down 3 left 4 up
 int r1 = -1;
 int r2 = n;
 int l1 = -1;
 int l2 = n;
 while(true)
 {
 map[x][y] = val;
 switch(dir)
 {
 case 1:
 y++;
 if(y == l2)
 {
 dir = 2;
 y--;
 x++;
 r1++;
 }
 break;
 case 2:
 x++;
 if(x == r2)
 {
 dir = 3;
 x--;
 y--;
 l2--;
 }
 break;
 case 3:
 y--;
 if(y == l1)
 {
 dir = 4;
 y++;
 x--;
 r2--;
 }
 break;
 case 4:
 x--;
 if(x == r1)
 {
 dir = 1;
 x++;
 y++;
 l1++;
 }
 break;
 }
 if(val == n*n)
 break;
 val++;
 }
 for(int i = 0; i < n; i++)
 {
 vector<int> tmp(n);
 for(int j = 0; j < n; j++)
 {
 tmp[j] = map[i][j];
 }
 ans[i] = tmp;
 }
 return ans;
 }
};

[leetcode_118]Pascal's Triangle

Wed, 20 May 2015 01:36:19 +0000

Simple array or vector manipulation, AC on the first try.
Find the relationship between adjacent rows.
Code below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


class Solution {
public:
 vector<vector<int>> generate(int numRows) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 vector<vector<int>> ans(numRows);
 for(int i = 1; i <= numRows; i++)
 {
 vector<int> tmp(i);
 if(i == 1)
 {
 tmp[0] = 1;
 ans[i-1] = tmp;
 continue;
 }
 if(i == 2)
 {
 tmp[0] = 1;
 tmp[1] = 1;
 ans[i-1] = tmp;
 continue;
 }
 tmp[0] = 1;
 tmp[i-1] = 1;
 for(int j = 1; j < i-1; j++)
 {
 tmp[j] = ans[i-2][j-1] + ans[i-2][j];
 }
 ans[i-1] = tmp;
 }
 return ans;
 }
};

[leetcode_120]Triangle

Wed, 20 May 2015 01:34:23 +0000

Simple DP problem. Accepted on the first try. Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


class Solution {
public:
 int minimumTotal(vector<vector<int>> &triangle) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 for(int i = triangle.size()-2; i >= 0; i--) {
 for(int j = 0; j < triangle[i].size(); j++) {
 if(triangle[i][j] + triangle[i+1][j] < triangle[i][j] + triangle[i+1][j+1]) {
 triangle[i][j] = triangle[i][j] + triangle[i+1][j];
 } else {
 triangle[i][j] = triangle[i][j] + triangle[i+1][j+1];
 }
 }
 }
 return triangle[0][0];
 }
};

[leetcode_53]Maximum Subarray

Wed, 20 May 2015 01:33:07 +0000

Find the contiguous subarray with the largest sum.

Did not get Accepted on the first try – my coding skills really need improvement. Pay attention to boundary conditions. I feel this code is not great.

Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


class Solution {
public:
 int maxSubArray(int A[], int n) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int sum = 0;
 if(n == 1)
 {
 return A[0];
 }
 int * value = new int[n];
 if(A[0] <= 0)
 value[0] = 0;
 else
 {
 value[0] = A[0];
 if(value[0] > sum)
 sum = value[0];
 }
 for(int i = 1;i < n;i++)
 {
 if(A[i] + value[i-1] > 0)
 {
 value[i] = A[i] + value[i-1];
 if(value[i] > sum)
 sum = value[i];
 }
 else
 {
 value[i] = 0;
 }
 }
 if(sum == 0)
 {
 sum = -999999999;
 for(int i = 0;i < n;i++)
 {
 if(A[i] > sum)
 sum = A[i];
 }
 }
 return sum;
 }
};

[leetcode_122]Best Time to Buy and Sell Stock II

Wed, 20 May 2015 01:31:40 +0000

I used to think this problem was really hard, but the acceptance rate was so high. I was frustrated wondering why I couldn’t solve it.

Then yesterday, after solving Part I on a whim, everything suddenly clicked.

The problem requires that you must buy before you sell, and you can only buy again after selling. You can make multiple transactions. What is the maximum profit?

The solution: compute the day-to-day price differences, then sum up all the positive differences.

Accepted on the first try:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


class Solution {
public:
 int maxProfit(vector<int> &prices) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int sum = 0;
 if(prices.size() <= 0)
 return sum;
 vector<int> dis(prices.size()-1);
 for(int i = 1;i < prices.size();i++)
 {
 dis[i-1] = prices[i] - prices[i-1];
 }
 for(int i = 0;i < dis.size();i++)
 {
 if(dis[i] > 0)
 {
 sum += dis[i];
 }
 }
 return sum;
 }
};

[leetcode_47]Permutations II

Wed, 20 May 2015 01:30:13 +0000

Got TLE on the first attempt as expected. I realized that my duplicate checking was using linear time each time, which was too slow.

This is where a data structure called map comes in handy.

After switching to map, it passed in 888ms.

I still need to study and practice map usage more. Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


#include <map>

using namespace std;

class Solution {
public:
 vector<vector<int>> ans;
 map<vector<int>, int> markmap;
 bool flag[100000];
 int sum;

 vector<vector<int>> permuteUnique(vector<int> &num) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 ans.clear();
 markmap.clear();
 sum = num.size();
 for(int i = 0; i < sum; i++) {
 flag[i] = false;
 }
 for(int i = 0; i < sum; i++) {
 flag[i] = true;
 vector<int> tmp(sum);
 tmp[0] = i;
 fun(tmp, 1, num);
 flag[i] = false;
 }
 return ans;
 }

 void fun(vector<int> &tmp, int k, vector<int> &num) {
 if(k >= sum) {
 vector<int> numtmp(sum);
 for(int i = 0; i < sum; i++) {
 numtmp[i] = num[tmp[i]];
 }
 map<vector<int>, int>::iterator l_it = markmap.find(numtmp);
 if(markmap.empty() || l_it == markmap.end()) {
 ans.push_back(numtmp);
 markmap[numtmp] = 590;
 }
 return;
 }
 for(int i = 0; i < sum; i++) {
 if(!flag[i]) {
 flag[i] = true;
 tmp[k] = i;
 fun(tmp, k + 1, num);
 flag[i] = false;
 }
 }
 }
};

[leetcode_15]3Sum

Tue, 19 May 2015 04:53:43 +0000

Want to know why I almost gave up later? It was because I got stuck on the 3Sum problem, which prevented me from picking high-acceptance-rate problems to work on. The 3Sum problem also kept giving me OLE!

The 3Sum problem asks: given a sequence, find all triplets whose sum equals zero.

At first I naively thought it would be as simple as the 2Sum problem with a greedy two-pointer approach. But no.

My approach:

Sort the array in O(n log n)
Enumerate three cases: two negatives and one positive, three zeros, one negative and two positives
O(n^2) complexity, using binary search for the third number

This should actually be faster than strict O(n^2).

I was worried about TLE from the start. But instead it gave me Output Limit Exceeded – so frustrating.

After modifying the code, finally Accepted:

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133


#include <algorithm>

using namespace std;
int cmp(int a,int b) {
 return a < b;
}
class Solution {
public:
 vector<vector<int>> threeSum(vector<int> &num) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 vector<vector<int>> ans;
 ans.clear();
 int *seq = new int[num.size()];
 for(int i = 0; i < num.size(); i++) {
 seq[i] = num[i];
 }
 sort(seq, seq + num.size(), cmp);
 int count0 = 0;
 int left = -1;
 int right = -1;
 for(int i = 0; i < num.size(); i++) {
 if(seq[i] == 0) {
 if(left == -1) {
 left = i - 1;
 }
 count0++;
 }
 if(seq[i] > 0) {
 if(left == -1) {
 left = i - 1;
 }
 if(right == -1) {
 right = i;
 break;
 }
 }
 }
 int index = 0;
 if(left == -1 || right == -1) {
 if(count0 >= 3) {
 vector<int> ivector(3, 0);
 ans.push_back(ivector);
 }
 return ans;
 }
 //two negatives and one positive
 for(int i = 0; i < left; i++) {
 for(int j = i + 1; j <= left; j++) {
 int a[3];
 a[0] = seq[i];
 a[1] = seq[j];
 a[2] = (seq[i] + seq[j]) * (-1);
 if(bsearch(right, num.size() - 1, seq, a[2]) == true) {
 vector<int> ivector(a, a + 3);
 bool flag = false;
 for(int k = 0; k < ans.size(); k++) {
 if(ivector == ans[k]) {
 flag = true;
 break;
 }
 }
 if(flag == false)
 ans.push_back(ivector);
 }
 }
 }
 if(count0 >= 1) {
 for(int i = 0; i <= left; i++) {
 if(i >= 1) {
 if(seq[i] == seq[i - 1])
 continue;
 }
 int a[3];
 a[0] = seq[i];
 a[1] = 0;
 a[2] = seq[i] * (-1);
 if(bsearch(right, num.size() - 1, seq, a[2]) == true) {
 vector<int> ivector(a, a + 3);
 bool flag = false;
 for(int k = 0; k < ans.size(); k++) {
 if(ivector == ans[k]) {
 flag = true;
 break;
 }
 }
 if(flag == false)
 ans.push_back(ivector);
 }
 }
 }
 //three zeros
 if(count0 >= 3) {
 vector<int> ivector(3, 0);
 ans.push_back(ivector);
 }
 //one negative and two positives
 for(int i = right; i < num.size() - 1; i++) {
 for(int j = i + 1; j < num.size(); j++) {
 if(i != j) {
 int a[3];
 a[1] = seq[i];
 a[2] = seq[j];
 a[0] = (seq[i] + seq[j]) * (-1);
 if(bsearch(0, left, seq, a[0]) == true) {
 vector<int> ivector(a, a + 3);
 bool flag = false;
 for(int k = 0; k < ans.size(); k++) {
 if(ivector == ans[k]) {
 flag = true;
 break;
 }
 }
 if(flag == false)
 ans.push_back(ivector);
 }
 }
 }
 }
 return ans;
 }
 bool bsearch(int left, int right, int *num, int a) {
 if(left > right)
 return false;
 int mid = (left + right) / 2;
 if(num[mid] == a) return true;
 if(num[mid] > a) {
 return bsearch(left, mid - 1, num, a);
 }
 if(num[mid] < a) {
 return bsearch(mid + 1, right, num, a);
 }
 }
};

[leetcode_46]Permutations

Tue, 19 May 2015 04:51:31 +0000

Generate all permutations of the input array and output them.

I kept getting Output Limit Exceeded and couldn’t figure out why.

I remembered asking a friend about it, and he said my output was larger than expected. The judge gave OLE after checking.

That felt even worse than getting TLE – at least with TLE I could optimize my code!

Later I wondered if there were duplicate elements in the array. I tried checking for duplicates before inserting into the vector, but still got OLE.

Finally I gave up and looked at other people’s solutions. The approach was the same as mine.

Then I suddenly noticed there’s a problem called Permutations II, which says the data may contain duplicates – meaning this problem’s data should NOT have duplicates!

Looking more carefully at others’ code, I noticed something more professional: vector.clear().

Just that one line was missing.

After adding it – Accepted!

Here is the code (a bit rough):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


class Solution {
public:
 vector<vector<int>> ans;
 bool flag[100000];
 int sum;
 vector<vector<int>> permute(vector<int> &num) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 sum = num.size();
 ans.clear();
 for(int i = 0;i < sum;i++) {
 flag[i] = false;
 }
 for(int i = 0;i < sum;i++) {
 flag[i] = true;
 vector<int> tmp(sum);
 tmp[0] = i;
 fun(tmp,1,num);
 flag[i] = false;
 }
 return ans;
 }
 void fun(vector<int> &tmp,int k,vector<int> &num) {
 if(k >= sum) {
 vector<int> numtmp(sum);
 for(int i = 0;i < sum;i++) {
 numtmp[i] = num[tmp[i]];
 }
 ans.push_back(numtmp);
 return ;
 }
 for(int i = 0;i < sum;i++) {
 if(!flag[i]) {
 flag[i] = true;
 tmp[k] = i;
 fun(tmp,k+1,num);
 flag[i] = false;
 }
 }
 }
};

[leetcode_121]Best Time to Buy and Sell Stock

Tue, 19 May 2015 04:48:56 +0000

I honestly didn’t expect to solve this one on my own, and the process was quite a journey. Persistence pays off!

The problem is roughly: you are trading stocks and can only make one transaction (buy once, sell once). On which day should you buy and on which later day should you sell to maximize profit?

I thought this would be easy – just brute force it. Of course, that resulted in TLE.

Then I racked my brain trying to figure out how to reduce the time complexity. Sorting? Greedy? It felt similar to the 2Sum problem, especially after drawing vertical lines on a graph.

Then it hit me: the difference between consecutive days represents the price change. If I compute these differences and then find the maximum contiguous subarray sum, the problem is solved!

I gave it a try and – AC!

Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


class Solution {
public:
 int maxProfit(vector<int> &prices) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int max = 0;
 if(prices.size() <= 1)
 return max;
 vector<int> dis(prices.size()-1);
 for(int i = 1;i < prices.size();i++) {
 dis[i-1] = prices[i] - prices[i-1];
 }
 vector<int> value(dis.size());
 for(int i = 0;i < dis.size();i++) {
 value[i] = dis[i];
 }
 if(dis[0] < 0)
 value[0] = 0;
 else
 value[0] = dis[0];
 for(int i = 1;i < value.size();i++) {
 if(value[i-1] + value[i] < 0) {
 value[i] = 0;
 } else {
 value[i] = value[i-1] + value[i];
 }
 }
 for(int i = 0;i < value.size();i++) {
 if(value[i] > max) {
 max = value[i];
 }
 }
 return max;
 }
};

[leetcode_66]Plus One

Tue, 19 May 2015 04:45:51 +0000

Big number addition. Accepted on the first try. The solution may not be optimal.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


class Solution {
public:
 vector<int> plusOne(vector<int> &digits) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 vector<int> ans(digits.size()+1);
 for(int i = 0;i < ans.size();i++)
 {
 ans[i] = 0;
 }
 int in = 1;
 for(int i = digits.size() - 1;i >= 0;i--)
 {
 int now = digits[i] + in;
 ans[i+1] = now % 10;
 in = now / 10;
 }
 ans[0] = in;
 if(ans[0] != 0)
 return ans;
 else
 {
 vector<int> result(digits.size());
 for(int i = 0;i < digits.size();i++)
 {
 result[i] = ans[i+1];
 }
 return result;
 }
 }
};

[leetcode_26] Remove Duplicates from Sorted Array

Tue, 19 May 2015 04:43:07 +0000

Remove duplicate elements from a sorted array without allocating extra space.

Use insertion sort-style swapping to move duplicates to the end of the array. Somewhat similar to the previous problem.

Accepted on the first try. Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


class Solution {
public:
 int removeDuplicates(int A[], int n) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int count = 0;
 int now = A[0];
 for(int i = 1; i < n-count; i++) {
 if(now == A[i]) {
 for(int j = i+1; j < n-count; j++) {
 int tmp = A[j];
 A[j] = A[j-1];
 A[j-1] = tmp;
 }
 count++;
 i--;
 } else {
 now = A[i];
 }
 }
 return n - count;
 }
};

[leetcode_27]Remove Element

Mon, 18 May 2015 01:57:48 +0000

This problem was tricky! You really need to understand English well and read the problem carefully.

At first I thought I just needed to return the length after deletion. But that’s not all – you also need to make sure the first length elements of array A are valid.

Got WA at first, then Accepted on the next try.

Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class Solution {
public:
 int removeElement(int A[], int n, int elem) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int length = 0;
 int *B = new int[n];
 for(int i = 0;i < n;i++)
 {
 if(A[i] != elem)
 {
 B[length++] = A[i];
 }
 }
 for(int i = 0;i < length;i++)
 {
 A[i] = B[i];
 }
 return length;
 }
};

A better approach would be to use two pointers and swap elements with the end of the array.

[leetcode_70]Climbing Stairs

Mon, 18 May 2015 01:55:36 +0000

Climbing stairs: you can either climb one step or two steps at a time. How many different ways can you climb to the top?

Using a search approach would result in TLE. So I switched to an iterative approach:
a[n] = a[n-1] + a[n-2]
Accepted on the first try.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


class Solution {
public:
 int climbStairs(int n) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int a1 = 1;
 int a2 = 2;
 if(n == 1)
 {
 return a1;
 }
 if(n == 2)
 {
 return a2;
 }
 int index = 3;
 int before = a2;
 int now = a1 + a2;
 while(true)
 {
 if(index == n)
 {
 return now;
 }
 int tmp = before;
 before = now;
 now = tmp + before;
 index++;
 }
 }
};

[leetcode_83]Remove Duplicates from Sorted List

Mon, 18 May 2015 01:41:36 +0000

Remove duplicate values from a sorted linked list. For linked list problems, I’ve found that keeping track of before, now, and next pointers makes the logic much simpler.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


class Solution {
public:
 ListNode *deleteDuplicates(ListNode *head) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 ListNode *headbackup = head;
 int val = 0;
 if(head == NULL)
 {
 return headbackup;
 }
 ListNode * before = head;
 ListNode * now = head->next;
 val = before->val;
 while(now != NULL)
 {
 if(val != now->val)
 {
 val = now->val;
 before = now;
 now = now->next;
 }
 else
 {
 now = now->next;
 before->next = now;
 }
 }
 return headbackup;
 }
};

[leetcode_35]Search Insert Position

Mon, 18 May 2015 01:37:10 +0000

Simple problem, use binary search. If the target is found, return its index; if not, return the index where it should be inserted.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class Solution {
public:
 int ans;
 int searchInsert(int A[], int n, int target) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 ans = 0;
 bsearch(0,n-1,A,target);
 return ans;
 }
 void bsearch(int left,int right,int A[],int target)
 {
 if(left &amp;gt; right)
 {
 ans = left;
 return ;
 }
 int mid = (left + right) / 2;
 if(A[mid] == target)
 {
 ans = mid;
 return ;
 }
 else
 if(A[mid] &amp;gt; target)
 {
 bsearch(left,mid-1,A,target);
 }
 else
 {
 bsearch(mid+1,right,A,target);
 }
 }
};

[leetcode_100]Same Tree

Mon, 18 May 2015 01:31:33 +0000

Check whether two trees are exactly the same. Accepted on the first try by simply enumerating all cases.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


class Solution {
public:
 bool ans;
 bool isSameTree(TreeNode *p, TreeNode *q)
 {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 ans = true;
 check(p,q);
 return ans;
 }
 void check(TreeNode *p,TreeNode *q)
 {
 if((p == NULL && q != NULL) || (p != NULL && q == NULL))
 {
 ans = false;
 return;
 }
 else
 if(p == NULL && q == NULL)
 {
 return ;
 }
 else
 {
 if(p->val != q->val)
 {
 ans = false;
 return;
 }
 else
 {
 check(p->left,q->left);
 check(p->right,q->right);
 }
 }
 }
};

[leetcode_104]Maximum Depth of Binary Tree

Sun, 17 May 2015 02:06:07 +0000

The problem is straightforward: given a binary tree, find its depth.

Got a Runtime Error once and a Compile Error once (due to redefinition in submitted code). Finally got Accepted.

For the RE, note that if root is NULL, you need to return 0 immediately. Otherwise, just use DFS.

Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


class Solution {
public:
 int depth;
 int maxDepth(TreeNode *root) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 if(root == NULL)
 return 0;
 depth = 1;
 query(root,1);
 return depth;
 }
 void query(TreeNode *node,int k)
 {
 if(node->left == NULL && node->right == NULL)
 {
 if(k > depth)
 depth = k;
 }
 if(node->left != NULL)
 {
 query(node->left,k+1);
 }
 if(node->right != NULL)
 {
 query(node->right,k+1);
 }
 }
};

[leetcode_136]Single Number

Sun, 17 May 2015 02:04:07 +0000

Given an array where every element appears twice except for one, find that single element without using extra memory.

This problem can be solved using XOR, which requires no extra memory.

Accepted on the first try. Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Solution {
public:
 int singleNumber(int A[], int n) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int ans = A[0];
 for(int i = 1; i < n; i++)
 {
 ans = ans ^ A[i];
 }
 return ans;
 }
};

[LeetCode 13] Roman to Integer

Sun, 17 May 2015 02:01:11 +0000

This is the reverse of the previous problem.

Hehe, my first sneaky thought was to use the previous problem’s code to build a lookup table for all numbers up to 3999, but I felt that would be too cheap.

So I decided to solve it properly.

Of course, the previous solution had way too many switch statements and if-else blocks.

So I decided to improve the approach.

Here’s the code – AC on the first try again:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


class Solution {
public:
 int num;
 int romanToInt(string s) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 num = 0;
 string sub[] = {
 "CM","DCCC","DCC","DC","D","CD","CCC","CC","C",
 "XC","LXXX","LXX","LX","L","XL","XXX","XX","X",
 "IX","VIII","VII","VI","V","IV","III","II","I"
 };
 int q[] = {
 900,800,700,600,500,400,300,200,100,
 90,80,70,60,50,40,30,20,10,
 9,8,7,6,5,4,3,2,1
 };
 int i;
 for(i = 0;i < s.size();i++)
 {
 if(s[i] != 'M')
 break;
 else
 num += 1000;
 }
 s = s.substr(i,s.size());
 for(int i = 0;i < 27;i++)
 {
 s = stringtoint(s,i,sub,q);
 }
 return num;
 }
 string stringtoint(string s,int i,string sub[],int q[])
 {
 if(finds(s,sub[i]))
 {
 num += q[i];
 s = s.substr(sub[i].length(),s.size()-1);
 }
 return s;
 }
 bool finds(string s,string sub)
 {
 if(s.size() < sub.size())
 return false;
 for(int i = 0;i < sub.size();i++)
 {
 if(s[i] != sub[i])
 return false;
 }
 return true;
 }
};

[LeetCode 12] Integer to Roman

Sun, 17 May 2015 01:58:49 +0000

This problem asks you to convert a number (1-3999) to Roman numerals. Not exactly easy, not exactly hard.

Reference from Baidu Baike: http://baike.baidu.com/link?url=TR8d0KXBBMWZffIDqBd_IFPSi0RZkB06DpUlsaZs-9_gCLNQaIVd2VmMwyf-3zG8

Code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152


class Solution {
public:
 string intToRoman(int num) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 char schar[10];
 int index = 0;
 int count;
 if(num / 1000 != 0) {
 count = num / 1000;
 num = num % 1000;
 for(int i = 0; i < count; i++) {
 schar[index++] = 'M';
 }
 }
 if(num / 100 != 0) {
 count = num / 100;
 num = num % 100;
 switch(count) {
 case 1:
 schar[index++] = 'C';
 break;
 case 2:
 schar[index++] = 'C';
 schar[index++] = 'C';
 break;
 case 3:
 schar[index++] = 'C';
 schar[index++] = 'C';
 schar[index++] = 'C';
 break;
 case 4:
 schar[index++] = 'C';
 schar[index++] = 'D';
 break;
 case 5:
 schar[index++] = 'D';
 break;
 case 6:
 schar[index++] = 'D';
 schar[index++] = 'C';
 break;
 case 7:
 schar[index++] = 'D';
 schar[index++] = 'C';
 schar[index++] = 'C';
 break;
 case 8:
 schar[index++] = 'D';
 schar[index++] = 'C';
 schar[index++] = 'C';
 schar[index++] = 'C';
 break;
 case 9:
 schar[index++] = 'C';
 schar[index++] = 'M';
 break;
 }
 }
 if(num / 10 != 0) {
 count = num / 10;
 num = num % 10;
 switch(count) {
 case 1:
 schar[index++] = 'X';
 break;
 case 2:
 schar[index++] = 'X';
 schar[index++] = 'X';
 break;
 case 3:
 schar[index++] = 'X';
 schar[index++] = 'X';
 schar[index++] = 'X';
 break;
 case 4:
 schar[index++] = 'X';
 schar[index++] = 'L';
 break;
 case 5:
 schar[index++] = 'L';
 break;
 case 6:
 schar[index++] = 'L';
 schar[index++] = 'X';
 break;
 case 7:
 schar[index++] = 'L';
 schar[index++] = 'X';
 schar[index++] = 'X';
 break;
 case 8:
 schar[index++] = 'L';
 schar[index++] = 'X';
 schar[index++] = 'X';
 schar[index++] = 'X';
 break;
 case 9:
 schar[index++] = 'X';
 schar[index++] = 'C';
 break;
 }
 }
 if(num != 0) {
 count = num;
 switch(count) {
 case 1:
 schar[index++] = 'I';
 break;
 case 2:
 schar[index++] = 'I';
 schar[index++] = 'I';
 break;
 case 3:
 schar[index++] = 'I';
 schar[index++] = 'I';
 schar[index++] = 'I';
 break;
 case 4:
 schar[index++] = 'I';
 schar[index++] = 'V';
 break;
 case 5:
 schar[index++] = 'V';
 break;
 case 6:
 schar[index++] = 'V';
 schar[index++] = 'I';
 break;
 case 7:
 schar[index++] = 'V';
 schar[index++] = 'I';
 schar[index++] = 'I';
 break;
 case 8:
 schar[index++] = 'V';
 schar[index++] = 'I';
 schar[index++] = 'I';
 schar[index++] = 'I';
 break;
 case 9:
 schar[index++] = 'I';
 schar[index++] = 'X';
 break;
 default:
 break;
 }
 }
 schar[index] = '\0';
 string s = schar;
 return s;
 }
};

[LeetCode 11] Container With Most Water

Sun, 17 May 2015 01:51:40 +0000

OK, I couldn’t figure this one out on my own. After struggling on and off, I eventually gave in and looked at other people’s approaches.

Let me share my thought process.

The first idea was brute force: pick every pair of lines, calculate the volume, and find the maximum.

The logic is correct, but it timed out. I checked the test cases – the data set is quite large.

So what next? We clearly need an approach with complexity lower than $O(n^2)$ to pass.

I thought for a long time. Sorting? Filling water from bottom up? Two pointers, one on each side, moving inward? Or fix the left side and assume the other line is always to the right?

It was all over the place.

Finally I looked at someone else’s solution, and it’s really so easy – I can’t believe I didn’t think of it. Sigh.

The approach is simple: greedy.

Two pointers, one on each end. Record the volume. Move the pointer at the shorter line inward. People online call this the “two-pointer” technique.

During implementation, when the two lines are equal in height, you could move either the left or the right pointer. So the best approach is to use recursion to handle both cases.

Here’s the code. Solving problems can be quite painful, especially for someone slow like me. Keep going!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


class Solution {
public:
 int sum;
 int maxArea(vector<int> &height) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 sum = 0;
 int left = 0;
 int right = height.size() - 1;
 func(left, right, height);
 return sum;
 }
 void func(int left, int right, vector<int> &height)
 {
 if (left < right)
 {
 int min = height[left];
 if (min > height[right])
 min = height[right];
 int tmp = min * (right-left);
 if (tmp > sum)
 sum = tmp;
 if (height[left] > height[right])
 {
 func(left, right-1, height);
 }
 else if (height[left] < height[right])
 {
 func(left+1, right, height);
 }
 else
 {
 func(left+1, right, height);
 func(left, right-1, height);
 }
 }
 }
};

[leetcode_9]Palindrome Number

Sun, 17 May 2015 01:48:59 +0000

This problem is simple: determine whether an int is a palindrome.

Note that negative numbers are not palindromes. Just convert the int to a character array and check directly.

Accepted on the first try.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class Solution {
public:
 bool isPalindrome(int x) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 if(x < 0)
 return false;
 char s[100];
 int index = 0;
 while(x > 0)
 {
 s[index++] = x%10;
 x /= 10;
 }
 int i = 0;
 int j = index-1;
 while(i <= j)
 {
 if(s[i] != s[j])
 return false;
 i++;
 j--;
 }
 return true;
 }
};

[leetcode_8] String to Integer (atoi)

Sun, 17 May 2015 01:46:23 +0000

This problem really taught me the importance of reading the problem statement carefully. I kept getting WA after WA…

The problem is simple: read a string, convert it to an int, and if it overflows, output the boundary value.

However, you need to handle the + and - signs. Also worth noting: first skip all leading spaces, then start parsing from the first non-space character, and continue until you encounter an unrecognizable character.

A special case: for a string like ’ a123123123’, you need to return 0.

The algorithm and data structure are not difficult. Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


class Solution {
public:
 int atoi(const char *str) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int i;
 for (i = 0; i < strlen(str); i++) {
 if (str[i] != ' ') break;
 }
 if (!((str[i] >= '0' && str[i] <= '9') || (str[i] == '+') || (str[i] == '-')))
 return 0;
 int start = -1;
 int end = -1;
 for (; i < strlen(str); i++) {
 if ((str[i] >= '0' && str[i] <= '9') || (str[i] == '+') || (str[i] == '-')) {
 start = i;
 break;
 }
 }
 if (start == -1)
 return 0;
 for (i = start + 1; i < strlen(str); i++) {
 if (str[i] < '0' || str[i] > '9') {
 end = i - 1;
 break;
 }
 }
 if (i == strlen(str)) {
 end = i - 1;
 }
 int p = 1;
 if (str[start] == '-' || str[start] == '+') {
 if (str[start] == '-')
 p = -1;
 start++;
 }
 double ans = 0;
 int index = 0;
 for (i = end; i >= start; i--) {
 ans += (str[i] - '0') * pow(10.0, index++);
 }
 ans = ans * p;
 if (ans > 2147483647.0)
 return 2147483647;
 if (ans < -2147483648.0)
 return -2147483648;
 return (int)ans;
 }
};

[leetcode_7]Reverse Integer

Sun, 17 May 2015 01:44:49 +0000

I just complained about unclear problem statements, and then this problem gives a whole bunch of clarifications and notes:

Have you thought about this?
Here are some good questions to ask before coding. Bonus points for you if you have already thought through this!

If the integer’s last digit is 0, what should the output be? ie, cases such as 10, 100.

Did you notice that the reversed integer might overflow? Assume the input is a 32-bit integer, then the reverse of 1000000003 overflows. How should you handle such cases?

Throw an exception? Good, but what if throwing an exception is not an option? You would then have to re-design the function (ie, add an extra parameter).

Other than the overflow issue which I didn’t consider, the rest of the points are worth noting.

Accepted on the first try.

Store the digits in an array and add them back in reverse order, so the trailing zeros issue is naturally resolved.

Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


class Solution {
public:
 int reverse(int x) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int num[100];
 int top = 0;
 while(true)
 {
 num[top++] = x%10;
 x /= 10;
 if(x == 0)
 break;
 }
 int ans = 0;
 for(int i = 0;i < top;i++)
 {
 ans += num[i]*(int)pow(10.0,top - i - 1);
 }
 return ans;
 }
};

[leetcode_6]ZigZag Conversion

Sun, 17 May 2015 01:39:59 +0000

This problem was really frustrating!!! The problem statement is deceptively simple!

The string “PAYPALISHIRING” is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)

P A H N
A P L S I I G
Y I R
And then read line by line: “PAHNAPLSIIGYIR”

Write the code that will take a string and make this conversion given a number of rows:

string convert(string text, int nRows);
convert(“PAYPALISHIRING”, 3) should return “PAHNAPLSIIGYIR”.

The problem didn’t explain itself clearly. At first I thought the format was:
X X X X
X X X X X X
…
where the first row has one letter with three spaces in between, and the second row has one letter with one space in between.

Following this logic, I assumed odd rows had X letters and even rows had 2X-1 letters. I wrote the code based on this idea and submitted it confidently:
142 / 1158 test cases passed.
Passed 142 test cases… then it said ABCD 2 was WA?

I was completely confused. Finally, with no other options, I looked up how others interpreted the problem.
Turns out it means:
1 7
2 6 8
3 5 9
4
It should form a zigzag pattern… then output row by row… sigh.

So I started working on it, using a 2D array to store the values, changing direction, and filling empty spots with spaces… Got all kinds of RE on small test cases??? That didn’t make sense. Then I realized it might be RE on large data but just happened to be running on small data first.

Eventually I tried expanding the 2D array to 10000x10000 and it blew up with memory issues.

What to do? I almost gave up on this problem.

It all came down to my own inexperience. Later I thought of two approaches: either use a mathematical method to calculate the output order, or compress the space. I chose the latter – instead of storing a 2D map array, I stored each letter’s x, y coordinates and value, which greatly reduced the space usage.

Accepted on the first try after that!

Notes:

Need to handle the special case of a single row.
I was lazy and used the standard library’s sort.

Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


#include <algorithm>

using namespace std;

struct Node {
 int x;
 int y;
 char val;
}p[10000];

int cmp(Node a,Node b) {
 if(a.x == b.x) {
 return a.y < b.y;
 } else {
 return a.x < b.x;
 }
}

class Solution {
public:
 string convert(string s, int nRows) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int x = 0;
 int y = 0;
 int direction = 0;
 if(nRows == 1) return s;
 for(int i = 0; i < s.length(); i++) {
 p[i].x = x;
 p[i].y = y;
 p[i].val = s[i];
 if(direction == 0) {
 x++;
 if(x >= nRows) {
 x--;
 direction = 1;
 x--;
 y++;
 }
 } else {
 x--;
 y++;
 if(x < 0) {
 x++;
 y--;
 direction = 0;
 x++;
 }
 }
 }
 sort(p, p + s.length(), cmp);
 for(int i = 0; i < s.length(); i++) {
 s[i] = p[i].val;
 }
 return s;
 }
};

[LeetCode 5] Longest Palindromic Substring

Fri, 15 May 2015 02:19:37 +0000

Wow, this one is a beast – also took me an entire afternoon.

The problem is: given a string, find the longest palindromic substring.

The first approach I thought of was brute force – just get it working first.

How to brute force? My initial idea was: Use a fixed function check to determine if a string is a palindrome. If s is a palindrome, we’re done. Otherwise, check s(0, s.length()-2) and s(1, s.length()-1).

I wrote this code and tested it – works fine for short strings. But thinking about it, the complexity is way too high, especially for slightly longer strings.

Sure enough, it timed out.

TLE means the approach is wrong – time to rethink.

Let’s try the reverse approach: First check if s[i] is a palindrome, then expand by 1 on each side. Then check if s[i], s[i+1] is a palindrome, then expand by 1 on each side. The two cases are needed because of the odd/even length distinction.

OK, this should optimize the time for most cases.

But still TLE. However, we’re getting closer to the solution.

Here’s the next insight: we don’t actually need to expand by 1 each time. If we’ve already found a palindrome of length sum, when we enumerate the next center point, we can start expanding from sum/2. And that got AC!

The few WAs were just boundary issues.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


class Solution {
public:
 int sum;
 int step;
 string ans;
 string longestPalindrome(string s) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 sum = 0;
 for(int i = 0;i < s.length();i++)
 {
 step = sum/2;
 if(i-step < 0 || i+step >= s.length())
 continue;
 func(s,i-step,i+step);
 }
 for(int i = 0;i < s.length();i++)
 {
 step = sum/2;
 if(i-step < 0 || i+step+1 >= s.length())
 continue;
 func(s,i-step,i+1+step);
 }
 return ans;
 }
 void func(string s,int x,int y)
 {
 if(x < 0 || y > s.length()-1)return;
 if(checkp(s.substr(x,y-x+1)))
 {
 if(sum < y-x+1)
 {
 sum = y-x+1;
 ans = s.substr(x,y-x+1);
 }
 func(s,x-1,y+1);
 }
 }
 bool checkp(string s)
 {
 int i = 0;
 int j = s.length() - 1;
 while(i <= j)
 {
 if(s[i] != s[j])
 return false;
 i++;
 j--;
 }
 return true;
 }
};

[LeetCode 2] Add Two Numbers

Fri, 15 May 2015 02:16:42 +0000

Man, this problem looks simple from the name, but it nearly killed me. The idea is clear, but the implementation was painful. My fundamentals really need work – it took forever.

The problem says: given two non-negative linked lists, add the corresponding values of the two lists. If the sum is 10 or greater, there’s a carry – and the carry is what really tripped me up. Got WA once because of it.

One thing to note is that the numbers need to be reversed. I directly reversed both input linked lists, which led to AC. If you miss this, you’ll likely get wrong answers. But reversing a linked list really frustrated me – I need to practice my fundamentals more.

There’s also the issue of deep copy vs. shallow copy with pointers.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


class Solution {
public:
 double findMedianSortedArrays(int A[], int m, int B[], int n) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int sum = m + n;
 if (sum % 2 == 0) {
 return (findk(A, m, B, n, sum/2) + findk(A, m, B, n, sum/2 + 1)) / 2;
 } else {
 return findk(A, m, B, n, sum/2 + 1);
 }
 }

 double findk(int A[], int m, int B[], int n, int k) {
 if (m > n) {
 return findk(B, n, A, m, k);
 }
 if (m <= 0)
 return B[k-1];
 if (n <= 0)
 return A[k-1];
 if (k == 1) {
 if (A[0] < B[0])
 return A[0];
 else
 return B[0];
 }

 int a = k/2;
 if (m < k/2)
 a = m;
 int b = k - a;
 if (A[a-1] == B[b-1])
 return A[a-1];
 else if (A[a-1] < B[b-1]) {
 return findk(A + a, m - a, B, n, k - a);
 } else {
 return findk(A, m, B + b, n - b, k - b);
 }
 }
};