时间复杂度：O(n)
空间复杂度：O(1)

class Solution {
public:
  int finalValueAfterOperations(vector<string>& operations) {
    return accumulate(begin(operations), end(operations), 0, [](const auto s, const auto& op){
      return s + (op[1] == '+' ? 1 : -1);
    });
  }
};

时间复杂度：O(m*n) 每个格子最多遍历3遍。
空间复杂度：O(1)

class Solution {
public:
  vector<vector<int>> findFarmland(vector<vector<int>>& land) {
    const int m = land.size();
    const int n = land[0].size();
    vector<vector<int>> ans;
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j) {
        if (!land[i][j]) continue;
        int w = 0;
        int h = 0;
        while (j + w < n && land[i][j + w]) ++w;
        while (i + h < m && land[i + h][j]) ++h;
        ans.push_back({i, j, i + h - 1, j + w - 1});
        for (int p = 0; p < h; ++p)
          for (int q = 0; q < w; ++q)
            land[i + p][j + q] = 0; // mark as seen.
      }
    return ans;
  }
};

时间复杂度：O(n)
空间复杂度：O(1)

// https://zxi.mytechroad.com/blog/string/leetcode-3498-reverse-degree-of-a-string/
class Solution {
public:
  int reverseDegree(string s) {
    int ans = 0;
    for (int i = 0; i < s.size(); ++i)
      ans += ('z' - s[i] + 1) * (i + 1);
    return ans;
  }
};

You are given an array of non-zero integers nums. The ant starts reading nums from the first element of it to its end. At each step, it moves according to the value of the current element:

• If nums[i] < 0, it moves left by -nums[i] units.
• If nums[i] > 0, it moves right by nums[i] units.

Return the number of times the ant returns to the boundary.

Notes:

• There is an infinite space on both sides of the boundary.
• We check whether the ant is on the boundary only after it has moved |nums[i]| units. In other words, if the ant crosses the boundary during its movement, it does not count.

Example 1:

Input: nums = [2,3,-5]
Output: 1
Explanation: After the first step, the ant is 2 steps to the right of the boundary.
After the second step, the ant is 5 steps to the right of the boundary.
After the third step, the ant is on the boundary.
So the answer is 1.

Example 2:

Input: nums = [3,2,-3,-4]
Output: 0
Explanation: After the first step, the ant is 3 steps to the right of the boundary.
After the second step, the ant is 5 steps to the right of the boundary.
After the third step, the ant is 2 steps to the right of the boundary.
After the fourth step, the ant is 2 steps to the left of the boundary.
The ant never returned to the boundary, so the answer is 0.

Constraints:

• 1 <= nums.length <= 100
• -10 <= nums[i] <= 10
• nums[i] != 0

Solution: Simulation

Simulate the position of the ant by summing up the numbers. If the position is zero (at boundary), increase the answer by 1.

Time complexity: O(n)
Space complexity: O(1)

class Solution {
public:
  int returnToBoundaryCount(vector<int>& nums) {
    int ans = 0;
    int pos = 0;
    for (int x : nums)
      ans += !(pos += x);
    return ans;
  }
};

The bowling game consists of n turns, and the number of pins in each turn is exactly 10.

Assume a player hit xi pins in the ith turn. The value of the ith turn for the player is:

• 2xi if the player hit 10 pins in any of the previous two turns.
• Otherwise, It is xi.

The score of the player is the sum of the values of their n turns.

Return

• 1 if the score of player 1 is more than the score of player 2,
• 2 if the score of player 2 is more than the score of player 1, and
• 0 in case of a draw.

Example 1:

Input: player1 = [4,10,7,9], player2 = [6,5,2,3]
Output: 1
Explanation: The score of player1 is 4 + 10 + 2*7 + 2*9 = 46.
The score of player2 is 6 + 5 + 2 + 3 = 16.
Score of player1 is more than the score of player2, so, player1 is the winner, and the answer is 1.

Example 2:

Input: player1 = [3,5,7,6], player2 = [8,10,10,2]
Output: 2
Explanation: The score of player1 is 3 + 5 + 7 + 6 = 21.
The score of player2 is 8 + 10 + 2*10 + 2*2 = 42.
Score of player2 is more than the score of player1, so, player2 is the winner, and the answer is 2.

Example 3:

Input: player1 = [2,3], player2 = [4,1]
Output: 0
Explanation: The score of player1 is 2 + 3 = 5
The score of player2 is 4 + 1 = 5
The score of player1 equals to the score of player2, so, there is a draw, and the answer is 0.

Constraints:

• n == player1.length == player2.length
• 1 <= n <= 1000
• 0 <= player1[i], player2[i] <= 10

Solution: Simulation

We can write a function to compute the score of a player.

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int isWinner(vector<int>& player1, vector<int>& player2) {
    auto score = [] (const vector<int>& player) {
      int sum = 0;
      int twice = 0;
      for (int x : player) {        
        sum += twice-- > 0 ? x * 2 : x;
        if (x == 10) twice = 2;
      }
      return sum;
    };
    int s1 = score(player1);
    int s2 = score(player2);
    if (s1 == s2) return 0;
    return s1 > s2 ? 1 : 2;
  }
};

• For example, if grid = [[-10], [3], [12]], the width of the only column is 3 since -10 is of length 3.

Return an integer array ans of size n where ans[i] is the width of the ith column.

The length of an integer x with len digits is equal to len if x is non-negative, and len + 1 otherwise.

Example 1:

Input: grid = [[1],[22],[333]]
Output: [3]
Explanation: In the 0th column, 333 is of length 3.

Example 2:

Input: grid = [[-15,1,3],[15,7,12],[5,6,-2]]
Output: [3,1,2]
Explanation: 
In the 0th column, only -15 is of length 3.
In the 1st column, all integers are of length 1. 
In the 2nd column, both 12 and -2 are of length 2.

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 100
• -109 <= grid[r][c] <= 109

Solution: Simulation

Note: width of ‘0’ is 1.

Time complexity: O(m*n*log(x))
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  vector<int> findColumnWidth(vector<vector<int>>& grid) {
    vector<int> ans;
    for (int j = 0; j < grid[0].size(); ++j) {
      int maxWidth = 1;
      for (int i = 0; i < grid.size(); ++i) {
        int x = grid[i][j];
        int width = 0;        
        if (x < 0) {
          x = -x;
          ++width;
        }
        while (x) {
          x /= 10;
          ++width;
        }        
        maxWidth = max(maxWidth, width);
      }
      ans.push_back(maxWidth);
    }
    return ans;
  }
};

A guard can see every cell in the four cardinal directions (north, east, south, or west) starting from their position unless obstructed by a wall or another guard. A cell is guarded if there is at least one guard that can see it.

Return the number of unoccupied cells that are not guarded.

Example 1:

Input: m = 4, n = 6, guards = [[0,0],[1,1],[2,3]], walls = [[0,1],[2,2],[1,4]]
Output: 7
Explanation: The guarded and unguarded cells are shown in red and green respectively in the above diagram.
There are a total of 7 unguarded cells, so we return 7.

Example 2:

Input: m = 3, n = 3, guards = [[1,1]], walls = [[0,1],[1,0],[2,1],[1,2]]
Output: 4
Explanation: The unguarded cells are shown in green in the above diagram.
There are a total of 4 unguarded cells, so we return 4.

Constraints:

• 1 <= m, n <= 105
• 2 <= m * n <= 105
• 1 <= guards.length, walls.length <= 5 * 104
• 2 <= guards.length + walls.length <= m * n
• guards[i].length == walls[j].length == 2
• 0 <= rowi, rowj < m
• 0 <= coli, colj < n
• All the positions in guards and walls are unique.

Solution: Simulation

Enumerate each cell, for each guard, shoot rays to 4 directions, mark cells on the way to 1 and stop when hit a guard or a wall.

Time complexity: O(mn)
Space complexity: O(mn)

// Author: Huahua
class Solution {
public:
  int countUnguarded(int m, int n, vector<vector<int>>& guards, vector<vector<int>>& walls) {
    vector<vector<int>> s(m, vector<int>(n));
    for (const auto& g : guards)
      s[g[0]][g[1]] = 2;
    
    for (const auto& w : walls)
      s[w[0]][w[1]] = 3;
    
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j) {
        if (s[i][j] != 2) continue;
        for (int y = i - 1; y >= 0; s[y--][j] = 1)
          if (s[y][j] >= 2) break;          
        for (int y = i + 1; y < m; s[y++][j] = 1)
          if (s[y][j] >= 2) break;        
        for (int x = j - 1; x >= 0; s[i][x--] = 1)
          if (s[i][x] >= 2) break;    
        for (int x = j + 1; x < n; s[i][x++] = 1)
          if (s[i][x] >= 2) break;          
      }    
    int ans = 0;
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j)
        ans += !s[i][j];
    return ans;
  }
};

The triangular sum of nums is the value of the only element present in nums after the following process terminates:

1. Let nums comprise of n elements. If n == 1, end the process. Otherwise, create a new 0-indexed integer array newNums of length n - 1.
2. For each index i, where 0 <= i < n - 1, assign the value of newNums[i] as (nums[i] + nums[i+1]) % 10, where % denotes modulo operator.
3. Replace the array nums with newNums.
4. Repeat the entire process starting from step 1.

Return the triangular sum of nums.

Example 1:

Input: nums = [1,2,3,4,5]
Output: 8
Explanation:
The above diagram depicts the process from which we obtain the triangular sum of the array.

Example 2:

Input: nums = [5]
Output: 5
Explanation:
Since there is only one element in nums, the triangular sum is the value of that element itself.

Constraints:

• 1 <= nums.length <= 1000
• 0 <= nums[i] <= 9

Solution 1: Simulation

Time complexity: O(n²)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int triangularSum(vector<int>& nums) {
    while (nums.size() != 1) {
      vector<int> next(nums.size() - 1);
      for (size_t i = 0; i < nums.size() - 1; ++i)
        next[i] = (nums[i] + nums[i + 1]) % 10;
      swap(next, nums);
    }
    return nums[0];
  }
};

In one operation, if num1 >= num2, you must subtract num2 from num1, otherwise subtract num1 from num2.

• For example, if num1 = 5 and num2 = 4, subtract num2 from num1, thus obtaining num1 = 1 and num2 = 4. However, if num1 = 4 and num2 = 5, after one operation, num1 = 4 and num2 = 1.

Return the number of operations required to make either num1 = 0 or num2 = 0.

Example 1:

Input: num1 = 2, num2 = 3
Output: 3
Explanation: 
- Operation 1: num1 = 2, num2 = 3. Since num1 < num2, we subtract num1 from num2 and get num1 = 2, num2 = 3 - 2 = 1.
- Operation 2: num1 = 2, num2 = 1. Since num1 > num2, we subtract num2 from num1.
- Operation 3: num1 = 1, num2 = 1. Since num1 == num2, we subtract num2 from num1.
Now num1 = 0 and num2 = 1. Since num1 == 0, we do not need to perform any further operations.
So the total number of operations required is 3.

Example 2:

Input: num1 = 10, num2 = 10
Output: 1
Explanation: 
- Operation 1: num1 = 10, num2 = 10. Since num1 == num2, we subtract num2 from num1 and get num1 = 10 - 10 = 0.
Now num1 = 0 and num2 = 10. Since num1 == 0, we are done.
So the total number of operations required is 1.

Constraints:

• 0 <= num1, num2 <= 105

Solution 1: Simulation

Time complexity: O(max(n,m) / min(n, m))
Space complexity: O(1)

No code

Solution 2: Simualtion + Math

For the case of 100, 3
100 – 3 = 97
97 – 3 = 94
…
4 – 3 = 1
Swap
3 – 1 = 2
2 – 1 = 1
1 – 1 = 0
It takes 36 steps.

We can do 100 / 3 to skip 33 steps
100 %= 3 = 1
3 / 1 = 3 to skip 3 steps
3 %= 1 = 0
total is 33 + 3 = 36.

Time complexity: O(logn) ?
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int countOperations(int num1, int num2) {
    int ans = 0;
    while (num1 && num2) {
      if (num1 < num2) swap(num1, num2);
      ans += num1 / num2;
      num1 %= num2;      
    }
    return ans;
  }
};

You then do the following steps:

1. If original is found in nums, multiply it by two (i.e., set original = 2 * original).
2. Otherwise, stop the process.
3. Repeat this process with the new number as long as you keep finding the number.

Return the final value of original.

Example 1:

Input: nums = [5,3,6,1,12], original = 3
Output: 24
Explanation: 
- 3 is found in nums. 3 is multiplied by 2 to obtain 6.
- 6 is found in nums. 6 is multiplied by 2 to obtain 12.
- 12 is found in nums. 12 is multiplied by 2 to obtain 24.
- 24 is not found in nums. Thus, 24 is returned.

Example 2:

Input: nums = [2,7,9], original = 4
Output: 4
Explanation:
- 4 is not found in nums. Thus, 4 is returned.

Constraints:

• 1 <= nums.length <= 1000
• 1 <= nums[i], original <= 1000

Solution: Hashset

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int findFinalValue(vector<int>& nums, int original) {
    unordered_set<int> s(begin(nums), end(nums));
    while (true) {
      if (!s.count(original)) break;
      original *= 2;
    }
    return original;
  }
};

First, convert s into an integer by replacing each letter with its position in the alphabet (i.e., replace 'a' with 1, 'b' with 2, …, 'z' with 26). Then, transform the integer by replacing it with the sum of its digits. Repeat the transform operation k times in total.

For example, if s = "zbax" and k = 2, then the resulting integer would be 8 by the following operations:

• Convert: "zbax" ➝ "(26)(2)(1)(24)" ➝ "262124" ➝ 262124
• Transform #1: 262124 ➝ 2 + 6 + 2 + 1 + 2 + 4 ➝ 17
• Transform #2: 17 ➝ 1 + 7 ➝ 8

Return the resulting integer after performing the operations described above.

Example 1:

Input: s = "iiii", k = 1
Output: 36
Explanation: The operations are as follows:
- Convert: "iiii" ➝ "(9)(9)(9)(9)" ➝ "9999" ➝ 9999
- Transform #1: 9999 ➝ 9 + 9 + 9 + 9 ➝ 36
Thus the resulting integer is 36.

Example 2:

Input: s = "leetcode", k = 2
Output: 6
Explanation: The operations are as follows:
- Convert: "leetcode" ➝ "(12)(5)(5)(20)(3)(15)(4)(5)" ➝ "12552031545" ➝ 12552031545
- Transform #1: 12552031545 ➝ 1 + 2 + 5 + 5 + 2 + 0 + 3 + 1 + 5 + 4 + 5 ➝ 33
- Transform #2: 33 ➝ 3 + 3 ➝ 6
Thus the resulting integer is 6.

Example 3:

Input: s = "zbax", k = 2
Output: 8

Constraints:

• 1 <= s.length <= 100
• 1 <= k <= 10
• s consists of lowercase English letters.

Solution: Simulation

Time complexity: O(klogn)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int getLucky(string s, int k) {
    int ans = 0;
    for (char c : s) {
      int n = c - 'a' + 1;
      ans += n % 10;
      ans += n / 10;
    }
    while (--k) {
      int n = ans;
      ans = 0;
      while (n) {
        ans += n % 10;
        n /= 10;
      }
    }
    return ans;
  }
};

• Find the leftmost occurrence of the substring part and remove it from s.

Return s after removing all occurrences of part.

A substring is a contiguous sequence of characters in a string.

Example 1:

Input: s = "daabcbaabcbc", part = "abc"
Output: "dab"
Explanation: The following operations are done:
- s = "daabcbaabcbc", remove "abc" starting at index 2, so s = "dabaabcbc".
- s = "dabaabcbc", remove "abc" starting at index 4, so s = "dababc".
- s = "dababc", remove "abc" starting at index 3, so s = "dab".
Now s has no occurrences of "abc".

Example 2:

Input: s = "axxxxyyyyb", part = "xy"
Output: "ab"
Explanation: The following operations are done:
- s = "axxxxyyyyb", remove "xy" starting at index 4 so s = "axxxyyyb".
- s = "axxxyyyb", remove "xy" starting at index 3 so s = "axxyyb".
- s = "axxyyb", remove "xy" starting at index 2 so s = "axyb".
- s = "axyb", remove "xy" starting at index 1 so s = "ab".
Now s has no occurrences of "xy".

Constraints:

• 1 <= s.length <= 1000
• 1 <= part.length <= 1000
• s​​​​​​ and part consists of lowercase English letters.

Solution: Simulation

Time complexity: O(n²/m)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  string removeOccurrences(string s, string part) {    
    while (true) {
      size_t i = s.find(part);
      if (i == string::npos) break;
      s.erase(i, part.size());      
    }
    return s;
  }
};

• For example, given s = "EnjoyYourCoffee" and spaces = [5, 9], we place spaces before 'Y' and 'C', which are at indices 5 and 9 respectively. Thus, we obtain "Enjoy Your Coffee".

Return the modified string after the spaces have been added.

Example 1:

Input: s = "LeetcodeHelpsMeLearn", spaces = [8,13,15]
Output: "Leetcode Helps Me Learn"
Explanation: 
The indices 8, 13, and 15 correspond to the underlined characters in "LeetcodeHelpsMeLearn".
We then place spaces before those characters.

Example 2:

Input: s = "icodeinpython", spaces = [1,5,7,9]
Output: "i code in py thon"
Explanation:
The indices 1, 5, 7, and 9 correspond to the underlined characters in "icodeinpython".
We then place spaces before those characters.

Example 3:

Input: s = "spacing", spaces = [0,1,2,3,4,5,6]
Output: " s p a c i n g"
Explanation:
We are also able to place spaces before the first character of the string.

Constraints:

• 1 <= s.length <= 3 * 105
• s consists only of lowercase and uppercase English letters.
• 1 <= spaces.length <= 3 * 105
• 0 <= spaces[i] <= s.length - 1
• All the values of spaces are strictly increasing.

Solution: Scan orignal string / Two Pointers

Just scan the original string and insert a space if the current index matched the front space index.

Time complexity: O(n)
Space complexity: O(m+n) / O(1)

// Author: Huahua
class Solution {
public:
  string addSpaces(string s, vector<int>& spaces) {
    const int m = spaces.size();
    string ans;
    for (int i = 0, j = 0; i < s.length(); ++i) {
      if (j < m && i == spaces[j]) {
        ans += " ";
        ++j;
      }
      ans += s[i];      
    }
    return ans;
  }
};

Solution: Simulation w/ Two Pointers

Simulate the watering process.

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int minimumRefill(vector<int>& plants, int capacityA, int capacityB) {
    const int n = plants.size();    
    int ans = 0;
    for (int l = 0, r = n - 1, A = capacityA, B = capacityB; l <= r; ++l, --r) {      
      if (l == r)
        return ans += max(A, B) < plants[l];
      if ((A -= plants[l]) < 0) 
        A = capacityA - plants[l], ++ans;        
      if ((B -= plants[r]) < 0) 
        B = capacityB - plants[r], ++ans;     
    }
    return ans;
  }
};

The bombs are represented by a 0-indexed 2D integer array bombs where bombs[i] = [xi, yi, ri]. xi and yi denote the X-coordinate and Y-coordinate of the location of the ith bomb, whereas ri denotes the radius of its range.

You may choose to detonate a single bomb. When a bomb is detonated, it will detonate all bombs that lie in its range. These bombs will further detonate the bombs that lie in their ranges.

Given the list of bombs, return the maximum number of bombs that can be detonated if you are allowed to detonate only one bomb.

Example 1:

Input: bombs = [[2,1,3],[6,1,4]]
Output: 2
Explanation:
The above figure shows the positions and ranges of the 2 bombs.
If we detonate the left bomb, the right bomb will not be affected.
But if we detonate the right bomb, both bombs will be detonated.
So the maximum bombs that can be detonated is max(1, 2) = 2.

Example 2:

Input: bombs = [[1,1,5],[10,10,5]]
Output: 1
Explanation:
Detonating either bomb will not detonate the other bomb, so the maximum number of bombs that can be detonated is 1.

Example 3:

Input: bombs = [[1,2,3],[2,3,1],[3,4,2],[4,5,3],[5,6,4]]
Output: 5
Explanation:
The best bomb to detonate is bomb 0 because:
- Bomb 0 detonates bombs 1 and 2. The red circle denotes the range of bomb 0.
- Bomb 2 detonates bomb 3. The blue circle denotes the range of bomb 2.
- Bomb 3 detonates bomb 4. The green circle denotes the range of bomb 3.
Thus all 5 bombs are detonated.

Constraints:

• 1 <= bombs.length <= 100
• bombs[i].length == 3
• 1 <= xi, yi, ri <= 105

Solution: Simulation w/ BFS

Enumerate the bomb to detonate, and simulate the process using BFS.

Time complexity: O(n³)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int maximumDetonation(vector<vector<int>>& bombs) {
    const int n = bombs.size();    
    auto check = [&](int i, int j) -> bool {
      long x1 = bombs[i][0], y1 = bombs[i][1], r1 = bombs[i][2];
      long x2 = bombs[j][0], y2 = bombs[j][1], r2 = bombs[j][2];
      return ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) <= r1 * r1);          
    };
    int ans = 0;
    for (int s = 0; s < n; ++s) {
      int count = 0;
      queue<int> q{{s}};
      vector<int> seen(n);
      seen[s] = 1;
      while (!q.empty()) {
        ++count;
        int i = q.front(); q.pop();
        for (int j = 0; j < n; ++j)
          if (check(i, j) && !seen[j]++)
            q.push(j);
      }
      ans = max(ans, count);
    }
    return ans;
  }
};