String on Jiang Yi(姜祎)'s Homepage

592. Fraction Addition and Subtraction

Fri, 23 Aug 2024 20:16:54 +0800

Given a string expression representing an expression of fraction addition and subtraction, return the calculation result in string format.

Intuition

Simulate the calculation of fraction addition and subtraction process.

Approach

First, to simplify addition and subtraction, we move the - to numerator part, for example, 3/4-2/3 becomes 3/4+(-2)/3, this step makes all operations become addition.

Second, we use a initial value 0/1 to record result to prevent from parsing the first fraction. Thus 3/4-2/3 is actually equivalent to 0/1+3/4-2/3.

Now, in each loop, we record the sign, the numerator, the denominator. Then we compute the result with the previous result with the formula

$$ \frac{a}{b} + \frac{c}{d} = \frac{ad-bc}{bd} $$

after computation, we use gcd() function to make the resulted fraction irreducible.

Complexity

Time complexity: Iterate the string once.
$$O(n)$$
Space complexity: No extra spaces needed.
$$O(1)$$

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


class Solution {
public:
 string fractionAddition(string expression) {
 int n = expression.size();
 int numerator1 = 0, dominator1 = 1;
 int numerator2 = 0, dominator2 = 1;
 int sign = 1;
 for (int i = 0; i < n;) {
 if (expression[i] == '-') {
 sign = -1;
 ++i;
 continue;
 }
 if (expression[i] == '+') {
 sign = 1;
 ++i;
 continue;
 }
 numerator2 = 0;
 while (i < n && '0' <= expression[i] && expression[i] <= '9') {
 numerator2 = numerator2 * 10 + (expression[i] - '0');
 ++i;
 }
 numerator2 *= sign; // move sign to numerator
 sign = 1; // reset sign
 ++i; // division operator
 dominator2 = 0;
 while (i < n && '0' <= expression[i] && expression[i] <= '9') {
 dominator2 = dominator2 * 10 + (expression[i] - '0');
 ++i;
 }
 numerator1 = (numerator1 * dominator2 + numerator2 * dominator1);
 dominator1 = dominator1 * dominator2;
 if (numerator1 && dominator1) {
 int gcd_num = gcd(numerator1, dominator1);
 numerator1 = numerator1 / gcd_num;
 dominator1 = dominator1 / gcd_num;
 }
 }
 // corner case
 if (numerator1 == 0) {
 return "0/1";
 }

 return to_string(numerator1) + "/" + to_string(dominator1);
 }
};

Reference

leetcode 592

165. Compare Version Numbers

Fri, 03 May 2024 15:13:23 +0800

Given two strings containing digits and dot, compare them in the form of a version number.

Intuition

Since the leading zeros are required to be ignored, we use dot character as separator and compute the integer of each part and compare them individually.

Approach

We use two index i and j to iterate over s1 and s2, we move the index i to the next dot character and compute the integer num1 we have found. Same operations for j to obtain the integer num2. Then num1 and num2 are compared.

Complexity

Time complexity: iterate each string once.
$$O(n)$$
Space complexity: no extra space needed.
$$O(1)$$

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 compareVersion(string version1, string version2) {
 int i = 0, j = 0;
 int m = version1.size(), n = version2.size();
 while (i < m || j < n) {
 int num1 = 0, num2 = 0;
 while (i < m && version1[i] != '.') {
 num1 = 10 * num1 + (version1[i++] - '0');
 }
 while (j < n && version2[j] != '.') {
 num2 = 10 * num2 + (version2[j++] - '0');
 }
 if (num1 < num2) return -1;
 if (num1 > num2) return 1;
 ++i, ++j;
 }
 return 0;
 }
};

References

Leetcode

1915. Number of Wonderful Substrings

Thu, 02 May 2024 10:51:29 +0800

Given a string ,count the number of wonderful substrings, where a wonderful string is a string that at most one character appears in an odd number of times.

Intuition

We use the prefix sum and bitwise representation to solve the problem. The idea is that every string can be represented by a state, and we can count the number of wonderful substrings by performing operations among states

Approach

According to the hint and the problem description, we have:

there are $10$ possible variables, which represent a to j
we only care about if the variable appears in odd number of times or in even number of times, which means that each variable has $2$ possible states.

so the number of overall possible states is $2^10=1024$. We define the prefix substring as prefix[i] = s[1...i].

For each substring, we can represent the state of the prefix as an index of the array, that is, state(prefix[i]) is a number between 0 and 1023, with each byte representing if the corresponding character appears in odd number of times (1) or in even number of times (0). A wonderful string is then defined as a string whose state representation is 0 or a power of 2.

now the substring s[i...j] is defined as prefix[j]-prefix[i], in state representations, there are three cases:

if one character appears in odd number of times in both prefix substring, then in the result substring, the character appears in even number of times, which is equivalent to (1, 1) -> 0
if one character appears in even number of times in both prefix substring, then in the result substring, the character appears in even number of times, which is equivalent to (0, 0) -> 0
If one character appears in even number of times in one prefix substring, and appears in odd number of times in the other prefix substring, then in the result substring, the character appears in even number of times, which is equivalent to (1, 0) -> 1

so, according to analysis, the minus operation in string corresponding to the XOR operation in states. That is, the state of s[i...j] is given by state(s[i...j])=state(prefix[j]) XOR state(prefix[i]).

Note that there is also a simplification since if a XOR b = c, then a XOR c = b. Instead of using a for loop to compute all substrings that ended with character j:

1
2
3
4
5


for (int i = 0; i <j; ++i) {
 // substring s[i...j]
 int substr_state = state[j] ^ state[i];
 // check if substr is a wonderful substring
}

with the property of XOR, wo directly check if state(prefix[j]) XOR 2^k exists, that is:

1
2
3
4


for (int i = 0; i < 10; ++i) {
 int state = state[j] ^ (1 << i);
 // check if state exists and add them.
}

Complexity

Time complexity: iterate string once
$$O(n)$$
Space complexity: stores the state representation.
$$O(1)$$

Code

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


class Solution {
public:
 long long wonderfulSubstrings(string word) {
 vector<int> bits(1024);
 bits[0] = 1;
 long long result = 0;
 int prefix = 0;
 for (char c: word) {
 prefix ^= 1 << (c - 'a');
 result += bits[prefix];
 for (int i = 0; i < 10; ++i) {
 result += bits[prefix ^ (1 << i)];
 }
 ++bits[prefix];
 }
 return result;
 }
};

References:

Leetcode

2000. Reverse Prefix of Word

Wed, 01 May 2024 09:01:22 +0800

Given a string ans a specified character, reverse the prefix that is ended with the specified character.

Intuition

Simulate the process.

Approach

find the first occurrence of the specified character, then reverse the prefix.

Complexity

Time complexity: find the first occurrence of the specified character.
$$O(n)$$
Space complexity: no extra spaces are needed.
$$O(1)$$

Code

1
2
3
4
5
6
7
8
9


class Solution {
public:
 string reversePrefix(string word, char ch) {
 auto pos = word.find(ch);
 if (pos == word.npos) return word;
 reverse(word.begin(), word.begin() + pos + 1);
 return word;
 }
};

514. Freedom Trail

Sat, 27 Apr 2024 11:55:28 +0800

Given a string displaying in the ring format, we can move one character at each step either in clockwise or anticlockwise (or hold still), now we need to retrieve a given string with minimum steps.

Intuition

We can construct a graph from the string and use DFS to search all possible paths, and find the path with minimum steps.

Approach

DFS -> TLE

In the beginning, I am going to use DFS to find all possible paths and find the path with minimum steps.

First, we need construct the graph, each character is adajcent to all other characters in ring, so there are n=length(ring) nodes and (n-1)^n edges. each edge has a weight representing the distance between two characters: weight(i,j)=min(abs(i-j), n - abs(i-j)) (here we use index of the character to represent the node).

Then, we can use DFS to search all possible paths, in each point, we have a state (ring_index, key_index), representing the current index on ring and key, there are two cases:

ring[ring_index] == key[key_index], in this case, we change key_index to key_index+1 and keeps ring_index unchanged (hold still).
ring[ring_index] != key[key_index], in this case, we need to rotate the string ring to make ring[ring_index] == key[key_index], this takes step and notice that there may multiple choices, so we need to go over all of them.

Once key_index == len(key), we have found a path and we can now update the result.

The code is given as follows:

 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:
 void dfs(unordered_map<int, vector<vector<int>>> &adjs,
 const string &ring, const string &key,
 int ring_index, int key_index,
 int &min_rotates, int &current_rotates) {
 if (key_index == key.size()) {
 min_rotates = min(min_rotates, current_rotates);
 return;
 }

 // character matches
 if (ring[ring_index] == key[key_index]) {
 dfs(adjs, ring, key, ring_index, key_index + 1, min_rotates, current_rotates);
 return;
 }
 // character doesn't match
 for (const auto &next_node: adjs[ring_index]) {
 int next_ring_index = next_node[0], rotates = next_node[1];
 if (ring[next_ring_index] != key[key_index]) continue;
 current_rotates += rotates;
 dfs(adjs, ring, key, next_ring_index, key_index, min_rotates, current_rotates);
 current_rotates -= rotates;
 }
 }

 int findRotateSteps(string ring, string key) {
 unordered_map<int, vector<vector<int>>> adjs;
 int n = ring.size();
 for (int i = 0; i < ring.size(); ++i) {
 for (int j = 0; j < ring.size(); ++j) {
 if (j == i) continue;
 int diff = abs(i - j);
 int rotates = min(diff, n - diff);
 adjs[i].push_back(vector<int>{j, rotates});
 }
 }

 int ring_index = 0, key_index = 0;
 int min_rotates = INT_MAX, current_rotates = 0;
 dfs(adjs, ring, key, ring_index, key_index, min_rotates, current_rotates);
 int spell = key.size();
 return min_rotates + spell;
 }
};

Dynamic programming

The problem of DFS is that, its time complexity grows exponentially if there have multiple repeat characters, which causes TLE (time limit exceeded) error.

So, to reduce the complexity, we can construct the solution from bottom to up. That is, we remember the path to go from the current state, and now we now go one step back, util we back to the original state.

We use dp[i][j] to represent start from ring[j], the minimum rotate steps we need to recover the string key[i...m], where m=length(key), the target then becomes finding out dp[0][0].

Note that we can easily compute dp[m-1][j], j=1,\dots,n, since there is only one character we need to recover, so we start from ring[j], and rotate util we find a character ring[k] such that ring[k]==key[m-1], the minimum steps is then updated. The update formula is then given by

$$ dp[i][j] = \min_{k=1,\dots,n,\ ring[k]=key[i]}(dp[i][j],\ dp[i + 1][k] + step(j, k)) $$

where $step(j,k)=\min(|j-k|,\ n-|j-k|)$.

Complexity

Time complexity: The dp matrix is of size $m\times n$, and each time, we need to iterate over the ring once.
$$O(mn^2)$$
Space complexity:The dp matrix is of size $m\times n$
$$O(mn)$$

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 findRotateSteps(string ring, string key) {
 int m = key.size(), n = ring.size();
 vector<vector<int>> dp(m + 1, vector<int>(n));
 for (int i = m - 1; i >= 0; --i) {
 // start from ring[j]
 for (int j = 0; j < n; ++j) {
 dp[i][j] = INT_MAX;
 // Find the feasible target ring[k] == key[i]
 for (int k = 0; k < n; ++k) {
 if (ring[k] != key[i])
 continue;
 int rotates = min(abs(k - j), n - abs(k - j));
 dp[i][j] = min(dp[i][j], dp[i + 1][k] + rotates);
 }
 }
 }
 return dp[0][0] + m;
 }
};

Reference

752. Open the Lock

Mon, 22 Apr 2024 19:01:23 +0800

Given a four-digit string, change one digit (plus or minus 1) at a time, find the minimum number of steps to go from the source to target without passing through invalid states.

Intuition

We can image this as a graph path finding problem, where we need to find a path from the source to the target with the minimum number of steps.

Approach

We use BFS to solve this problem. The graph is constructed as follows: each possible state is a node of the graph, such as "1234", "4567", each operation defines an edge between two nodes, for example, we can rotate third digit of "1234" to obtain "1244", since there are two possible directions and four digits, each node has $2^4=16$ adjacent nodes. We keep track of visited nodes and add them to deadends since there are no difference between them.

Complexity

Time complexity: there are at most $10^4=10000$ nodes and we visited all nodes at most once.
$$O(1)$$
Space complexity: there are at most $10^4=10000$ nodes.
$$O(1)$$

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


class Solution {
public:
 vector<string> get_ajacent_nodes(const string &s) {
 vector<string> result;
 for (int i = 0; i < s.size(); ++i) {
 string s1 = s;
 string s2 = s;
 if ('1' <= s[i] && s[i] <= '9') {
 s1.replace(i, 1, string(1, s[i] + 1));
 s2.replace(i, 1, string(1, s[i] - 1));
 } else if (s[i] == '9') {
 s1.replace(i, 1, "0");
 s2.replace(i, 1, "8");
 } else {
 s1.replace(i, 1, "1");
 s2.replace(i, 1, "9");
 }
 result.push_back(s1);
 result.push_back(s2);
 }
 return result;
 }

 int openLock(vector<string>& deadends, string target) {
 unordered_set<string> set_deadends(deadends.begin(), deadends.end());
 queue<string> q;
 q.push("0000");
 int result = 0;
 while (!q.empty()) {
 int size = q.size();
 for (int i = 0; i < size; ++i) {
 string node = q.front();
 q.pop();
 // dead end check
 if (set_deadends.find(node) != set_deadends.end()) continue;
 // target check
 if (node == target) return result;
 // mark as visited
 set_deadends.insert(node);
 const vector<string> &adjacent_nodes = get_ajacent_nodes(node);
 for (const string &adjacent_node: adjacent_nodes) {
 q.push(adjacent_node);
 }
 }
 ++result;
 }
 return -1;
 }
};