Art of Programming on Coinidea's Blog

[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 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 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 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 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 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);
 }
 }
};

[LeetCode 3] Longest Substring Without Repeating Characters

Fri, 15 May 2015 02:12:51 +0000

I initially thought this problem would require fancy algorithms, but I ended up using what I consider the simplest approach.

Let me explain my thought process.

At first, I was a bit confused and naively thought: start enumerating from the first element of the array, and if a later element is different from the “first” element, stop and move to the next loop, then output the maximum sum.

Obviously that’s wrong! It should be: a later element must be different from ALL previous elements.

WA #1.

OK, this brute force approach did pass. Now, the problem says “characters” – if we’re talking about English letters including both upper and lower case, that’s 26*2. All ASCII characters would be 256. I allocated an array of 300, which should be enough.

The logic was correct but I still got WA #2. Why? Because the termination condition wasn’t explicit enough. If there are no repeating characters all the way to the end, my program would break.

WA #3 was because the program would crash when there’s only one element. Boundary conditions matter a lot for simple problems!

Finally it was pending for a while – I kept thinking it would time out, but it didn’t.

Yay!

Actually, the time complexity can be further optimized. If we start searching from position x, and elements at positions i and j are the same, the next search can start from i+1 instead of x+1. This would keep the time at linear scanning, though we’d need to store the indices of i and j.

 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:
 int lengthOfLongestSubstring(string s) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int sum = 0;
 if(s.length() == 1)
 return 1;
 for(int i = 0; i < s.length(); i++)
 {
 int flag[300];
 for(int k = 0; k < 300; k++)
 {
 flag[k] = 0;
 }
 flag[s[i]] = 1;
 for(int j = i+1; j < s.length(); j++)
 {
 if(flag[s[j]] == 1)
 {
 if(j - i > sum)
 sum = j - i;
 break;
 }
 if(j == s.length() - 1)
 {
 if(j - i + 1 > sum)
 sum = j - i + 1;
 break;
 }
 flag[s[j]] = 1;
 }
 }
 return sum;
 }
};

[LeetCode 4] Median of Two Sorted Arrays

Fri, 15 May 2015 02:08:02 +0000

Honestly, I couldn’t solve this one on my first attempt. I only figured it out after reading someone else’s approach, and I still made boundary errors multiple times. Embarrassing.

Let me explain the approach.

My initial idea was: merge sort the two arrays, then output array[median]. But clearly this has a time complexity higher than $O(\log(m+n))$ – it’s about $O(m+n)$.

The time complexity constraint is what makes this problem frustrating.

OK, looking at the conditions again: two already sorted arrays, and the required time complexity is logarithmic. What does that remind you of? Binary search?

But how do you apply binary search to this problem? There’s a bit of math involved.

For the detailed derivation, see: http://blog.chinaunix.net/uid-28490468-id-3576490.html

I had seen another blog post about this before, but I can’t find it anymore. Oh well.

 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


ListNode *l;

class Solution {
public:
 ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 l1 = Reverse(l1);
 l2 = Reverse(l2);
 ListNode *ans = NULL;
 ListNode *ansbackup = NULL;
 int sum = 0;
 int now = 0;
 int next = 0;
 while(true)
 {
 if(l1 == NULL || l2 == NULL)
 break;
 sum = l1->val + l2->val+next;
 now = sum % 10;
 next = sum / 10;
 ListNode *tmp = new ListNode(now);
 if(ans == NULL)
 {
 ans = tmp;
 ansbackup = ans;
 }
 else
 {
 ans->next = tmp;
 ans = ans->next;
 }
 l1 = l1->next;
 l2 = l2->next;
 }
 if(l1 != NULL)
 {
 while(true)
 {
 if(l1 == NULL) break;
 sum = l1->val + next;
 now = sum % 10;
 next = sum / 10;
 ListNode *tmp = new ListNode(now);
 ans->next = tmp;
 ans = ans->next;
 l1 = l1->next;
 }
 }
 if(l2 != NULL)
 {
 while(true)
 {
 if(l2 == NULL) break;
 sum = l2->val + next;
 now = sum % 10;
 next = sum / 10;
 ListNode *tmp = new ListNode(now);
 ans->next = tmp;
 ans = ans->next;
 l2 = l2->next;
 }
 }
 if(next != 0)
 {
 ListNode *tmp = new ListNode(next);
 ans->next = tmp;
 ans = ans->next;
 }
 return ansbackup;
 }
 ListNode *Reverse(ListNode *l)
 {
 ListNode *before;
 ListNode *now;
 ListNode *next;
 if(l->next == NULL)
 return l;
 before = l;
 now = l->next;
 while(now == NULL)
 {
 next = now->next;
 now->next = before;
 before = now;
 now = next;
 }
 return before;
 }
};

[LeetCode 1] Two Sum

Fri, 15 May 2015 01:28:40 +0000

The problem asks: given an array numbers and a target, find two indices index1 and index2 such that the two numbers at those indices sum to target.

Note that the indices in numbers start from 1, but vector as a built-in array actually has 0-based indexing.

Since I just started doing LeetCode problems, I’m still getting used to it – it’s quite different from the online judges I used before.

In particular, I had never worked with vector before, and now I truly realize how much of a C++ beginner I am.

Here’s a blog post for learning about vectors: http://www.cnblogs.com/charley_yang/archive/2010/12/11/1903040.html

Just treat vector as an array.

Here’s my solution and approach:

 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> twoSum(vector<int> &numbers, int target) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 vector<int> answer(2);
 for(int i = 0; i < numbers.size(); i++) {
 int flag = false;
 for(int j = 0; j < numbers.size(); j++) {
 if(i != j && numbers[i] + numbers[j] == target) {
 answer[0] = i + 1;
 answer[1] = j + 1;
 flag = true;
 break;
 }
 }
 if(flag == true) break;
 }
 return answer;
 }
};

The approach is straightforward – brute force.

Got AC on the first try, though the runtime was 32ms. This method is $O(n^2)$ – can we do better?

I thought about it: if we sort the vector first in $O(n \log n)$, then for each number, compute the difference with target and binary search for it, the overall complexity would be $O(n \log n)$. That should be faster – though we’d need to handle index preservation.