方法1: BFS

把问题看成求无权重图中的最短路径，BFS可以找到最优解。

我们的节点有两个状态，当前的长度，剪贴板（上次复制后）的长度。
长度超过n一定无解，所以我们的状态最多只有n²种，每个状态最多拓展2个新的节点。

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

class Solution {
public:
  int minSteps(int n) {
    vector<vector<bool>> seen(n + 1, vector<bool>(n + 1));
    queue<pair<int, int>> q;

    auto expand = [&](int len, int clip) {
      if (len > n || len > n || seen[len][clip]) return;
      q.emplace(len, clip);
      seen[len][clip] = true;
    };

    int steps = 0;
    expand(1, 0); // init state.
    while (!q.empty()) {
      int size = q.size();
      while (size--) {
        auto [len, clip] = q.front(); q.pop();
        if (len == n) return steps;
        expand(len, len); // copy.
        expand(len + clip, clip); // paste.
      }
      ++steps;
    }
    return -1;
  }
};

Two strings s1 and s2 are said to be connected if the set of letters of s2 can be obtained from the set of letters of s1 by any one of the following operations:

• Adding exactly one letter to the set of the letters of s1.
• Deleting exactly one letter from the set of the letters of s1.
• Replacing exactly one letter from the set of the letters of s1 with any letter, including itself.

The array words can be divided into one or more non-intersecting groups. A string belongs to a group if any one of the following is true:

• It is connected to at least one other string of the group.
• It is the only string present in the group.

Note that the strings in words should be grouped in such a manner that a string belonging to a group cannot be connected to a string present in any other group. It can be proved that such an arrangement is always unique.

Return an array ans of size 2 where:

• ans[0] is the total number of groups words can be divided into, and
• ans[1] is the size of the largest group.

Example 1:

Input: words = ["a","b","ab","cde"]
Output: [2,3]
Explanation:
- words[0] can be used to obtain words[1] (by replacing 'a' with 'b'), and words[2] (by adding 'b'). So words[0] is connected to words[1] and words[2].
- words[1] can be used to obtain words[0] (by replacing 'b' with 'a'), and words[2] (by adding 'a'). So words[1] is connected to words[0] and words[2].
- words[2] can be used to obtain words[0] (by deleting 'b'), and words[1] (by deleting 'a'). So words[2] is connected to words[0] and words[1].
- words[3] is not connected to any string in words.
Thus, words can be divided into 2 groups ["a","b","ab"] and ["cde"]. The size of the largest group is 3.  

Example 2:

Input: words = ["a","ab","abc"]
Output: [1,3]
Explanation:
- words[0] is connected to words[1].
- words[1] is connected to words[0] and words[2].
- words[2] is connected to words[1].
Since all strings are connected to each other, they should be grouped together.
Thus, the size of the largest group is 3.

Constraints:

• 1 <= words.length <= 2 * 104
• 1 <= words[i].length <= 26
• words[i] consists of lowercase English letters only.
• No letter occurs more than once in words[i].

Solution: Bitmask + DFS

Use a bitmask to represent a string. Use dfs to find connected components.

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

// Author: Huahua
class Solution {
public:
  vector<int> groupStrings(vector<string>& words) {
    unordered_map<int, int> m;
    for (const string& w : words)
      ++m[accumulate(begin(w), end(w), 0, [](int k, char c){ return k | (1 << (c - 'a')); })];
    function<int(int)> dfs = [&](int mask) {
      auto it = m.find(mask);
      if (it == end(m)) return 0;
      int ans = it->second;      
      m.erase(it);
      for (int i = 0; i < 26; ++i) {        
        ans += dfs(mask ^ (1 << i));
        for (int j = i + 1; j < 26; ++j)
          if ((mask >> i & 1) != (mask >> j & 1))
            ans += dfs(mask ^ (1 << i) ^ (1 << j));
      }
      return ans;
    };
    int size = 0;
    int groups = 0;
    while (!m.empty()) {
      size = max(size, dfs(begin(m)->first));
      ++groups;
    }
    return {groups, size};
  }
};

• For example, 9 is a 2-mirror number. The representation of 9 in base-10 and base-2 are 9 and 1001 respectively, which read the same both forward and backward.
• On the contrary, 4 is not a 2-mirror number. The representation of 4 in base-2 is 100, which does not read the same both forward and backward.

Given the base k and the number n, return the sum of the n smallest k-mirror numbers.

Example 1:

Input: k = 2, n = 5
Output: 25
Explanation:
The 5 smallest 2-mirror numbers and their representations in base-2 are listed as follows:
  base-10    base-2
    1          1
    3          11
    5          101
    7          111
    9          1001
Their sum = 1 + 3 + 5 + 7 + 9 = 25. 

Example 2:

Input: k = 3, n = 7
Output: 499
Explanation:
The 7 smallest 3-mirror numbers are and their representations in base-3 are listed as follows:
  base-10    base-3
    1          1
    2          2
    4          11
    8          22
    121        11111
    151        12121
    212        21212
Their sum = 1 + 2 + 4 + 8 + 121 + 151 + 212 = 499.

Example 3:

Input: k = 7, n = 17
Output: 20379000
Explanation: The 17 smallest 7-mirror numbers are:
1, 2, 3, 4, 5, 6, 8, 121, 171, 242, 292, 16561, 65656, 2137312, 4602064, 6597956, 6958596

Constraints:

• 2 <= k <= 9
• 1 <= n <= 30

Solution: Generate palindromes in base-k.

# Author: Huahua
class Solution:
  def kMirror(self, k: int, n: int) -> int:
    def getNext(x: str) -> str:
      s = list(x)
      l = len(s)    
      for i in range(l // 2, l):
        if int(s[i]) + 1 >= k: continue
        s[i] = s[~i] = str(int(s[i]) + 1)
        for j in range(l // 2, i): s[j] = s[~j] = "0"
        return "".join(s)
      return "1" + "0" * (l - 1) + "1"
    ans = 0
    x = "0"
    for _ in range(n):
      while True:
        x = getNext(x)
        val = int(x, k)
        if str(val) == str(val)[::-1]: break
      ans += val
    return ans

Return the maximum possible product of the lengths of the two palindromic subsequences.

A subsequence is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters. A string is palindromic if it reads the same forward and backward.

Example 1:

Input: s = "leetcodecom"
Output: 9
Explanation: An optimal solution is to choose "ete" for the 1st subsequence and "cdc" for the 2nd subsequence.
The product of their lengths is: 3 * 3 = 9.

Example 2:

Input: s = "bb"
Output: 1
Explanation: An optimal solution is to choose "b" (the first character) for the 1st subsequence and "b" (the second character) for the 2nd subsequence.
The product of their lengths is: 1 * 1 = 1.

Example 3:

Input: s = "accbcaxxcxx"
Output: 25
Explanation: An optimal solution is to choose "accca" for the 1st subsequence and "xxcxx" for the 2nd subsequence.
The product of their lengths is: 5 * 5 = 25.

Constraints:

• 2 <= s.length <= 12
• s consists of lowercase English letters only.

Solution 1: DFS

Time complexity: O(3ⁿ*n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int maxProduct(string s) {    
    auto isPalindrom = [](const string& s) {
      for (int i = 0; i < s.length(); ++i)
        if (s[i] != s[s.size() - i - 1]) return false;
      return true;
    };
    const int n = s.size();
    vector<string> ss(3);
    size_t ans = 0;
    function<void(int)> dfs = [&](int i) -> void {
      if (i == n) {
        if (isPalindrom(ss[0]) && isPalindrom(ss[1]))
          ans = max(ans, ss[0].size() * ss[1].size());
        return;
      }
      for (int k = 0; k < 3; ++k) {
        ss[k].push_back(s[i]);
        dfs(i + 1); 
        ss[k].pop_back();  
      }      
    };
    dfs(0);
    return ans;
  }
};

Solution: Subsets + Bitmask + All Pairs

Time complexity: O(2²ⁿ)
Space complexity: O(2ⁿ)

// Author: Huahua
class Solution {
public:
  int maxProduct(string s) {    
    auto isPalindrom = [](const string& s) {
      for (int i = 0; i < s.length(); ++i)
        if (s[i] != s[s.size() - i - 1]) return false;
      return true;
    };
    const int n = s.size();
    unordered_set<int> p;
    for (int i = 0; i < (1 << n); ++i) {
      string t;
      for (int j = 0; j < n; ++j)
        if (i >> j & 1) t.push_back(s[j]);
      if (isPalindrom(t))
        p.insert(i);
    }
    int ans = 0;
    for (int s1 : p)
      for (int s2 : p) 
        if (!(s1 & s2))
          ans = max(ans, __builtin_popcount(s1) * __builtin_popcount(s2));
    return ans;
  }
};

A valid path in the graph is any path that starts at node 0, ends at node 0, and takes at most maxTime seconds to complete. You may visit the same node multiple times. The quality of a valid path is the sum of the values of the unique nodes visited in the path (each node’s value is added at most once to the sum).

Return the maximum quality of a valid path.

Note: There are at most four edges connected to each node.

Example 1:

Input: values = [0,32,10,43], edges = [[0,1,10],[1,2,15],[0,3,10]], maxTime = 49
Output: 75
Explanation:
One possible path is 0 -> 1 -> 0 -> 3 -> 0. The total time taken is 10 + 10 + 10 + 10 = 40 <= 49.
The nodes visited are 0, 1, and 3, giving a maximal path quality of 0 + 32 + 43 = 75.

Example 2:

Input: values = [5,10,15,20], edges = [[0,1,10],[1,2,10],[0,3,10]], maxTime = 30
Output: 25
Explanation:
One possible path is 0 -> 3 -> 0. The total time taken is 10 + 10 = 20 <= 30.
The nodes visited are 0 and 3, giving a maximal path quality of 5 + 20 = 25.

Example 3:

Input: values = [1,2,3,4], edges = [[0,1,10],[1,2,11],[2,3,12],[1,3,13]], maxTime = 50
Output: 7
Explanation:
One possible path is 0 -> 1 -> 3 -> 1 -> 0. The total time taken is 10 + 13 + 13 + 10 = 46 <= 50.
The nodes visited are 0, 1, and 3, giving a maximal path quality of 1 + 2 + 4 = 7.

Example 4:

Input: values = [0,1,2], edges = [[1,2,10]], maxTime = 10
Output: 0
Explanation: 
The only path is 0. The total time taken is 0.
The only node visited is 0, giving a maximal path quality of 0.

Constraints:

• n == values.length
• 1 <= n <= 1000
• 0 <= values[i] <= 108
• 0 <= edges.length <= 2000
• edges[j].length == 3
• 0 <= uj < vj <= n - 1
• 10 <= timej, maxTime <= 100
• All the pairs [uj, vj] are unique.
• There are at most four edges connected to each node.
• The graph may not be connected.

Solution: DFS

Given time >= 10 and maxTime <= 100, the path length is at most 10, given at most four edges connected to each node.
Time complexity: O(4¹⁰)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int maximalPathQuality(vector<int>& values, vector<vector<int>>& edges, int maxTime) {
    const int n = values.size();
    vector<vector<pair<int, int>>> g(n);
    for (const auto& e : edges) {
      g[e[0]].emplace_back(e[1], e[2]);
      g[e[1]].emplace_back(e[0], e[2]);
    }
    vector<int> seen(n);
    int ans = 0;
    function<void(int, int, int)> dfs = [&](int u, int t, int s) {
      if (++seen[u] == 1) s += values[u];
      if (u == 0) ans = max(ans, s);
      for (auto [v, d] : g[u])
        if (t + d <= maxTime) dfs(v, t + d, s);
      if (--seen[u] == 0) s -= values[u];
    };
    dfs(0, 0, 0);
    return ans;
  }
};

Given an integer n, return the smallest numerically balanced number strictly greater than n.

Example 1:

Input: n = 1
Output: 22
Explanation: 
22 is numerically balanced since:
- The digit 2 occurs 2 times. 
It is also the smallest numerically balanced number strictly greater than 1.

Example 2:

Input: n = 1000
Output: 1333
Explanation: 
1333 is numerically balanced since:
- The digit 1 occurs 1 time.
- The digit 3 occurs 3 times. 
It is also the smallest numerically balanced number strictly greater than 1000.
Note that 1022 cannot be the answer because 0 appeared more than 0 times.

Example 3:

Input: n = 3000
Output: 3133
Explanation: 
3133 is numerically balanced since:
- The digit 1 occurs 1 time.
- The digit 3 occurs 3 times.
It is also the smallest numerically balanced number strictly greater than 3000.

Constraints:

• 0 <= n <= 106

Solution: Permutation

Time complexity: O(log(n)!)
Space complexity: O(log(n)) ?

// Author: Huahua
class Solution {
public:
  int nextBeautifulNumber(int n) {
    const string t = to_string(n);
    vector<int> nums{1,
                     22,
                     122, 333,
                     1333, 4444,
                     14444, 22333, 55555,
                     122333, 155555, 224444, 666666};
    int ans = 1224444;
    for (int num : nums) {
      string s = to_string(num);
      if (s.size() < t.size()) continue;
      else if (s.size() > t.size()) {
        ans = min(ans, num);
      } else { // same length 
        do {
          if (s > t) ans = min(ans, stoi(s));
        } while (next_permutation(begin(s), end(s)));
      }
    }
    return ans;
  }
};

Check if we can split s into two or more non-empty substrings such that the numerical values of the substrings are in descending order and the difference between numerical values of every two adjacent substrings is equal to 1.

• For example, the string s = "0090089" can be split into ["0090", "089"] with numerical values [90,89]. The values are in descending order and adjacent values differ by 1, so this way is valid.
• Another example, the string s = "001" can be split into ["0", "01"], ["00", "1"], or ["0", "0", "1"]. However all the ways are invalid because they have numerical values [0,1], [0,1], and [0,0,1] respectively, all of which are not in descending order.

Return true if it is possible to split s​​​​​​ as described above, or false otherwise.

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

Example 1:

Input: s = "1234"
Output: false
Explanation: There is no valid way to split s.

Example 2:

Input: s = "050043"
Output: true
Explanation: s can be split into ["05", "004", "3"] with numerical values [5,4,3].
The values are in descending order with adjacent values differing by 1.

Example 3:

Input: s = "9080701"
Output: false
Explanation: There is no valid way to split s.

Example 4:

Input: s = "10009998"
Output: true
Explanation: s can be split into ["100", "099", "98"] with numerical values [100,99,98].
The values are in descending order with adjacent values differing by 1.

Constraints:

• 1 <= s.length <= 20
• s only consists of digits.

Solution: DFS

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

class Solution {
public:
  bool splitString(string s) {
    const int n = s.length();
    vector<long> nums;
    function<bool(int)> dfs = [&](int p) {
      if (p == n) return nums.size() >= 2;
      long cur = 0;
      for (int i = p; i < n && cur < 1e11; ++i) {        
        cur = cur * 10 + (s[i] - '0');
        if (nums.empty() || cur + 1 == nums.back()) {
          nums.push_back(cur);
          if (dfs(i + 1)) return true;
          nums.pop_back();
        }
        if (!nums.empty() && cur >= nums.back()) break;                
      }
      return false;
    };
    return dfs(0);
  }
};

• There must be exactly one ice cream base.
• You can add one or more types of topping or have no toppings at all.
• There are at most two of each type of topping.

You are given three inputs:

• baseCosts, an integer array of length n, where each baseCosts[i] represents the price of the ith ice cream base flavor.
• toppingCosts, an integer array of length m, where each toppingCosts[i] is the price of one of the ith topping.
• target, an integer representing your target price for dessert.

You want to make a dessert with a total cost as close to target as possible.

Return the closest possible cost of the dessert to target. If there are multiple, return the lower one.

Example 1:

Input: baseCosts = [1,7], toppingCosts = [3,4], target = 10
Output: 10
Explanation: Consider the following combination (all 0-indexed):
- Choose base 1: cost 7
- Take 1 of topping 0: cost 1 x 3 = 3
- Take 0 of topping 1: cost 0 x 4 = 0
Total: 7 + 3 + 0 = 10.

Example 2:

Input: baseCosts = [2,3], toppingCosts = [4,5,100], target = 18
Output: 17
Explanation: Consider the following combination (all 0-indexed):
- Choose base 1: cost 3
- Take 1 of topping 0: cost 1 x 4 = 4
- Take 2 of topping 1: cost 2 x 5 = 10
- Take 0 of topping 2: cost 0 x 100 = 0
Total: 3 + 4 + 10 + 0 = 17. You cannot make a dessert with a total cost of 18.

Example 3:

Input: baseCosts = [3,10], toppingCosts = [2,5], target = 9
Output: 8
Explanation: It is possible to make desserts with cost 8 and 10. Return 8 as it is the lower cost.

Example 4:

Input: baseCosts = [10], toppingCosts = [1], target = 1
Output: 10
Explanation: Notice that you don't have to have any toppings, but you must have exactly one base.

Constraints:

• n == baseCosts.length
• m == toppingCosts.length
• 1 <= n, m <= 10
• 1 <= baseCosts[i], toppingCosts[i] <= 104
• 1 <= target <= 104

Solution: DP / Knapsack

Pre-compute the costs of all possible combinations of toppings.

Time complexity: O(sum(toppings) * 2 * (m + n)) ~ O(10^6)
Space complexity: O(sum(toppings)) ~ O(10^5)

// Author: Huahua
class Solution {
public:
  int closestCost(vector<int>& bs, vector<int>& ts, int target) {
    const int kMax = 2 * accumulate(begin(ts), end(ts), 0);
    int min_diff = INT_MAX;
    int ans = INT_MAX;
    vector<int> dp(kMax + 1);
    dp[0] = 1;
    for (int t : ts) {
      for (int i = kMax; i >= 0; --i) {
        if (!dp[i]) continue;
        if (i + t <= kMax) dp[i + t] = 1;
        if (i + 2 * t <= kMax) dp[i + 2 * t] = 1;        
      }
    }   
    for (int i = 0; i <= kMax; ++i) {
      if (!dp[i]) continue;
       for (int b : bs) {
        const int diff = abs(b + i - target);
        if (diff < min_diff || diff == min_diff && b + i < ans) {
          min_diff = diff;
          ans = b + i;
        }
      }
    }
    return ans;
  }
};

Solution 2: DFS

Combination

Time complexity: O(3^m * n)
Space complexity: O(m)

// Author: Huahua
class Solution {
public:
  int closestCost(vector<int>& bs, vector<int>& ts, int target) {
    const int m = ts.size();
    int min_diff = INT_MAX;
    int ans = INT_MAX;
    function<void(int, int)> dfs = [&](int s, int cur) {
      if (s == m) {
        for (int b : bs) {
          const int total = b + cur;
          const int diff = abs(total - target);
          if (diff < min_diff 
              || diff == min_diff && total < ans) {
            min_diff = diff;
            ans = total;
          }
        }
        return;
      }      
      for (int i = s; i < m; ++i) {
        dfs(i + 1, cur);
        dfs(i + 1, cur + ts[i]);
        dfs(i + 1, cur + ts[i] * 2);
      }
    };    
    dfs(0, 0);
    return ans;
  }
};

You are given an integer array nums and an integer goal.

You want to choose a subsequence of nums such that the sum of its elements is the closest possible to goal. That is, if the sum of the subsequence’s elements is sum, then you want to minimize the absolute difference abs(sum - goal).

Return the minimum possible value of abs(sum - goal).

Note that a subsequence of an array is an array formed by removing some elements (possibly all or none) of the original array.

Example 1:

Input: nums = [5,-7,3,5], goal = 6
Output: 0
Explanation: Choose the whole array as a subsequence, with a sum of 6.
This is equal to the goal, so the absolute difference is 0.

Example 2:

Input: nums = [7,-9,15,-2], goal = -5
Output: 1
Explanation: Choose the subsequence [7,-9,-2], with a sum of -4.
The absolute difference is abs(-4 - (-5)) = abs(1) = 1, which is the minimum.

Example 3:

Input: nums = [1,2,3], goal = -7
Output: 7

Constraints:

• 1 <= nums.length <= 40
• -107 <= nums[i] <= 107
• -109 <= goal <= 109

Solution: Binary Search

Since n is too large to generate sums for all subsets O(2^n), we have to split the array into half, generate two sum sets. O(2^(n/2)).

Then the problem can be reduced to find the closet sum by picking one number (sum) each from two different arrays which can be solved in O(mlogm), where m = 2^(n/2).

So final time complexity is O(n * 2^(n/2))
Space complexity: O(2^(n/2))

// Author: Huahua
class Solution {
public:
  int minAbsDifference(vector<int>& nums, int goal) {
    const int n = nums.size();
    int ans = abs(goal);
    vector<int> t1{0}, t2{0};
    t1.reserve(1 << (n / 2 + 1));
    t2.reserve(1 << (n / 2 + 1));
    for (int i = 0; i < n / 2; ++i)
      for (int j = t1.size() - 1; j >= 0; --j)
        t1.push_back(t1[j] + nums[i]);
    for (int i = n / 2; i < n; ++i)
      for (int j = t2.size() - 1; j >= 0; --j)
        t2.push_back(t2[j] + nums[i]);
    set<int> s2(begin(t2), end(t2));
    for (int x : unordered_set<int>(begin(t1), end(t1))) {
      auto it = s2.lower_bound(goal - x);
      if (it != s2.end())
        ans = min(ans, abs(goal - x - *it));
      if (it != s2.begin())
        ans = min(ans, abs(goal - x - *prev(it)));
    }
    return ans;
  }
};

• The integer 1 occurs once in the sequence.
• Each integer between 2 and n occurs twice in the sequence.
• For every integer i between 2 and n, the distance between the two occurrences of i is exactly i.

The distance between two numbers on the sequence, a[i] and a[j], is the absolute difference of their indices, |j - i|.

Return the lexicographically largest sequence. It is guaranteed that under the given constraints, there is always a solution.

A sequence a is lexicographically larger than a sequence b (of the same length) if in the first position where a and b differ, sequence a has a number greater than the corresponding number in b. For example, [0,1,9,0] is lexicographically larger than [0,1,5,6] because the first position they differ is at the third number, and 9 is greater than 5.

Example 1:

Input: n = 3
Output: [3,1,2,3,2]
Explanation: [2,3,2,1,3] is also a valid sequence, but [3,1,2,3,2] is the lexicographically largest valid sequence.

Example 2:

Input: n = 5
Output: [5,3,1,4,3,5,2,4,2]

Constraints:

• 1 <= n <= 20

Solution: Search

Search from left to right, largest to smallest.

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

// Author: Huahua
// Author: Huahua
class Solution {
public:
  vector<int> constructDistancedSequence(int n) {
    const int len = 2 * n - 1;
    vector<int> ans(len);    
    function<bool(int, int)> dfs = [&](int i, int s) {      
      if (i == len) return true;
      if (ans[i]) return dfs(i + 1, s);
      for (int d = n; d > 0; --d) {
        const int j = i + (d == 1 ? 0 : d);
        if ((s & (1 << d)) || j >= len || ans[j]) continue;
        ans[i] = ans[j] = d;
        if (dfs(i + 1, s | (1 << d))) return true;
        ans[i] = ans[j] = 0;
      }
      return false;
    };
    dfs(0, 0);
    return ans;
  }
};

// Author: Huahua
class Solution {
  private boolean dfs(int[] ans, int n, int i, int s) {
    if (i == ans.length) return true;
    if (ans[i] > 0) return dfs(ans, n, i + 1, s);
    for (int d = n; d > 0; --d) {
      int j = i + (d == 1 ? 0 : d);
      if ((s & (1 << d)) > 0 || j >= ans.length || ans[j] > 0)
        continue;
      ans[i] = ans[j] = d;
      if (dfs(ans, n, i + 1, s | (1 << d))) return true;
      ans[i] = ans[j] = 0;
    }
    return false;
  }
  
  public int[] constructDistancedSequence(int n) {    
    int[] ans = new int[n * 2 - 1];
    dfs(ans, n, 0, 0);
    return ans;
  }  
}

# Author: Huahua
class Solution:
  def constructDistancedSequence(self, n: int) -> List[int]:
    l = n * 2 - 1
    ans = [0] * l
    def dfs(i, s):
      if i == l: return True
      if ans[i]: return dfs(i + 1, s)
      for d in range(n, 0, -1):
        j = i + (0 if d == 1 else d)
        if s & (1 << d) or j >= l or ans[j]: continue
        ans[i] = ans[j] = d
        if dfs(i + 1, s | (1 << d)): return True
        ans[i] = ans[j] = 0
      return False
    dfs(0, 0)
    return ans

You are given four integers, m, n, introvertsCount, and extrovertsCount. You have an m x n grid, and there are two types of people: introverts and extroverts. There are introvertsCount introverts and extrovertsCount extroverts.

You should decide how many people you want to live in the grid and assign each of them one grid cell. Note that you do not have to have all the people living in the grid.

The happiness of each person is calculated as follows:

• Introverts start with 120 happiness and lose 30 happiness for each neighbor (introvert or extrovert).
• Extroverts start with 40 happiness and gain 20 happiness for each neighbor (introvert or extrovert).

Neighbors live in the directly adjacent cells north, east, south, and west of a person’s cell.

The grid happiness is the sum of each person’s happiness. Return the maximum possible grid happiness.

Example 1:

Input: m = 2, n = 3, introvertsCount = 1, extrovertsCount = 2
Output: 240
Explanation: Assume the grid is 1-indexed with coordinates (row, column).
We can put the introvert in cell (1,1) and put the extroverts in cells (1,3) and (2,3).
- Introvert at (1,1) happiness: 120 (starting happiness) - (0 * 30) (0 neighbors) = 120
- Extrovert at (1,3) happiness: 40 (starting happiness) + (1 * 20) (1 neighbor) = 60
- Extrovert at (2,3) happiness: 40 (starting happiness) + (1 * 20) (1 neighbor) = 60
The grid happiness is 120 + 60 + 60 = 240.
The above figure shows the grid in this example with each person's happiness. The introvert stays in the light green cell while the extroverts live on the light purple cells.

Example 2:

Input: m = 3, n = 1, introvertsCount = 2, extrovertsCount = 1
Output: 260
Explanation: Place the two introverts in (1,1) and (3,1) and the extrovert at (2,1).
- Introvert at (1,1) happiness: 120 (starting happiness) - (1 * 30) (1 neighbor) = 90
- Extrovert at (2,1) happiness: 40 (starting happiness) + (2 * 20) (2 neighbors) = 80
- Introvert at (3,1) happiness: 120 (starting happiness) - (1 * 30) (1 neighbor) = 90
The grid happiness is 90 + 80 + 90 = 260.

Example 3:

Input: m = 2, n = 2, introvertsCount = 4, extrovertsCount = 0
Output: 240

Constraints:

• 1 <= m, n <= 5
• 0 <= introvertsCount, extrovertsCount <= min(m * n, 6)

Solution: DP

dp(x, y, in, ex, mask) := max score at (x, y) with in and ex left and the state of previous row is mask.

Mask is ternary, mask(i) = {0, 1, 2} means {empty, in, ex}, there are at most 3^n = 3^5 = 243 different states.

Total states / Space complexity: O(m*n*3^n*in*ex) = 5*5*3^5*6*6
Space complexity: O(m*n*3^n*in*ex)

class Solution {
public:
  int getMaxGridHappiness(int m, int n, int introvertsCount, int extrovertsCount) {
    constexpr int kMaxStates = 243;
    int dp[6][6][7][7][kMaxStates];
    memset(dp, -1, sizeof(dp));
    auto get = [](int val, int i) { return val / static_cast<int>(pow(3, i)) % 3; };
    auto update = [](int val, int s) { return (val * 3 + s) % kMaxStates; };
    vector<int> init{0, 120, 40};
    vector<int> gain{0, -30, 20};
    
    function<int(int,int,int,int,int)> dfs = [&](int x, int y, int in, int ex, int mask) {
      if (in == 0 && ex == 0) return 0; // Nothing left.
      if (x == n) { x = 0; ++y; }
      if (y == m) return 0; // Done.
      int& ans = dp[x][y][in][ex][mask];      
      if (ans != -1) return ans;
      
      ans = dfs(x + 1, y, in, ex, update(mask, 0)); // Skip current cell.
      
      vector<int> counts{0, in, ex};
      int up = get(mask, n - 1);
      int left = get(mask, 0);         
      for (int i = 1; i <= 2; ++i) {
        if (counts[i] == 0) continue;        
        int s = init[i];
        if (y - 1 >= 0 && up) s += gain[i] + gain[up];
        if (x - 1 >= 0 && left) s += gain[i] + gain[left];
        ans = max(ans, s + dfs(x + 1, y, in - (i==1), ex - (i==2), update(mask, i)));
      }
      return ans;
    };
    return dfs(0, 0, introvertsCount, extrovertsCount, 0);
  }
};

# Author: Huahua
class Solution:
  def getMaxGridHappiness(self, m: int, n: int, I: int, E: int) -> int:    
    init, gain = [None, 120, 40], [None, -30, 20]
    
    get = lambda val, i: (val // (3 ** i)) % 3
    update = lambda val, s: (val * 3 + s) % (3 ** n)
    
    @lru_cache(None)
    def dp(x: int, y: int, i: int, e: int, mask: int) -> int:
      if x == n: x, y = 0, y + 1
      if i + e == 0 or y == m: return 0
      
      ans = dp(x + 1, y, i, e, update(mask, 0))
      up, left = get(mask, n - 1), get(mask, 0)
      
      for cur, count in enumerate([i, e], 1):
        if count == 0: continue
        s = init[cur]
        if x - 1 >= 0 and left: s += gain[cur] + gain[left]
        if y - 1 >= 0 and up: s += gain[cur] + gain[up]
        ans = max(ans, s + dp(x + 1, y, 
                              i - (cur == 1), 
                              e - (cur == 2),
                              update(mask, cur)))
      return ans
    return dp(0, 0, I, E, 0)

• The ith customer gets exactly quantity[i] integers,
• The integers the ith customer gets are all equal, and
• Every customer is satisfied.

Return true if it is possible to distribute nums according to the above conditions.

Example 1:

Input: nums = [1,2,3,4], quantity = [2]
Output: false
Explanation: The 0th customer cannot be given two different integers.

Example 2:

Input: nums = [1,2,3,3], quantity = [2]
Output: true
Explanation: The 0th customer is given [3,3]. The integers [1,2] are not used.

Example 3:

Input: nums = [1,1,2,2], quantity = [2,2]
Output: true
Explanation: The 0th customer is given [1,1], and the 1st customer is given [2,2].

Example 4:

Input: nums = [1,1,2,3], quantity = [2,2]
Output: false
Explanation: Although the 0th customer could be given [1,1], the 1st customer cannot be satisfied.

Example 5:

Input: nums = [1,1,1,1,1], quantity = [2,3]
Output: true
Explanation: The 0th customer is given [1,1], and the 1st customer is given [1,1,1].

Constraints:

• n == nums.length
• 1 <= n <= 105
• 1 <= nums[i] <= 1000
• m == quantity.length
• 1 <= m <= 10
• 1 <= quantity[i] <= 105
• There are at most 50 unique values in nums.

Solution1: Backtracking

Time complexity: O(|vals|^m)
Space complexity: O(|vals| + m)

// Author: Huahua
class Solution {
public:
  bool canDistribute(vector<int>& nums, vector<int>& quantity) {
    unordered_map<int, int> m;
    for (int x : nums) ++m[x];
    vector<int> cnt;
    for (const auto& [x, c] : m) cnt.push_back(c);
    
    const int q = quantity.size();
    const int n = cnt.size();
    function<bool(int)> dfs = [&](int d) {
      if (d == q) return true;
      for (int i = 0; i < n; ++i) 
        if (cnt[i] >= quantity[d]) {
          cnt[i] -= quantity[d];
          if (dfs(d + 1)) return true;
          cnt[i] += quantity[d];
        }
      return false;
    };
    
    sort(rbegin(cnt), rend(cnt));
    sort(rbegin(quantity), rend(quantity));
    
    return dfs(0);
  }
};

Solution 2: Bitmask + all subsets

dp(mask, i) := whether we can distribute to a subset of customers represented as a bit mask, using the i-th to (n-1)-th numbers.

Time complexity: O(2^m * m * |vals|) = O(2^10 * 10 * 50)
Space complexity: O(2^m * |vals|)

class Solution {
public:
  bool canDistribute(vector<int>& nums, vector<int>& quantity) {
    vector<int> cnt;
    unordered_map<int, int> freq;
    for (int x : nums) ++freq[x]; 
    for (const auto& [x, f] : freq) cnt.push_back(f);
    
    const int n = cnt.size();
    const int m = quantity.size();        
    
    vector<vector<optional<bool>>> cache(1 << m, vector<optional<bool>>(n));
    
    vector<int> sums(1 << m);
    for (int mask = 0; mask < 1 << m; ++mask)
      for (int i = 0; i < m; ++i)
        if (mask & (1 << i))
          sums[mask] += quantity[i];
    
    function<bool(int, int)> dp = [&](int mask, int i) -> bool {
      if (mask == 0) return true;
      if (i == n) return false;
      
      auto& ans = cache[mask][i];
      
      if (ans.has_value()) return ans.value();
      
      int cur = mask;
      while (cur) {
        if (sums[cur] <= cnt[i] && dp(mask ^ cur, i + 1)) {
          ans = true;
          return true;
        }
        cur = (cur - 1) & mask;
      }
      
      ans = dp(mask, i + 1);
      return ans.value();
    };
    
    return dp((1 << m) - 1, 0);
  }
};

# Author: Huahua
class Solution:
  def canDistribute(self, nums: List[int], 
                    quantity: List[int]) -> bool:    
    cnts = list(Counter(nums).values())
    m = len(quantity)
    n = len(cnts)
    sums = [0] * (1 << m)
    for mask in range(1 << m):
      for i in range(m):
        if mask & (1 << i): sums[mask] += quantity[i]
    
    @lru_cache(None)
    def dp(mask: int, i: int) -> bool:
      if not mask: return True
      if i < 0: return False
      
      cur = mask
      while cur:
        if sums[cur] <= cnts[i] and dp(mask ^ cur, i - 1):
          return True
        cur = (cur - 1) & mask
      
      return dp(mask, i - 1)
    
    return dp((1 << m) - 1, n - 1)

Bottom up:

class Solution {
public:
  bool canDistribute(vector<int>& nums, vector<int>& quantity) {
    vector<int> cnt;
    unordered_map<int, int> freq;
    for (int x : nums) ++freq[x]; 
    for (const auto& [x, f] : freq) cnt.push_back(f);
    
    const int n = cnt.size();
    const int m = quantity.size();            
    
    vector<int> sums(1 << m);
    for (int mask = 0; mask < 1 << m; ++mask)
      for (int i = 0; i < m; ++i)
        if (mask & (1 << i))
          sums[mask] += quantity[i];
    
    // dp[mask][i] := use first i types to satisfy mask customers.
    vector<vector<int>> dp(1 << m, vector<int>(n + 1));
    dp[0][0] = 1;    
    for (int mask = 0; mask < 1 << m; ++mask)
      for (int i = 0; i < n; ++i) {
        dp[mask][i + 1] |= dp[mask][i];
        for (int cur = mask; cur; cur = (cur - 1) & mask)
          if (sums[cur] <= cnt[i] && dp[mask ^ cur][i])
            dp[mask][i + 1] = 1;
      }
    
    return dp[(1 << m) - 1][n];
  }
};

The bug jumps according to the following rules:

• It can jump exactly a positions forward (to the right).
• It can jump exactly b positions backward (to the left).
• It cannot jump backward twice in a row.
• It cannot jump to any forbidden positions.

The bug may jump forward beyond its home, but it cannot jump to positions numbered with negative integers.

Given an array of integers forbidden, where forbidden[i] means that the bug cannot jump to the position forbidden[i], and integers a, b, and x, return the minimum number of jumps needed for the bug to reach its home. If there is no possible sequence of jumps that lands the bug on position x, return -1.

Example 1:

Input: forbidden = [14,4,18,1,15], a = 3, b = 15, x = 9
Output: 3
Explanation: 3 jumps forward (0 -> 3 -> 6 -> 9) will get the bug home.

Example 2:

Input: forbidden = [8,3,16,6,12,20], a = 15, b = 13, x = 11
Output: -1

Example 3:

Input: forbidden = [1,6,2,14,5,17,4], a = 16, b = 9, x = 7
Output: 2
Explanation: One jump forward (0 -> 16) then one jump backward (16 -> 7) will get the bug home.

Constraints:

• 1 <= forbidden.length <= 1000
• 1 <= a, b, forbidden[i] <= 2000
• 0 <= x <= 2000
• All the elements in forbidden are distinct.
• Position x is not forbidden.

Solution: BFS

Normal BFS with two tricks:
1. For each position, we need to track whether it’s reached via a forward jump or backward jump
2. How far should we go? If we don’t limit, it can go forever which leads to TLE/MLE. We can limit the distance to 2*max_jump, e.g. 4000, that’s maximum distance we can jump back to home in one shot.

Time complexity: O(max_distance * 2)
Space complexity: O(max_distance * 2)

// Author: Huahua
class Solution {
public:
  int minimumJumps(vector<int>& forbidden, int a, int b, int x) {
    constexpr int kMaxPosition = 4000;
    if (x == 0) return 0;
    queue<pair<int, bool>> q{{{0, true}}};
    unordered_set<int> seen1, seen2;
    for (int f : forbidden) seen1.insert(f), seen2.insert(f);
    seen1.insert(0);
    int steps = 0;
    while (!q.empty()) {      
      int size = q.size();
      while (size--) {
        auto [cur, forward] = q.front(); q.pop();        
        if (cur == x) return steps;
        if (cur > kMaxPosition) continue; // no way to go back
        if (seen1.insert(cur + a).second)      
          q.emplace(cur + a, true);
        if (cur - b >= 0 && forward && seen2.insert(cur - b).second)
          q.emplace(cur - b, false);
      }
      ++steps;
    }
    return -1;
  }
};

You can apply either of the following two operations any number of times and in any order on s:

• Add a to all odd indices of s (0-indexed). Digits post 9 are cycled back to 0. For example, if s = "3456" and a = 5, s becomes "3951".
• Rotate s to the right by b positions. For example, if s = "3456" and b = 1, s becomes "6345".

Return the lexicographically smallest string you can obtain by applying the above operations any number of times on s.

A string a is lexicographically smaller than a string b (of the same length) if in the first position where a and b differ, string a has a letter that appears earlier in the alphabet than the corresponding letter in b. For example, "0158" is lexicographically smaller than "0190" because the first position they differ is at the third letter, and '5' comes before '9'.

Example 1:

Input: s = "5525", a = 9, b = 2
Output: "2050"
Explanation: We can apply the following operations:
Start:  "5525"
Rotate: "2555"
Add:    "2454"
Add:    "2353"
Rotate: "5323"
Add:    "5222"
​​​​​​​Add:    "5121"
​​​​​​​Rotate: "2151"
​​​​​​​Add:    "2050"​​​​​​​​​​​​
There is no way to obtain a string that is lexicographically smaller then "2050".

Example 2:

Input: s = "74", a = 5, b = 1
Output: "24"
Explanation: We can apply the following operations:
Start:  "74"
Rotate: "47"
​​​​​​​Add:    "42"
​​​​​​​Rotate: "24"​​​​​​​​​​​​
There is no way to obtain a string that is lexicographically smaller then "24".

Example 3:

Input: s = "0011", a = 4, b = 2
Output: "0011"
Explanation: There are no sequence of operations that will give us a lexicographically smaller string than "0011".

Example 4:

Input: s = "43987654", a = 7, b = 3
Output: "00553311"

Constraints:

• 2 <= s.length <= 100
• s.length is even.
• s consists of digits from 0 to 9 only.
• 1 <= a <= 9
• 1 <= b <= s.length - 1

Solution: Search

// Author: Huahua
class Solution {
public:
  string findLexSmallestString(string s, int a, int b) {
    unordered_set<string> seen;    
    string ans(s);
    function<void(string)> dfs = [&](const string& s) {
      if (!seen.insert(s).second) return;
      ans = min(ans, s);
      string t(s);
      for (int i = 1; i < s.length(); i += 2)
        t[i] = (t[i] - '0' + a) % 10 + '0';
      dfs(t);
      dfs(s.substr(b) + s.substr(0, b));
    };    
    dfs(s);
    return ans;
  }
};

You are given an array requests where requests[i] = [fromi, toi] represents an employee’s request to transfer from building fromi to building toi.

All buildings are full, so a list of requests is achievable only if for each building, the net change in employee transfers is zero. This means the number of employees leaving is equal to the number of employees moving in. For example if n = 3 and two employees are leaving building 0, one is leaving building 1, and one is leaving building 2, there should be two employees moving to building 0, one employee moving to building 1, and one employee moving to building 2.

Return the maximum number of achievable requests.

Example 1:

Input: n = 5, requests = [[0,1],[1,0],[0,1],[1,2],[2,0],[3,4]]
Output: 5
Explantion: Let's see the requests:
From building 0 we have employees x and y and both want to move to building 1.
From building 1 we have employees a and b and they want to move to buildings 2 and 0 respectively.
From building 2 we have employee z and they want to move to building 0.
From building 3 we have employee c and they want to move to building 4.
From building 4 we don't have any requests.
We can achieve the requests of users x and b by swapping their places.
We can achieve the requests of users y, a and z by swapping the places in the 3 buildings.

Example 2:

Input: n = 3, requests = [[0,0],[1,2],[2,1]]
Output: 3
Explantion: Let's see the requests:
From building 0 we have employee x and they want to stay in the same building 0.
From building 1 we have employee y and they want to move to building 2.
From building 2 we have employee z and they want to move to building 1.
We can achieve all the requests. 

Example 3:

Input: n = 4, requests = [[0,3],[3,1],[1,2],[2,0]]
Output: 4

Constraints:

• 1 <= n <= 20
• 1 <= requests.length <= 16
• requests[i].length == 2
• 0 <= fromi, toi < n

Solution: Combination

Try all combinations: O(2^n * (r + n))
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int maximumRequests(int n, vector<vector<int>>& requests) {
    const int r = requests.size(); 
    int ans = 0;
    vector<int> nets(n);
    for (int s = 0; s < 1 << r; ++s) {
      fill(begin(nets), end(nets), 0);
      for (int j = 0; j < r; ++j)
        if (s & (1 << j)) {
          --nets[requests[j][0]];
          ++nets[requests[j][1]];
        }
      if (all_of(begin(nets), end(nets), [](const int x) { return x == 0; }))
        ans = max(ans, __builtin_popcount(s));
    }
    return ans;
  }
};

# Author: Huahua
class Solution:
  def maximumRequests(self, n: int, requests: List[List[int]]) -> int:
    r = len(requests)
    ans = 0
    for s in range(1 << r):
      degrees = [0] * n
      for i in range(r):
        if s & (1 << i):
          degrees[requests[i][0]] -= 1
          degrees[requests[i][1]] += 1
      if not any(degrees):
        ans = max(ans, bin(s).count('1'))
    return ans