Medium 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

264. Ugly Number II

Sun, 18 Aug 2024 10:37:20 +0000

A number is ugly if its prime factors is a subset of $\{2, 3, 5\}$. We are required to find the $n$-th ugly number

Intuition

Each ugly number is generated from a previous ugly number by multiplying $2$, $3$ or $5$.

Approach

We use three pointers index_2, index_3 and index_5 to record the index of previous ugly number. For example, $4$ is generated from $2$ by multiplying $2$, so the index index_2 is the index of 2.

Then, we take the minimum of three generated numbers:

1

dp[i] = min(dp[index_2] * 2, dp[index_3] * 3, dp[index_5] * 5)

Finally, we need to update the pointers so that there is no duplication.

Complexity

Time complexity: iterate once.
$$O(n)$$
Space complexity: Use a vector to store the result.
$$O(n)$$

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 nthUglyNumber(int n) {
 vector<int> result{1};

 int index_2 = 0, index_3 = 0, index_5 = 0;

 for (int i = 1; i < n; ++i) {
 int result_2 = result[index_2] * 2;
 int result_3 = result[index_3] * 3;
 int result_5 = result[index_5] * 5;
 int current_ugly_num = min(result_2, min(result_3, result_5));

 if (current_ugly_num == result_2) ++index_2;
 if (current_ugly_num == result_3) ++index_3;
 if (current_ugly_num == result_5) ++index_5;
 }

 return result;
 }
};

References

Leetcode 264

2812. Find the Safest Path in a Grid

Wed, 15 May 2024 20:24:56 +0800

Given a matrix, we wish to find a path that from start to end, such that the path is as far as from the dangerous position.

Intuition

We can convert the problem into finding a path with minimum weights in a graph.

Approach

We first convert the matrix into a graph, with node as position (i, j) and weight w[i,j]\min_k(|i-thief[k][0]| + |j - thief[k][1]|), where thief[k]=(thief[k][0], thief[k][1]) is the position of the thief thief[k]. To do this, we can use DFS, starting from each thief and iterate through the grids.

Then, we need to find a path from the start (0, 0) to target (n - 1, n - 1). This can be done via Dijkstra’s Algorithm. We use a priority queue to keep track of minimum to-be-visited nodes, this ensures that the newly added nodes are always with the maximum safe factor.

Complexity

Time complexity: iterate all elements twice, the second trial requires to maintain the priority queue.
$$O(n^2\log n)$$
Space complexity: store safe factors matrix.
$$O(n^2)$$

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


class Solution {
 vector<vector<int>> dirs{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

public:
 int maximumSafenessFactor(vector<vector<int>>& grid) {
 int n = grid.size();
 if (grid[0][0] == 1 || grid[n - 1][n - 1] == 1)
 return 0;

 vector<vector<int>> scores(n, vector<int>(n, INT_MAX));
 queue<pair<int, int>> q;
 for (int i = 0; i < n; ++i) {
 for (int j = 0; j < n; ++j) {
 if (grid[i][j] == 0)
 continue;
 q.push(make_pair(i, j));
 scores[i][j] = 0;
 }
 }
 while (!q.empty()) {
 const auto node = q.front();
 int x = node.first, y = node.second;
 for (const auto& dir : dirs) {
 int new_x = x + dir[0], new_y = y + dir[1];
 if (new_x < 0 || new_x >= n || new_y < 0 || new_y >= n)
 continue;
 if (scores[new_x][new_y] <= 1 + scores[x][y])
 continue;
 scores[new_x][new_y] = 1 + scores[x][y];
 q.push(make_pair(new_x, new_y));
 }
 q.pop();
 }

 vector<vector<bool>> visited(n, vector<bool>(n, false));
 priority_queue<pair<int, pair<int, int>>> pq;
 pq.push(make_pair(scores[0][0], make_pair(0, 0)));

 while (!pq.empty()) {
 auto node = pq.top();
 pq.pop();
 int safe_factor = node.first;
 auto pos = node.second;
 if (pos.first == n - 1 && pos.second == n - 1)
 return safe_factor;
 visited[pos.first][pos.second] = true;
 for (const auto& dir : dirs) {
 int new_x = pos.first + dir[0], new_y = pos.second + dir[1];
 if (new_x < 0 || new_x >= n || new_y < 0 || new_y >= n)
 continue;

 if (visited[new_x][new_y])
 continue;

 int score = min(safe_factor, scores[new_x][new_y]);
 pq.push(make_pair(score, make_pair(new_x, new_y)));
 visited[new_x][new_y] = true;
 }

 }

 return -1;
 }
};

References

Leetcode

1219. Path with Maximum Gold

Tue, 14 May 2024 20:39:03 +0800

Given a matrix, whose element representing the number of golds. Find a path such that the sum is maximized and without crossing the grids that has not gold elements.

Intuition

Use backtracking to find all possible paths, and update the results.

Approach

We use two variables current and result to store results, current stores the sum of golds from start to current position, result stores the final result.

Complexity

Time complexity: In worst case, each grid contains gold, for each position, there are $\binom{m+n}{m}$ possible paths, so the overall complexity is

$$O\left(mn\binom{m+n}{m}\right)$$

Space complexity: No extra spaces needed (without considering recursive stack)

$$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


class Solution {
 vector<vector<int>> dirs{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
public:
 void backtracking(vector<vector<int>>& grid, int i, int j, int &current, int &result) {
 if (grid[i][j] <= 0) return;
 current += grid[i][j];
 // update result
 result = max(result, current);
 // mark as visited
 int temp = grid[i][j];
 grid[i][j] = -1;
 for (const auto &dir: dirs) {
 int row = i + dir[0], col = j + dir[1];
 if (row < 0 || row >= grid.size() || col < 0 || col >= grid[0].size()) {
 continue;
 }
 backtracking(grid, row, col, current, result);
 }
 // retrieve the state
 grid[i][j] = temp;
 current -= grid[i][j];
 }

 int getMaximumGold(vector<vector<int>>& grid) {
 int result = 0;
 for (int i = 0; i < grid.size(); ++i) {
 for (int j = 0; j < grid[0].size(); ++j) {
 if (grid[i][j] == 0) continue;
 int current = 0;
 backtracking(grid, i, j, current, result);
 }
 }
 return result;
 }
};

Reference

Leetcode 1219

861. Score After Flipping Matrix

Mon, 13 May 2024 20:52:02 +0800

Given a binary matrix, we can flip one column or one row, the goal is to flip zero or more times such that the sum of the number represented by the rows are maximized.

Intuition

The leading 1s are always important than the trailing 1s. So we make sure that 1 appears before 0s.

Approach

The challenge is to determine when to flip the rows and flip the columns. From the intuition, we know that:

a row is flipped only if its first bit is 0, after flipping, the number becomes larger and cannot be flipped again.
a column is flipped only if the number of 1s are smaller than 0s.

So we flip the rows first and the columns second.

Complexity

Time complexity: iterate matrix twice.
$$ O(mn) $$
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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


class Solution {
public:
 int matrixScore(vector<vector<int>>& grid) {
 int m = grid.size(), n = grid[0].size();
 for (int i = 0; i < m; ++i) {
 if (grid[i][0] == 0) {
 // flip row
 for (int j = 0; j < n; ++j) {
 grid[i][j] = 1 - grid[i][j];
 }
 }
 }

 // check column by column
 for (int j = 1; j < n; ++j) {
 int count = 0;
 for (int i = 0; i < m; ++i) {
 count += grid[i][j];
 }
 if (count < (m + 1) / 2) {
 // flip column
 for (int k = 0; k < m; ++k) {
 grid[k][j] = 1 - grid[k][j];
 }
 }
 }

 int result = 0;
 for (int i = 0; i < m; ++i) {
 for (int j = 0; j < n; ++j) {
 if (grid[i][j] == 0) continue;
 result += (1 << (n - j - 1));
 }

 }

 return result;
 }
};

References

Leetcode

3075. Maximize Happiness of Selected Children

Thu, 09 May 2024 20:21:07 +0800

Given an integer array representing the happiness of the children, select $k$ children such that the sum of their happiness is maximized.

Intuition

Since happiness of all rest children after choosing one child will decrease by 1, their relative order will still the same. So this problem is actually requiring us to select $k$ most happy children.

Approach

Use sorting.

Complexity

Time complexity: Sort the array.
$$O(n\log n)$$
Space complexity: No extra spaces are needed.
$$O(1)$$

Code

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


class Solution {
public:
 long long maximumHappinessSum(vector<int>& happiness, int k) {
 sort(happiness.begin(), happiness.end());
 int n = happiness.size();
 long long result = 0;
 for (int i = 0; i < k; ++i) {
 result += max(happiness[n - 1 - i] - i, 0);
 }
 return result;
 }
};

Reference

Leetcode

2487. Remove Nodes From Linked List

Mon, 06 May 2024 19:47:28 +0800

Given a linked list, we are required to remove some nodes, such that for each node in the result linked list, the value of the node is the greatest from the node to the end of the linked list.

Intuition

We construct the result linked list from right to left, that is, the last node in the linked list is kept, then the pointer goes from right to left util there is a node with greater value. This process can be done via post traversal as tree.

Complexity

Time complexity: iterate the list once.
$$O(n)$$
Space complexity: use a set to store numbers.
$$O(n)$$

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


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode() : val(0), next(nullptr) {}
 * ListNode(int x) : val(x), next(nullptr) {}
 * ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
 void reverse_traversal(ListNode* head, stack<int> &s) {
 if (!head) return;
 reverse_traversal(head->next, s);
 if (s.empty() || head->val >= s.top()) {
 s.push(head->val);
 }
 }

 ListNode* removeNodes(ListNode* head) {
 stack<int> s;
 reverse_traversal(head, s);
 ListNode* dummyhead = new ListNode(0, nullptr);
 ListNode* cur = dummyhead;
 while (!s.empty()) {
 cur->next = new ListNode(s.top(), nullptr);
 cur = cur->next;
 s.pop();
 }
 return dummyhead->next;
 }
};
``

# References
- [Leetcode](https://leetcode.com/problems/remove-nodes-from-linked-list/description/)

2816. Double a Number Represented as a Linked List

Mon, 06 May 2024 19:47:28 +0800

Given a linked list representing a non-negative integer, we are required to double this integer and convert it back to a linked list.

Intuition

We can just simulate the process, that is:

Retrieve the integer represented by the linked list
Double the integer
Construct the result linked list from the result integer.

Approach

We can just simulate the process as above. However, if the integer is very large, retrieve the integer may cause overflow. To simplify this process, we can use a stack to store the digits of the original integer, then we double the integer by operating on the top of the stack.

In each step, we pop an element from the stack, doubling it and adding it with the carry digit. Then we construct the result linked list with inserting the new node in the front of the head.

Complexity

Time complexity: iterate all digits twice.
$$O(n)$$
Space complexity: store the result linked list.
$$O(n)$$

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


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode() : val(0), next(nullptr) {}
 * ListNode(int x) : val(x), next(nullptr) {}
 * ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
 ListNode* doubleIt(ListNode* head) {
 stack<int> s;
 ListNode* cur = head;
 while (cur) {
 s.push(cur->val);
 cur = cur->next;
 }
 int carry = 0;
 while (!s.empty()) {
 int num = s.top() * 2 + carry;
 ListNode* pre = new ListNode(num % 10, cur);
 carry = num / 10;
 cur = pre;
 s.pop();
 }
 if (carry) {
 ListNode* pre = new ListNode(carry, cur);
 cur = pre;
 }
 return cur;
 }
};

References

Leetcode

237. Delete Node in a Linked List

Sun, 05 May 2024 20:13:45 +0800

Given a linked list and the node to be deleted, delete the node without accessing the head of the linked list

Intuition

This deletion is same as deleting a node from an array.

Approach

We use two pointers, pre and node to represent the previous and current node of the linked list, and we update the value of pre and node at each iteration. Finally, we delete the last node in the linked list.

Complexity

Time complexity: iterate the linked list 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


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
 void deleteNode(ListNode* node) {
 ListNode* pre = nullptr;
 while (node->next) {
 node->val = node->next->val;
 pre = node;
 node = node->next;
 }
 pre->next = nullptr;
 }
};

References

Leetcode

881. Boats to Save People

Sat, 04 May 2024 09:06:48 +0800

Given an array weight where weight[i] representing the weight of person i, now given the capacity of the boat and the constraint that each boat can carry at most two people, find the minimum number of boats to carry all people.

Intuition

Always pair the lightest person abd the heaviest person to a boat.

Approach

We first sort the array weight in ascending order. Then we use two pointers left=0 and right=n-1 to iterate through the array. In each step, there are two cases:

If weight[left]+weight[right] > limit, then we cannot find a peer who can take one boat with right, in this case, right occupies a single boat alone.
If weight[left]+weight[right] <= limit, then these two people can take one boat.

Complexity

Time complexity: sort the array and iterate the array once.
$$ O(n\log 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


class Solution {
public:
 int numRescueBoats(vector<int>& people, int limit) {
 sort(people.begin(), people.end());
 int left = 0, right = people.size() - 1;
 int num = 0;
 while (left <= right){
 if (people[right] + people[left] <= limit)
 ++left;
 --right;
 ++num;
 }

 return num;
 }
};

References

Leetcode

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

2997. Minimum Number of Operations to Make Array XOR Equal to K

Mon, 29 Apr 2024 21:16:53 +0800

Given an integer array, we can flip one bit of one element of the array at every step, we asked to compute the minimum flips, such that the XOR of all elements of the array is equal to the given integer $k$.

Intuition

XOR of multiple bits is always equal to either 1 or 0, and changes one of the input bits will cause the result change to the other one.

Approach

We first compute the XOR of all elements of the array, then we compare bit by bit with the XOR result and the given k, utils all bits becomes the same.

Complexity

Time complexity: compute the XOR result
$$O(n)$$
Space complexity: No extra spaces are 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


class Solution {
public:
 int minOperations(vector<int>& nums, int k) {
 int result = nums[0];
 for (int i = 1; i < nums.size(); ++i) {
 result ^= nums[i];
 }
 vector<int> bits_result, bits_k;
 while (k) {
 bits_k.push_back(k % 2);
 k /= 2;
 }
 while (result) {
 bits_result.push_back(result % 2);
 result /= 2;
 }
 int count = 0;
 int i = 0;
 for (; i < bits_result.size() && i < bits_k.size(); ++i) {
 if (bits_result[i] != bits_k[i])
 ++count;
 }
 for (; i < bits_result.size(); ++i) {
 if (bits_result[i] == 1)
 ++count;
 }
 for (; i < bits_k.size(); ++i) {
 if (bits_k[i] == 1)
 ++count;
 }
 return count;
 }
};

2370. Longest Ideal Subsequence

Thu, 25 Apr 2024 20:34:06 +0800

Given a string consisting of lower-case characters, find the longest subsequence such that the distance between adjacent characters in the subsequence are less than a given threshold.

Intuition

Same as the longest increasing subsequence, we can use dynamic programming to solve this problem.

Approach

We use dp[i] to represent the longest ideal subsequence that ended with s[i - 1]. We then update the dp[i] with the property of ideal subsequence:

$$ dp[i] = \max_{j=1,\dots,i-1, \mathrm{abs}(s[i - 1]-s[j - 1])\leq k}(dp[i],\ dp[j] + 1) ,\ i=1,\dots,n$$

However, it turns out that the above solution is of complexity $O(n^2)$, which leads to Time Exceed Limit, so we need to optimize it.

Now, consider the property of ideal sequence, we only care about those characters that is within the range (s[i - 1] - k, s[i - 1] + k). So, we can use a map record, whose key is all lowercase characters, to remember the result that is used to update dp[i], that is, for given index i:

$$ record[l] = \max_{j=1,\dots,i - 1, s[j] - 'a' = l}dp[j] $$

in this way, we have

$$ dp[i] = \max_{\mathrm{abs}((s[i]-'a') - l)\leq k}(dp[i],\ record[l] + 1),\ i=1,\dots,n $$

notice that len(record)=26, so the complexity now reduces to $O(n)$.

Complexity

Time complexity: iterate all characters once, each iteration queries record at most $26$ times.
$$O(n)$$
Space complexity: stores the dp array, can be optimized to $O(1)$ by update result at each iteration.
$$O(n)$$

Code

 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 longestIdealString(string s, int k) {
 int n = s.size();
 vector<int> dp(n + 1);
 vector<int> record(26);
 for (int i = 0; i < n; ++i) {
 dp[i + 1] = 1;
 int index = s[i] - 'a';
 for (int j = 0; j < 26; ++j) {
 if (abs(index - j) <= k) {
 dp[i + 1] = max(dp[i + 1], record[j] + 1);
 }
 }
 record[index] = max(record[index], dp[i + 1]);
 }
 int result = 0;
 for (int i = 0; i < n + 1; ++i) {
 result = max(result, dp[i]);
 }
 return result;
 }
};