state compression Archives - Huahua's Tech Road

花花酱 LeetCode 1659. Maximize Grid Happiness

zxi — Mon, 23 Nov 2020 06:27:48 +0000

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)

C++

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(pow(3, i)) % 3; };
    auto update = [](int val, int s) { return (val * 3 + s) % kMaxStates; };
    vector init{0, 120, 40};
    vector gain{0, -30, 20};
    
    function 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 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);
  }
};

Python3

# 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 post 花花酱 LeetCode 1659. Maximize Grid Happiness appeared first on Huahua's Tech Road.

花花酱 LeetCode 1494. Parallel Courses II

zxi — Sun, 28 Jun 2020 05:41:08 +0000

Given the integer n representing the number of courses at some university labeled from 1 to n, and the array dependencies where dependencies[i] = [x_i, y_i] represents a prerequisite relationship, that is, the course x_i must be taken before the course y_i. Also, you are given the integer k.

In one semester you can take at most k courses as long as you have taken all the prerequisites for the courses you are taking.

Return the minimum number of semesters to take all courses. It is guaranteed that you can take all courses in some way.

Example 1:

Input: n = 4, dependencies = [[2,1],[3,1],[1,4]], k = 2
Output: 3 
Explanation: The figure above represents the given graph. In this case we can take courses 2 and 3 in the first semester, then take course 1 in the second semester and finally take course 4 in the third semester.

Example 2:

Input: n = 5, dependencies = [[2,1],[3,1],[4,1],[1,5]], k = 2
Output: 4 
Explanation: The figure above represents the given graph. In this case one optimal way to take all courses is: take courses 2 and 3 in the first semester and take course 4 in the second semester, then take course 1 in the third semester and finally take course 5 in the fourth semester.

Example 3:

Input: n = 11, dependencies = [], k = 2
Output: 6

Constraints:

1 <= n <= 15
1 <= k <= n
0 <= dependencies.length <= n * (n-1) / 2
dependencies[i].length == 2
1 <= x_i, y_i <= n
x_i != y_i
All prerequisite relationships are distinct, that is, dependencies[i] != dependencies[j].
The given graph is a directed acyclic graph.

Solution: DP / Bitmask

NOTE: This is a NP problem, any polynomial-time algorithm is incorrect otherwise P = NP.

Variant 1:
dp[m] := whether state m is reachable, where m is the bitmask of courses studied.
For each semester, we enumerate all possible states from 0 to 2^n – 1, if that state is reachable, then we choose c (c <= k) courses from n and check whether we can study those courses.
If we can study those courses, we have a new reachable state, we set dp[m | courses] = true.

Time complexity: O(n*2^n*2^n) = O(n*n^4) <– This will be much smaller in practice.
and can be reduced to O(n*3^n).
Space complexity: O(2^n)

C++

// Author: Huahua, 52 ms, 14.5 MB
class Solution {
public:
  int minNumberOfSemesters(int n, vector>& dependencies, int k) {    
    const int S = 1 << n;
    vector deps(n); // deps[i] = dependency mask for course i.
    for (const auto& d : dependencies)
      deps[d[1] - 1] |= 1 << (d[0] - 1);    
    // dp(i)[s] := reachable(s) at semester i.
    vector dp(S);
    dp[0] = 1;
    for (int d = 1; d <= n; ++d) { // at most n semesters.
      vector tmp(S); // start a new semesters.
      for (int s = 0; s < S; ++s) {
        if (!dp[s]) continue; // not a reachable state.
        int mask = 0;
        for (int i = 0; i < n; ++i)
          if (!(s & (1 << i)) && (s & deps[i]) == deps[i]) 
            mask |= (1 << i);
        // Prunning, take all.
        if (__builtin_popcount(mask) <= k) {
          tmp[s | mask] = 1;         
        } else {
          // Try all subsets. 
          for (int c = mask; c; c = (c - 1) & mask)
            if (__builtin_popcount(c) <= k) {
              tmp[s | c] = 1;
            }
        }
        if (tmp.back()) return d;
      }
      dp.swap(tmp);      
    }
    return -1;
  }
};

Variant 2:
dp[m] := min semesters to reach state m.
dp[m | c] = min{dp[m | c], dp[m] + 1}, if we can reach m | c from m.
This allows us to get rid of enumerate n semesters.
Time complexity: O(2^n*2^n) <– This will be much smaller in practice.
and can be reduced to O(3^n).
Space complexity: O(2^n)

C++

// Author: Huahua, 16 ms, 8.5 MB
class Solution {
public:
  int minNumberOfSemesters(int n, vector>& dependencies, int k) {
    const int kInf = 1e9;
    const int S = 1 << n;
    vector deps(n); // deps[i] = dependency mask for course i.
    for (const auto& d : dependencies)
      deps[d[1] - 1] |= 1 << (d[0] - 1);    
    // dp[m] := min semesters to reach state m.
    vector dp(S, kInf);
    dp[0] = 0;
    for (int s = 0; s < S; ++s) {
      if (dp[s] == kInf) continue; // not reachable.
      // Generate a mask of courses we can study under state s.
      int mask = 0;
      for (int i = 0; i < n; ++i)
        if (!(s & (1 << i)) && (s & deps[i]) == deps[i])
          mask |= (1 << i);
      // Prunning, take all.
      if (__builtin_popcount(mask) <= k) {
        dp[s | mask] = min(dp[s | mask], dp[s] + 1);       
      } else {
        // Try all subsets.
        for (int c = mask; c; c = (c - 1) & mask)
          if (__builtin_popcount(c) <= k)
            dp[s | c] = min(dp[s | c], dp[s] + 1);
      }
      // Early termination?
      if (dp.back() != kInf) return dp.back();
    }
    return dp.back();
  }
};

The post 花花酱 LeetCode 1494. Parallel Courses II appeared first on Huahua's Tech Road.

花花酱 LeetCode 1434. Number of Ways to Wear Different Hats to Each Other

zxi — Mon, 04 May 2020 03:23:29 +0000

There are n people and 40 types of hats labeled from 1 to 40.

Given a list of list of integers hats, where hats[i] is a list of all hats preferred by the i-th person.

Return the number of ways that the n people wear different hats to each other.

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

Example 1:

Input: hats = [[3,4],[4,5],[5]]
Output: 1
Explanation: There is only one way to choose hats given the conditions. 
First person choose hat 3, Second person choose hat 4 and last one hat 5.

Example 2:

Input: hats = [[3,5,1],[3,5]]
Output: 4
Explanation: There are 4 ways to choose hats
(3,5), (5,3), (1,3) and (1,5)

Example 3:

Input: hats = [[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,2,3,4]]
Output: 24
Explanation: Each person can choose hats labeled from 1 to 4.
Number of Permutations of (1,2,3,4) = 24.

Example 4:

Input: hats = [[1,2,3],[2,3,5,6],[1,3,7,9],[1,8,9],[2,5,7]]
Output: 111

Constraints:

n == hats.length
1 <= n <= 10
1 <= hats[i].length <= 40
1 <= hats[i][j] <= 40
hats[i] contains a list of unique integers.

Solution: DP

dp[i][j] := # of ways using first i hats, j is the bit mask of people wearing hats.

e.g. dp[3][101] == # of ways using first 3 hats that people 1 and 3 are wearing hats.

init dp[0][0] = 1

dp[i][mask | (1 << p)] = dp[i-1][mask | (1 << p)] + dp[i-1][mask], where people p prefers hats i.

ans: dp[nHat][1…1]

Time complexity: O(2^n * h * n)
Space complexity: O(2^n * h) -> O(2^n)

C++

// Author: Huahua
class Solution {
public:
  int numberWays(vector>& hats) {
    constexpr int kHat = 40;
    constexpr int kMod = 1e9 + 7;
    const int n = hats.size();    
    vector> people(kHat + 1); // hat -> {people}
    for (int i = 0; i < n; ++i)
      for (int hat : hats[i])
        people[hat].push_back(i);
    // dp[i][j] := # of ways using first i hats where j is bit mask of people wearing hats.
    vector> dp(kHat + 1, vector(1 << n));
    dp[0][0] = 1;
    
    for (int i = 1; i <= kHat; ++i) {
      dp[i] = dp[i - 1];
      for (int mask = (1 << n) - 1; mask >= 0; --mask)
        for (int p : people[i]) {
          if (mask & (1 << p)) continue;
          dp[i][mask | (1 << p)] += dp[i - 1][mask];
          dp[i][mask | (1 << p)] %= kMod;          
        }
    }
    return dp.back().back();
  }
};

O(2^n) memory

C++

// Author: Huahua
class Solution {
public:
  int numberWays(vector>& hats) {
    constexpr int kHat = 40;
    constexpr int kMod = 1e9 + 7;
    const int n = hats.size();    
    vector> people(kHat + 1); // hat -> {people}
    for (int i = 0; i < n; ++i)
      for (int hat : hats[i])
        people[hat].push_back(i);
    // dp([i])[j] := # of ways using first i hats where j is bit mask of people wearing hat.
    vector dp(1 << n);
    dp[0] = 1;
    
    for (int i = 1; i <= kHat; ++i)      
      for (int mask = (1 << n) - 1; mask >= 0; --mask)
        for (int p : people[i]) {
          if (mask & (1 << p)) continue;
          dp[mask | (1 << p)] += dp[mask];
          dp[mask | (1 << p)] %= kMod;          
      }
    return dp.back();
  }
};

The post 花花酱 LeetCode 1434. Number of Ways to Wear Different Hats to Each Other appeared first on Huahua's Tech Road.