Beauty of Programming on Coinidea's Blog

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

[C++] Drawing a Diamond Shape

Mon, 27 Jul 2015 02:04:30 +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


#include <iostream>
using namespace std;

int main()
{
 int n; // The longest row of the diamond has n characters, and n must be odd because n = 2*k + 1
 cin >> n;

 int cn = 1;
 bool isUp = true;
 for (int i = 1; i <= n; i++) {
 for (int j = 1; j <= (n - cn) / 2; j++) {
 cout << " ";
 }
 for (int j = 1; j <= cn; j++) {
 cout << "*";
 }
 for (int j = 1; j <= (n - cn) / 2; j++) {
 cout << " ";
 }
 cout << endl;

 if (cn >= n) {
 isUp = false;
 }
 if (isUp) {
 cn += 2;
 } else {
 cn -= 2;
 }
 }
 return 0;
}

[C++] Open a TXT File by Input Filename and Count Its Bytes

Sun, 26 Jul 2015 02:04:30 +0000

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


#include <iostream>
using namespace std;

int main() {
 char filename[255];
 cin >> filename;

 FILE * pFile = fopen(filename, "r");
 fseek(pFile, 0L, SEEK_END);
 long count = ftell(pFile);
 cout << "Byte count=" << count << endl;
 fclose(pFile);
 return 0;
}

[Beauty of Programming 2.9] Fibonacci Sequence

Sat, 23 May 2015 05:20:58 +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


int Fibonacci(int n)
{
 if (1 == n)
 {
 return 1;
 }
 if (2 == n)
 {
 return 2;
 }
 return Fibonacci(n-1) + Fibonacci(n-2);
}

int FibonacciIteration (int n)
{
 int a = 1;
 int b = 2;
 if (n == 1)
 return a;
 if (n == 2)
 return b;
 for (int i = 3; i <= n; i++)
 {
 int now = a + b;
 a = b;
 b = now;
 }
 return b;
}

The book mentions a method: fi = fi-1 + fi-2 => converted into matrix form

[Beauty of Programming 2.9] Fibonacci Sequence
Time complexity: O(log2n).

[Beauty of Programming 2.8] Finding Integers That Meet the Criteria

Sat, 23 May 2015 05:19:47 +0000

The problem is simple: given an integer n, find the smallest m such that n*m contains only the digits 0 and 1 in its decimal representation.

Method 1: Brute Force [Need to consider large integers, termination conditions, and time complexity]

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


bool CheckNumber(int number)
{
 while(number)
 {
 if (number%10 != 0 && number%10 != 1)
 return false;
 number /= 10;
 }
 return true;
}

int CalcMBruteForce(int n)
{
 int m = 1;
 while (!CheckNumber(m * n))
 {
 m++;
 }
 return m;
}

Method 2: BFS [Need to consider large integers, termination conditions, and duplicate elimination]

 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


int CalcM(int number)
{
 int i = 1;
 vector<int> vList;
 vList.clear();
 vList.push_back(0);
 vList.push_back(1);
 vector<int> vListC;
 int k = 1;
 // TODO:
 // BigInt
 // Delete duplicate
 while (true)
 {
 vListC.clear();
 for (vector<int>::size_type i = 0; i < vList.size(); i++)
 {
 if (vList[i] && vList[i] % number == 0)
 {
 return vList[i];
 }
 vListC.push_back(vList[i] + 0);
 vListC.push_back(vList[i] + (int)pow(10.0, k));
 }
 vList.clear();
 vList = vListC;
 k++;
 }
}

[Beauty of Programming 2.7] The Greatest Common Divisor Problem

Sat, 23 May 2015 05:18:46 +0000

GCD: Greatest Common Divisor – the largest integer that divides both m and n evenly.
Euclid’s algorithm (the Euclidean algorithm) has existed since ancient times:
GCD(x, y) = GCD(x, x%y)
x = k*y + b. If d is the GCD of x and y, then d must also divide b, and d is the GCD of x and b, where b = x%y.
Code:

1
2
3
4
5


// GCD
int GCD(int x, int y)
{
 return y == 0 ? x : GCD(y, x % y);
}

The book “Beauty of Programming” discusses time optimizations:

The modulo operation involves division, which is relatively expensive.
How to optimize for big integers.

[Beauty of Programming 2.6] Exact Representation of Floating Point Numbers

Sat, 23 May 2015 05:17:49 +0000

The code below simplifies the problem to converting a repeating decimal into a fraction. For terminating decimals, you can convert them directly to fractions, but this involves another important concept: finding the greatest common divisor (GCD). The classic method is the Euclidean algorithm.
Code:

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


// GCD
int GCD(int x, int y)
{
 return y == 0 ? x : GCD(y, x % y);
}

// Simplified conditions
// x: repeating decimal
// n: integer representation of the repeating block
// m: length of the repeating block
// 10^m * x = n + x
// x = n / (10^m - 1)
void FloatNumber(string number)
{
 int start = number.find_first_of('(') + 1;
 int end = number.find_first_of(')');
 string repetend = number.substr(start, end - start);
 int n = atoi(repetend.c_str());
 int m = end - start;
 int d = GCD(n, ((int)pow(10.0, m) - 1));
 cout << n / d << '/' << ((int)pow(10.0, m) - 1) / d << endl;
}

[Beauty of Programming 2.5] Finding the K Largest Numbers

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

This problem is equivalent to finding the k-th largest/smallest number.
Method 1: Sort and output directly. [The book “Beauty of Programming” notes that different sorting methods have different time complexities. Indeed, since we don’t need all n numbers sorted – we only need the k largest.]
Using quicksort:

1
2
3
4
5
6


vector<int> FindMostKSort(vector<int>& vNumbers, int k)
{
 sort(vNumbers.begin(),vNumbers.end());
 vector<int> vKNumbers(vNumbers.rbegin(), vNumbers.rbegin() + k);
 return vKNumbers;
}

Method 2: We don’t actually need all numbers sorted. We can simulate the partition step of quicksort to find the element at the k-th position after sorting.

 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


void swap(int &a, int &b)
{
 int tmp = a;
 a = b;
 b = tmp;
}
void FindMostKPartition(vector<int>& vNumber, int k, int left, int right)
{
 int index = left;
 int tmp = vNumber[index];
 int i = left;
 int j = right;
 while (i < j)
 {
 while(i < j && vNumber[j] >= vNumber[index]) j--;
 swap(vNumber[j], vNumber[index]);
 index = j;
 while(i < j && vNumber[i] <= vNumber[index]) i++;
 swap(vNumber[i], vNumber[index]);
 index = i;
 }
 if (index - left + 1 == k)
 {
 cout << vNumber[index] << endl;
 }
 else if (index - left + 1 < k)
 {
 FindMostKPartition(vNumber, k - (index - left + 1), index + 1, right);
 }
 else
 {
 FindMostKPartition(vNumber, k, left, index - 1);
 }
}

Method 3: Heap sort [maintain a min-heap of size k. The STL code is remarkably short, though you could implement the heap with arrays yourself.]

PS: All sorting uses STL implementations. Implementing sorting from scratch will be attempted in the near future.

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


void FindMostKHeap(vector<int>& vNumbers, int k)
{
 vector<int> vKNumbers(vNumbers.begin(), vNumbers.begin() + k);
 make_heap(vKNumbers.begin(), vKNumbers.end(), greater<int>());
 for (vector<int>::size_type i = k; i < vNumbers.size(); i++)
 {
 if (vNumbers[i] > vKNumbers[0])
 {
 vKNumbers[0] = vNumbers[i];
 make_heap(vKNumbers.begin(), vKNumbers.end(), greater<int>());
 }
 }
 cout << vKNumbers[0] << endl;
}

[Beauty of Programming 2.4] Count of Digit 1

Sat, 23 May 2015 05:15:31 +0000

The problem is straightforward: given a positive integer n, count the total number of times the digit 1 appears in all numbers from 1 to n.
For example, for the number 12312, global count += 2 because 1 appears twice. Given input n, we need to compute this for all numbers from 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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


int VerifyCountOneNumberAns(int n)
{
 int ans = 0;
 for (int i = 1; i <= n; i++)
 {
 int tmp = i;
 while(tmp)
 {
 if (1 == tmp%10) ans++;
 tmp /= 10;
 }
 }
 return ans;
}
int CountOneNumber(int n)
{
 if (n == 0)
 return 0;
 if (n < 10)
 return 1;
 vector<int> vNumber;
 vNumber.clear();
 int tmp = n;
 while(tmp)
 {
 vNumber.push_back(tmp%10);
 tmp /= 10;
 }
 int count = 0;
 int vSize = vNumber.size();
 count = (vSize - 1) * vNumber[vSize - 1] * (int)pow(10.0, (int)(vSize - 2));
 if (vNumber[vSize - 1] > 1)
 {
 count += (int)pow(10.0, (int)(vSize - 1));
 }
 else
 {
 count += n - vNumber[vSize - 1] * (int)pow(10.0, vSize - 1) + 1;
 }
 count += CountOneNumber(n - vNumber[vSize - 1] * (int)pow(10.0, vSize - 1));
 return count;
}
int main()
{
 vector<int> ids;
 for (int i = 1; i <= 10000; i++)
 {
 int count = CountOneNumber(i);
 int ans = VerifyCountOneNumberAns(i);
 if (ans != count)
 cout << i << '\t' << ans << '\t' << count << endl;
 }
 return 0;
}

The code includes a verification function whose correctness is beyond doubt. The problem also provides a recursive approach, which has acceptable time complexity – it should be proportional to the number of digits.
PS: I’m clearly not great at math; this was quite a struggle. But my logic still works well…

[Beauty of Programming 2.3] Finding the Forum "Spammer"

Sat, 23 May 2015 05:14:27 +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


int FindMostIds(vector<int> &ids)
{
 map<int,int> hashIds;
 map<int,int>::iterator it;
 hashIds.clear();
 for (int i = 0; i < ids.size(); i++)
 {
 it = hashIds.find(ids[i]);
 if (hashIds.end() == it)
 {
 hashIds.insert(map<int,int>::value_type(ids[i],1));
 }
 else
 {
 it->second++;
 }
 }
 int id = 0, count = -1;
 for (it = hashIds.begin(); it != hashIds.end(); it++)
 {
 if (it->second > count)
 {
 id = it->first;
 count = it->second;
 }
 }
 return id;
}

This problem can be further optimized in two ways: 1) Optimize the solution itself; 2) If there are 3 “spammers,” each posting more than a quarter of all posts, how do we solve it? It’s late today, heading back to the dorm. I’ll solve it tomorrow – though I already have an idea.
Problem 1:
The book “Beauty of Programming” mentions that space complexity can be optimized to O(1).
After reading the book, here’s the hint:
Use one variable id to store the current ID and count to store the count of that ID, then compare for equality and maintain dynamically. The final id must be the spammer.

 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


int FindMostIds(vector<int> &ids)
{
 if (ids.size() <= 0)
 return -1;
 int id = ids[0];
 int count = 1;
 for (vector<int>::size_type i = 1; i < ids.size(); i++)
 {
 if (0 == count)
 {
 id = ids[i];
 count = 1;
 continue;
 }
 if (id == ids[i])
 {
 count++;
 }
 else
 {
 count--;
 }
 }
 return id;
}

Problem 2: This can be generalized from the approach in Problem 1, Solution 2: [my own idea, not rigorously tested, but the logic should be correct]

 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


void FindMostIds(vector<int> &ids)
{
 if (ids.size() <= 0)
 return ;
 int id[3] = {-1, -1, -1};
 int count[3] = {0, 0, 0};
 for (vector<int>::size_type i = 1; i < ids.size(); i++)
 {
 bool flag = false;
 for (int j = 0; j < 3; j++)
 {
 if (id[j] == ids[i])
 {
 count[j]++;
 flag = true;
 break;
 }
 }
 if (flag) continue;

 flag = false;
 for (int j = 0; j < 3; j++)
 {
 if (count[j] == 0)
 {
 id[j] = ids[i];
 count[j]++;
 flag = true;
 break;
 }
 }
 if (flag) continue;
 for (int j = 0; j < 3; j++)
 {
 count[j]--;
 }
 }
 for (int i = 0; i < 3; i++)
 {
 cout << id[i] << '\t';
 }
 cout << endl;
}

[Beauty of Programming 2.2] Don't Be Scared by Factorials

Sat, 23 May 2015 05:11:00 +0000

The problem asks to count the number of trailing zeros in n!. This is essentially counting how many multiples of 5 are multiplied in during the computation of n!.

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


int CountZero(int n)
{
 int cnt = 0;
 for (int i = 1; i <= n; i++)
 {
 int tmp = i;
 while (0 == i % 5)
 {
 cnt++;
 tmp /= 5;
 }
 }
 return cnt;
}

The problem asks for the position of the lowest bit 1 in the binary representation of N!. We can observe that multiplying by odd numbers doesn’t affect the position of 1. Each time we multiply by 2, the entire value shifts left by 1 bit. Therefore, the result depends on the number of times 2 appears as a factor.

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


int CountBinaryOne(int n)
{
 int cnt = 0;
 for (int i = 1; i <= n; i++)
 {
 int tmp = i;
 while (0 == tmp % 2)
 {
 cnt++;
 tmp /= 2;
 }
 }
 return cnt;
}

[Beauty of Programming 2.1] Count the Number of 1s in Binary

Sat, 23 May 2015 05:09:14 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


int CountOne(int val)
{
 int cnt = 0;
 while (val)
 {
 val &= val - 1;
 cnt++;
 }
 return cnt;
}

[Beauty of Programming 1] Drawing Curves with CPU Usage

Sat, 23 May 2015 05:06:15 +0000

Getting the CPU to run at full load is actually quite simple – just write an infinite loop and the OS will allocate more and more time slices to it. However, modern processors are multi-core. For example, my computer has 4 cores, so you’ll find the CPU stays around 25-27% and never reaches 100%.

To reach 100%, you just need to use multithreading.

The most provocative statement I saw today was:

“I dare you to make the CPU draw a circle.” I was completely stunned at that moment…

Now let’s look at the 50% case. The book “Beauty of Programming” says that alternating between “sleep for one time slice, work for one time slice” should achieve 50%. But I found the results were not great. Even using GetTickCount, the effect was poor because the computer has other programs running as 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


void Work(DWORD time)
{
 DWORD now = GetTickCount();
 for(;GetTickCount() <<- endstream>> now + time;)
 {
 }
}
DWORD WINAPI DrawThread(LPVOID lParam)
{
 double deta = 0.1f;
 while (true)
 {
 double time = 500 + 500 * sin(deta);
 Work(time);
 Sleep(1000-time);
 deta += 0.1f;
 }
 return 0;
}
int main()
{
 HANDLE hThread[4];
 DWORD idThread[4];
 hThread[0] = CreateThread(0,0,DrawThread,NULL,0,& idThread[0]);
 hThread[1] = CreateThread(0,0,DrawThread,NULL,0,& idThread[1]);
 hThread[2] = CreateThread(0,0,DrawThread,NULL,0,& idThread[2]);
 hThread[3] = CreateThread(0,0,DrawThread,NULL,0,& idThread[3]);
 SetThreadAffinityMask(hThread[0], 0x00000001);
 SetThreadAffinityMask(hThread[1], 0x00000010);
 SetThreadAffinityMask(hThread[2], 0x00000100);
 SetThreadAffinityMask(hThread[3], 0x00001000);

 WaitForSingleObject(hThread[0], INFINITE);
 WaitForSingleObject(hThread[1], INFINITE);
 WaitForSingleObject(hThread[2], INFINITE);
 WaitForSingleObject(hThread[3], INFINITE);

 return 0;
}

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