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

The post 花花酱 LeetCode 2048. Next Greater Numerically Balanced Number appeared first on Huahua's Tech Road.

The XOR sum of the two integer arrays is (nums1[0] XOR nums2[0]) + (nums1[1] XOR nums2[1]) + ... + (nums1[n - 1] XOR nums2[n - 1]) (0-indexed).

• For example, the XOR sum of [1,2,3] and [3,2,1] is equal to (1 XOR 3) + (2 XOR 2) + (3 XOR 1) = 2 + 0 + 2 = 4.

Rearrange the elements of nums2 such that the resulting XOR sum is minimized.

Return the XOR sum after the rearrangement.

Example 1:

Input: nums1 = [1,2], nums2 = [2,3]
Output: 2
Explanation: Rearrange nums2 so that it becomes [3,2].
The XOR sum is (1 XOR 3) + (2 XOR 2) = 2 + 0 = 2.

Example 2:

Input: nums1 = [1,0,3], nums2 = [5,3,4]
Output: 8
Explanation: Rearrange nums2 so that it becomes [5,4,3]. 
The XOR sum is (1 XOR 5) + (0 XOR 4) + (3 XOR 3) = 4 + 4 + 0 = 8.

Constraints:

• n == nums1.length
• n == nums2.length
• 1 <= n <= 14
• 0 <= nums1[i], nums2[i] <= 107

Solution: DP / Permutation to combination

dp[s] := min xor sum by using a subset of nums2 (presented by a binary string s) xor with nums1[0:|s|].

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

// Author: Huahua
class Solution {
public:
  int minimumXORSum(vector<int>& nums1, vector<int>& nums2) {
    const int n = nums1.size();
    vector<int> dp(1 << n, INT_MAX);
    dp[0] = 0;
    for (int s = 0; s < 1 << n; ++s) {
      int index = __builtin_popcount(s);
      for (int i = 0; i < n; ++i) {
        if (s & (1 << i)) continue;
        dp[s | (1 << i)] = min(dp[s | (1 << i)],
                               dp[s] + (nums1[index] ^ nums2[i]));
      }
    }    
    return dp.back();
  }
};

The post 花花酱 LeetCode 1879. Minimum XOR Sum of Two Arrays appeared first on Huahua's Tech Road.

We call some integer wonderful if it is a permutation of the digits in num and is greater in value than num. There can be many wonderful integers. However, we only care about the smallest-valued ones.

• For example, when num = "5489355142":
  • The 1^st smallest wonderful integer is "5489355214".
  • The 2^nd smallest wonderful integer is "5489355241".
  • The 3^rd smallest wonderful integer is "5489355412".
  • The 4^th smallest wonderful integer is "5489355421".

Return the minimum number of adjacent digit swaps that needs to be applied to num to reach the kth smallest wonderful integer.

The tests are generated in such a way that kth smallest wonderful integer exists.

Example 1:

Input: num = "5489355142", k = 4
Output: 2
Explanation: The 4th smallest wonderful number is "5489355421". To get this number:
- Swap index 7 with index 8: "5489355142" -> "5489355412"
- Swap index 8 with index 9: "5489355412" -> "5489355421"

Example 2:

Input: num = "11112", k = 4
Output: 4
Explanation: The 4th smallest wonderful number is "21111". To get this number:
- Swap index 3 with index 4: "11112" -> "11121"
- Swap index 2 with index 3: "11121" -> "11211"
- Swap index 1 with index 2: "11211" -> "12111"
- Swap index 0 with index 1: "12111" -> "21111"

Example 3:

Input: num = "00123", k = 1
Output: 1
Explanation: The 1st smallest wonderful number is "00132". To get this number:
- Swap index 3 with index 4: "00123" -> "00132"

Constraints:

• 2 <= num.length <= 1000
• 1 <= k <= 1000
• num only consists of digits.

Solution: Next Permutation + Greedy

Time complexity: O(k*n + n^2)
Space complexity: O(n)

class Solution {
public:
  int getMinSwaps(string s, int k) {
    string t(s);
    while (k--) next_permutation(begin(t), end(t));
    const int n = s.length();
    int ans = 0;
    for (int i = 0; i < n; ++i) {
      if (s[i] == t[i]) continue;
      for (int j = i + 1; j < n; ++j) {
        if (s[i] != t[j]) continue;
        ans += j - i;
        t = t.substr(0, i + 1) + t.substr(i, j - i) + t.substr(j + 1);
        break;
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1850. Minimum Adjacent Swaps to Reach the Kth Smallest Number appeared first on Huahua's Tech Road.

1. Find the largest index i such that 1 <= i < s.length and s[i] < s[i - 1].
2. Find the largest index j such that i <= j < s.length and s[k] < s[i - 1] for all the possible values of k in the range [i, j] inclusive.
3. Swap the two characters at indices i - 1​​​​ and j​​​​​.
4. Reverse the suffix starting at index i​​​​​​.

Return the number of operations needed to make the string sorted. Since the answer can be too large, return it modulo 109 + 7.

Example 1:

Input: s = "cba"
Output: 5
Explanation: The simulation goes as follows:
Operation 1: i=2, j=2. Swap s[1] and s[2] to get s="cab", then reverse the suffix starting at 2. Now, s="cab".
Operation 2: i=1, j=2. Swap s[0] and s[2] to get s="bac", then reverse the suffix starting at 1. Now, s="bca".
Operation 3: i=2, j=2. Swap s[1] and s[2] to get s="bac", then reverse the suffix starting at 2. Now, s="bac".
Operation 4: i=1, j=1. Swap s[0] and s[1] to get s="abc", then reverse the suffix starting at 1. Now, s="acb".
Operation 5: i=2, j=2. Swap s[1] and s[2] to get s="abc", then reverse the suffix starting at 2. Now, s="abc".

Example 2:

Input: s = "aabaa"
Output: 2
Explanation: The simulation goes as follows:
Operation 1: i=3, j=4. Swap s[2] and s[4] to get s="aaaab", then reverse the substring starting at 3. Now, s="aaaba".
Operation 2: i=4, j=4. Swap s[3] and s[4] to get s="aaaab", then reverse the substring starting at 4. Now, s="aaaab".

Example 3:

Input: s = "cdbea"
Output: 63

Example 4:

Input: s = "leetcodeleetcodeleetcode"
Output: 982157772

Constraints:

• 1 <= s.length <= 3000
• s​​​​​​ consists only of lowercase English letters.

Solution: Math

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

constexpr int kMod = 1e9 + 7;
int64_t powm(int64_t b, int64_t p) {
  int64_t ans = 1;
  while (p) {
    if (p & 1) ans = (ans * b) % kMod;
    b = (b * b) % kMod;
    p >>= 1;
  }
  return ans;
}

class Solution {
public:
  int makeStringSorted(string s) {
    const int n = s.length();    
    vector<int64_t> fact(n + 1, 1);
    vector<int64_t> inv(n + 1, 1);    
    
    for (int i = 1; i <= n; ++i) {
      fact[i] = (fact[i - 1] * i) % kMod;
      inv[i] = powm(fact[i], kMod - 2);
    }
    
    int64_t ans = 0;
    vector<int> freq(26);
    for (int i = n - 1; i >= 0; --i) {
      const int idx = s[i] - 'a';
      ++freq[idx];
      int64_t cur = accumulate(begin(freq), begin(freq) + idx, 0ll) *
                      fact[n - i - 1] % kMod;
      for (int f : freq)
        cur = cur * inv[f] % kMod;      
      ans = (ans + cur) % kMod;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1830. Minimum Number of Operations to Make String Sorted appeared first on Huahua's Tech Road.

There is a donuts shop that bakes donuts in batches of batchSize. They have a rule where they must serve all of the donuts of a batch before serving any donuts of the next batch. You are given an integer batchSize and an integer array groups, where groups[i] denotes that there is a group of groups[i] customers that will visit the shop. Each customer will get exactly one donut.

When a group visits the shop, all customers of the group must be served before serving any of the following groups. A group will be happy if they all get fresh donuts. That is, the first customer of the group does not receive a donut that was left over from the previous group.

You can freely rearrange the ordering of the groups. Return the maximum possible number of happy groups after rearranging the groups.

Example 1:

Input: batchSize = 3, groups = [1,2,3,4,5,6]
Output: 4
Explanation: You can arrange the groups as [6,2,4,5,1,3]. Then the 1st, 2nd, 4th, and 6th groups will be happy.

Example 2:

Input: batchSize = 4, groups = [1,3,2,5,2,2,1,6]
Output: 4

Constraints:

• 1 <= batchSize <= 9
• 1 <= groups.length <= 30
• 1 <= groups[i] <= 109

Solution 0: Binary Mask DP

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

// Author: Huahua, TLE, 42/67 Passed
class Solution {
public:
  int maxHappyGroups(int b, vector<int>& groups) {
    const int n = groups.size();
    vector<int> dp(1 << n);
    for (int mask = 0; mask < 1 << n; ++mask) {
      int s = 0;
      for (int i = 0; i < n; ++i)
        if (mask & (1 << i)) s = (s + groups[i]) % b;
      for (int i = 0; i < n; ++i)
        if (!(mask & (1 << i)))
          dp[mask | (1 << i)] = max(dp[mask | (1 << i)],
                                    dp[mask] + (s == 0));
    }
    return dp[(1 << n) - 1];
  }
};

Solution 1: Recursion w/ Memoization

State: count of group size % batchSize

// Author: Huahua, 888 ms, 61.9 MB
class Solution {
public:
  int maxHappyGroups(int b, vector<int>& groups) {
    int ans = 0;
    vector<int> count(b);
    for (int g : groups) ++count[g % b];      
    map<vector<int>, int> cache;
    function<int(int)> dp = [&](int s) {
      auto it = cache.find(count);
      if (it != cache.end()) return it->second;
      int ans = 0;
      for (int i = 1; i < b; ++i) {
        if (!count[i]) continue;
        --count[i];
        ans = max(ans, (s == 0) + dp((s + i) % b));
        ++count[i];
      }
      return cache[count] = ans;
    };    
    return count[0] + dp(0);
  }
};

// Author: Huahua 380 ms, 59.2 MB
struct VectorHasher {
  size_t operator()(const vector<int>& V) const {
    size_t hash = V.size();
    for (auto i : V)
      hash ^= i + 0x9e3779b9 + (hash << 6) + (hash >> 2);
    return hash;
  }
};
class Solution {
public:
  int maxHappyGroups(int b, vector<int>& groups) {
    int ans = 0;
    vector<int> count(b);
    for (int g : groups) ++count[g % b];      
    unordered_map<vector<int>, int, VectorHasher> cache;
    function<int(int)> dp = [&](int s) {
      auto it = cache.find(count);
      if (it != cache.end()) return it->second;
      int ans = 0;
      for (int i = 1; i < b; ++i) {
        if (!count[i]) continue;
        --count[i];
        ans = max(ans, (s == 0) + dp((s + b - i) % b));
        ++count[i];
      }
      return cache[count] = ans;
    };    
    return count[0] + dp(0);
  }
};

// Author: Huahua, 0 ms, 8.1 MB
class Solution {
public:
  int maxHappyGroups(int b, vector<int>& groups) {
    int ans = 0;
    vector<int> count(b);
    for (int g : groups) {
      const int r = g % b;
      if (r == 0) { ++ans; continue; }      
      if (count[b - r]) {
        --count[b - r];
        ++ans;
      } else {
        ++count[r];
      }
    }    
    map<vector<int>, int> cache;
    function<int(int, int)> dp = [&](int r, int n) {
      if (n == 0) return 0;
      auto it = cache.find(count);
      if (it != cache.end()) return it->second;
      int ans = 0;
      for (int i = 1; i < b; ++i) {
        if (!count[i]) continue;
        --count[i];
        ans = max(ans, (r == 0) + dp((r + b - i) % b, n - 1));
        ++count[i];
      }
      return cache[count] = ans;
    };
    const int n = accumulate(begin(count), end(count), 0);
    return ans + (n ? dp(0, n) : 0);
  }
};

The post 花花酱 LeetCode 1815. Maximum Number of Groups Getting Fresh Donuts appeared first on Huahua's Tech Road.

In one operation, you will create a new array arr, and for each i:

• If i % 2 == 0, then arr[i] = perm[i / 2].
• If i % 2 == 1, then arr[i] = perm[n / 2 + (i - 1) / 2].

You will then assign arr​​​​ to perm.

Return the minimum non-zero number of operations you need to perform on perm to return the permutation to its initial value.

Example 1:

Input: n = 2
Output: 1
Explanation: prem = [0,1] initially.
After the 1st operation, prem = [0,1]
So it takes only 1 operation.

Example 2:

Input: n = 4
Output: 2
Explanation: prem = [0,1,2,3] initially.
After the 1st operation, prem = [0,2,1,3]
After the 2nd operation, prem = [0,1,2,3]
So it takes only 2 operations.

Example 3:

Input: n = 6
Output: 4

Constraints:

• 2 <= n <= 1000
• n​​​​​​ is even.

Solution: Brute Force / Simulation

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

// Author: Huahua
class Solution {
public:
  int reinitializePermutation(int n) {
    vector<int> perm(n);
    vector<int> arr(n);
    for (int i = 0; i < n; ++i) perm[i] = i;
    int ans = 0;
    bool flag = true;
    while (flag && ++ans) {
      flag = false;
      for (int i = 0; i < n; ++i) {
        arr[i] = i & 1 ? perm[n / 2 + (i - 1) / 2] : perm[i / 2];
        flag |= arr[i] != i;        
      }
      swap(perm, arr);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1806. Minimum Number of Operations to Reinitialize a Permutation appeared first on Huahua's Tech Road.

Given 2n balls of k distinct colors. You will be given an integer array balls of size k where balls[i] is the number of balls of color i. 

All the balls will be shuffled uniformly at random, then we will distribute the first n balls to the first box and the remaining n balls to the other box (Please read the explanation of the second example carefully).

Please note that the two boxes are considered different. For example, if we have two balls of colors a and b, and two boxes [] and (), then the distribution [a] (b) is considered different than the distribution [b] (a) (Please read the explanation of the first example carefully).

We want to calculate the probability that the two boxes have the same number of distinct balls.

Example 1:

Input: balls = [1,1]
Output: 1.00000
Explanation: Only 2 ways to divide the balls equally:
- A ball of color 1 to box 1 and a ball of color 2 to box 2
- A ball of color 2 to box 1 and a ball of color 1 to box 2
In both ways, the number of distinct colors in each box is equal. The probability is 2/2 = 1

Example 2:

Input: balls = [2,1,1]
Output: 0.66667
Explanation: We have the set of balls [1, 1, 2, 3]
This set of balls will be shuffled randomly and we may have one of the 12 distinct shuffles with equale probability (i.e. 1/12):
[1,1 / 2,3], [1,1 / 3,2], [1,2 / 1,3], [1,2 / 3,1], [1,3 / 1,2], [1,3 / 2,1], [2,1 / 1,3], [2,1 / 3,1], [2,3 / 1,1], [3,1 / 1,2], [3,1 / 2,1], [3,2 / 1,1]
After that we add the first two balls to the first box and the second two balls to the second box.
We can see that 8 of these 12 possible random distributions have the same number of distinct colors of balls in each box.
Probability is 8/12 = 0.66667

Example 3:

Input: balls = [1,2,1,2]
Output: 0.60000
Explanation: The set of balls is [1, 2, 2, 3, 4, 4]. It is hard to display all the 180 possible random shuffles of this set but it is easy to check that 108 of them will have the same number of distinct colors in each box.
Probability = 108 / 180 = 0.6

Example 4:

Input: balls = [3,2,1]
Output: 0.30000
Explanation: The set of balls is [1, 1, 1, 2, 2, 3]. It is hard to display all the 60 possible random shuffles of this set but it is easy to check that 18 of them will have the same number of distinct colors in each box.
Probability = 18 / 60 = 0.3

Example 5:

Input: balls = [6,6,6,6,6,6]
Output: 0.90327

Constraints:

• 1 <= balls.length <= 8
• 1 <= balls[i] <= 6
• sum(balls) is even.
• Answers within 10^-5 of the actual value will be accepted as correct.

Solution 0: Permutation (TLE)

Enumerate all permutations of the balls, count valid ones and divide that by the total.

Time complexity: O((8*6)!) = O(48!)
After deduplication: O(48!/(6!)^8) ~ 1.7e38
Space complexity: O(8*6)

// Author: Huahua, TLE 4/21 passed
class Solution {
public:
  double getProbability(vector<int>& balls) {
    const int k = balls.size();
    vector<int> bs;
    for (int i = 0; i < k; ++i)
      for (int j = 0; j < balls[i]; ++j)
        bs.push_back(i);
    const int n = bs.size();
    double total = 0.0;
    double valid = 0.0;
    // d : depth
    // used : bitmap of bs's usage
    // c1: bitmap of colors of box1
    // c2: bitmap of colors of box1
    function<void(int, long, int, int)> dfs = [&](int d, long used, int c1, int c2) {    
      if (d == n) {          
        total += 1;
        valid += __builtin_popcount(c1) == __builtin_popcount(c2);                
        return;
      }
      for (int i = 0; i < n; ++i) {
        if (used & (1L << i)) continue;
        // Deduplication.
        if (i > 0 && bs[i] == bs[i - 1] && !(used & (1L << (i - 1)))) continue;        
        int tc1 = (d < n / 2) ? (c1 | (1 << bs[i])) : c1;
        int tc2 = (d < n / 2) ? c2 : (c2 | (1 << bs[i]));
        dfs(d + 1, used | (1L << i), tc1, tc2);
      }
    };
    dfs(0, 0, 0, 0);    
    return valid / total;
  }
};

Solution 1: Combination

For each color, put n_i balls into box1, the left t_i – n_i balls go to box2.
permutations = fact(n//2) / PROD(fact(n_i)) * fact(n//2) * PROD(fact(t_i – n_i))
E.g
balls = [1×2, 2×6, 3×4]
One possible combination:
box1: 1 22 333
box2: 1 2222 3
permutations = 6! / (1! * 2! * 3!) * 6! / (1! * 4! * 1!) = 1800

Time complexity: O((t+1)^k) = O(7^8)
Space complexity: O(k + (t*k)) = O(8 + 48)

// Author: Huahua
class Solution {
public:
  double getProbability(vector<int>& balls) {
    const int n = accumulate(begin(balls), end(balls), 0);
    const int k = balls.size();        
    double total = 0.0;
    double valid = 0.0;
    vector<double> fact(50, 1.0);
    for (int i = 1; i < fact.size(); ++i)
      fact[i] = fact[i - 1] * i;
    // d: depth
    // b1, b2: # of balls in box1, box2
    // c1, c2: # of distinct colors in box1, box2
    // p1, p2: # permutations of duplicate balls in box1, box2
    function<void(int, int, int, int, int, double, double)> dfs = [&]
      (int d, int b1, int b2, int c1, int c2, double p1, double p2) {
      if (b1 > n / 2 || b2 > n / 2) return;
      if (d == k) {
        const double count = fact[b1] / p1 * fact[b2] / p2;
        total += count;
        valid += count * (c1 == c2);
        return;
      }
      for (int s1 = 0; s1 <= balls[d]; ++s1) {
        const int s2 = balls[d] - s1;
        dfs(d + 1,
            b1 + s1, 
            b2 + s2,
            c1 + (s1 > 0), 
            c2 + (s2 > 0), 
            p1 * fact[s1], 
            p2 * fact[s2]);
      }
    };
    dfs(0, 0, 0, 0, 0, 1.0, 1.0);
    return valid / total;
  }
};

vector version

// Author: Huahua
class Solution {
public:
  double getProbability(vector<int>& balls) {
    const int k = balls.size();                    
    const int n = accumulate(begin(balls), end(balls), 0);
    vector<double> fact(49, 1.0);
    for (int i = 1; i < fact.size(); ++i)
      fact[i] = fact[i - 1] * i;
    auto perms = [&](const vector<int>& bs, int n) -> double {
      double p = fact[n];
      for (int b : bs) p /= fact[b];        
      return p;
    };
    vector<int> box1, box2;
    function<double(int)> dfs = [&](int d) -> double {
      const int n1 = accumulate(begin(box1), end(box1), 0);
      const int n2 = accumulate(begin(box2), end(box2), 0);
      if (n1 > n / 2 || n2 > n / 2) return 0;
      if (d == k)
        return (box1.size() == box2.size()) * perms(box1, n1) * perms(box2, n2);
      double total = 0;
      for (int s1 = 0; s1 <= balls[d]; ++s1) {
        const int s2 = balls[d] - s1;
        if (s1) box1.push_back(s1);
        if (s2) box2.push_back(s2);
        total += dfs(d + 1);
        if (s1) box1.pop_back();
        if (s2) box2.pop_back();
      }
      return total;
    };
    return dfs(0) / perms(balls, n);
  }
};

The post 花花酱 LeetCode 1467. Probability of a Two Boxes Having The Same Number of Distinct Balls appeared first on Huahua's Tech Road.

Count all valid pickup/delivery possible sequences such that delivery(i) is always after of pickup(i). 

Since the answer may be too large, return it modulo 10^9 + 7.

Example 1:

Input: n = 1
Output: 1
Explanation: Unique order (P1, D1), Delivery 1 always is after of Pickup 1.

Example 2:

Input: n = 2
Output: 6
Explanation: All possible orders: 
(P1,P2,D1,D2), (P1,P2,D2,D1), (P1,D1,P2,D2), (P2,P1,D1,D2), (P2,P1,D2,D1) and (P2,D2,P1,D1).
This is an invalid order (P1,D2,P2,D1) because Pickup 2 is after of Delivery 2.

Example 3:

Input: n = 3
Output: 90

Constraints:

• 1 <= n <= 500

Solution: Combination

Let dp[i] denote the number of valid sequence of i nodes.

For i-1 nodes, the sequence length is 2(i-1).
For the i-th nodes,
If we put Pi at index = 0, then we can put Di at 1, 2, …, 2i – 2 => 2i-1 options.
If we put Pi at index = 1, then we can put Di at 2,3,…, 2i – 2 => 2i – 2 options.
…
If we put Pi at index = 2i-1, then we can put Di at 2i – 1=> 1 option.
There are total (2i – 1 + 1) / 2 * (2i – 1) = i * (2*i – 1) options

dp[i] = dp[i – 1] * i * (2*i – 1)

or

dp[i] = 2n! / 2^n

// Author: Huahua
class Solution {
public:
  int countOrders(int n) {
    constexpr int kMod = 1e9 + 7;
    long ans = 1;
    for (int i = 2; i <= n; ++i)
      ans = ans * i * (2 * i - 1) % kMod;      
    return ans;
  }
};

The post 花花酱 LeetCode 1359. Count All Valid Pickup and Delivery Options appeared first on Huahua's Tech Road.

Example:

Input: [1,2,3]
Output:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

Solution: DFS

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

// Author: Huahua
class Solution {
public:
  vector<vector<int>> permute(vector<int>& nums) {
    const int n = nums.size();
    vector<vector<int>> ans;
    vector<int> used(n);
    vector<int> path;
    function<void(int)> dfs = [&](int d) {
      if (d == n) {
        ans.push_back(path);
        return;
      }
      for (int i = 0; i < n; ++i) {
        if (used[i]) continue;
        used[i] = 1;
        path.push_back(nums[i]);
        dfs(d + 1);
        path.pop_back();
        used[i] = 0;
      }
    };
    dfs(0);
    return ans;
  }
};

Related Problems

• https://zxi.mytechroad.com/blog/searching/leetcode-47-permutations-ii/

The post 花花酱 LeetCode 46. Permutations appeared first on Huahua's Tech Road.

By listing and labeling all of the permutations in order, we get the following sequence for n = 3:

1. "123"
2. "132"
3. "213"
4. "231"
5. "312"
6. "321"

Given n and k, return the k^th permutation sequence.

Note:

• Given n will be between 1 and 9 inclusive.
• Given k will be between 1 and n! inclusive.

Example 1:

Input: n = 3, k = 3
Output: "213"

Example 2:

Input: n = 4, k = 9
Output: "2314"

Solution: Math

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

// Author: Huahua
class Solution {
public:
  string getPermutation(int n, int k) {
    vector<int> num;
    vector<int> fact(10, 1);
    for (int i = 1; i <= 9; i++) {
      num.push_back(i);
      fact[i] = fact[i - 1] * i;
    }

    string s;
    k--;
    while (n--) {
      int d = k / fact[n];
      k %= fact[n];
      s += ('0' + num[d]);
      for (int i = d + 1; i <= 9; i++)
        num[i - 1] = num[i];
    }
    return s;
  }
};

The post 花花酱 LeetCode 60. Permutation Sequence appeared first on Huahua's Tech Road.

(Recall that an integer is prime if and only if it is greater than 1, and cannot be written as a product of two positive integers both smaller than it.)

Since the answer may be large, return the answer modulo 10^9 + 7.

Example 1:

Input: n = 5
Output: 12
Explanation: For example [1,2,5,4,3] is a valid permutation, but [5,2,3,4,1] is not because the prime number 5 is at index 1.

Example 2:

Input: n = 100
Output: 682289015

Constraints:

• 1 <= n <= 100

Solution: Permutation

Count the number of primes in range [1, n], assuming there are p primes and n – p non-primes, we can permute each group separately.
ans = p! * (n – p)!

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

// Author: Huahua
class Solution {
public:
  int numPrimeArrangements(int n) {
    const int kMod = 1e9 + 7;
    int p = 0;
    for (int i = 1; i <= n; ++i)
      p += isPrime(i);
    long ans = 1;
    for (int i = 1; i <= p; ++i)
      ans = (ans * i) % kMod;
    for (int i = 1; i <= n - p; ++i)
      ans = (ans * i) % kMod;
    return ans;
  }
private:
  bool isPrime(int x) {
    if (x < 2) return false;
    if (x == 2) return true;
    for (int i = 2; i <= sqrt(x); ++i)
      if (x % i == 0) return false;
    return true;
  }
};

The post 花花酱 LeetCode 1175. Prime Arrangements appeared first on Huahua's Tech Road.

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).

The replacement must be in-place and use only constant extra memory.

Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.

1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

Solution

Find the last acceding element x, swap with the smallest number y, y is after x that and y is greater than x.

Reverse the elements after x.

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua, 8 ms
class Solution {
public:
  void nextPermutation(vector<int>& nums) {
    int i = nums.size() - 2;
    while (i >= 0 && nums[i + 1] <= nums[i]) --i;
    if (i >= 0) {
      int j = nums.size() - 1;
      while (j >= 0 && nums[j] <= nums[i]) --j;
      swap(nums[i], nums[j]);
    }
    reverse(begin(nums) + i + 1, end(nums));
  }
};

# Author: Huahua, 48 ms
class Solution:
  def nextPermutation(self, nums):
    n = len(nums)
    i = n - 2
    while i >= 0 and nums[i] >= nums[i + 1]: i -= 1
    if i >= 0:
      j = n - 1
      while j >= 0 and nums[j] <= nums[i]: j -= 1
      nums[i], nums[j] = nums[j], nums[i]
    nums[i + 1:] = nums[i+1:][::-1]

The post 花花酱 LeetCode 31. Next Permutation appeared first on Huahua's Tech Road.

Given a collection of numbers that might contain duplicates, return all possible unique permutations.

Example:

Input: [1,1,2]
Output:
[
  [1,1,2],
  [1,2,1],
  [2,1,1]
]

Solution

Time complexity: O(n!)

Space complexity: O(n + k)

// Author: Huahua
// Running time: 20 ms
class Solution {
public:
  vector<vector<int>> permuteUnique(vector<int>& nums) {
    sort(begin(nums), end(nums));
    vector<vector<int>> ans;
    vector<int> used(nums.size());
    vector<int> cur;
    dfs(nums, cur, used, ans);
    return ans;
  }
private:
  void dfs(const vector<int>& nums, vector<int>& cur, vector<int>& used, vector<vector<int>>& ans) {
    if (cur.size() == nums.size()) {
      ans.push_back(cur);
      return;
    }
    for (int i = 0; i < nums.size(); ++i) {
      if (used[i]) continue;
      // Same number can be only used once at each depth.
      if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue;
      used[i] = 1;
      cur.push_back(nums[i]);
      dfs(nums, cur, used, ans);
      cur.pop_back();
      used[i] = 0;
    }
  }
};

Related Problems

• 花花酱 LeetCode 784. Letter Case Permutation

The post 花花酱 LeetCode 47. Permutations II appeared first on Huahua's Tech Road.

Given a non-negative integer n, count all numbers with unique digits, x, where 0 ≤ x < 10ⁿ.

Example:
Given n = 2, return 91. (The answer should be the total numbers in the range of 0 ≤ x < 100, excluding [11,22,33,44,55,66,77,88,99])

Solution: Math

f(0) = 1 (0)

f(1) = 10 (0 – 9)

f(2) = 9 * 9 (1-9 * (0 ~ 9 exclude the one from first digit))

f(3) = 9 * 9 * 8

f(4) = 9 * 9 * 8 * 7

…

f(x) = 0 if x >= 10

ans = sum(f[1] ~ f[n])

Time complexity: O(1)

Space complexity: O(1)

// Author: Huahua
// Running time: 0 ms
class Solution {
public:
  int countNumbersWithUniqueDigits(int n) {
    if (n == 0) return 1;
    vector<int> f(11);    
    f[1] = 10;
    f[2] = 9 * 9;
    for (int i = 3; i <= 10; ++i)
      f[i] = f[i - 1] * (10 - i + 1);
    int ans = 0;
    for (int i = 0; i <= min(10, n); ++i)
      ans += f[i];
    return ans;
  }
};

The post 花花酱 LeetCode 357. Count Numbers with Unique Digits appeared first on Huahua's Tech Road.

Example:

// Init an array with set 1, 2, and 3.
int[] nums = {1,2,3};
Solution solution = new Solution(nums);

// Shuffle the array [1,2,3] and return its result. Any permutation of [1,2,3] must equally likely to be returned.
solution.shuffle();

// Resets the array back to its original configuration [1,2,3].
solution.reset();

// Returns the random shuffling of array [1,2,3].
solution.shuffle();

C++

// Author: Huahua
// Running time: 249 ms
class Solution {
public:
  Solution(vector<int> nums) {
    nums_ = std::move(nums);
  }

  /** Resets the array to its original configuration and return it. */
  vector<int> reset() {
    return nums_;
  }

  /** Returns a random shuffling of the array. */
  vector<int> shuffle() {
    vector<int> output(nums_);
    const int n = nums_.size();
    for (int i = 0; i < n - 1; ++i) {      
      int j = rand() % (n - i) + i;
      std::swap(output[i], output[j]);
    }
    return output;
  }
private:
  vector<int> nums_;
};

The post 花花酱 LeetCode 384. Shuffle an Array appeared first on Huahua's Tech Road.