We have `n`

buildings numbered from `0`

to `n - 1`

. Each building has a number of employees. It’s transfer season, and some employees want to change the building they reside in.

You are given an array `requests`

where `requests[i] = [from`

represents an employee’s request to transfer from building _{i}, to_{i}]`from`

to building _{i}`to`

._{i}

**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:5Explantion: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:3Explantion: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 <= from`

_{i}, to_{i}< n

**Solution: Combination**

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

Space complexity: O(n)

## C++

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// 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; } }; |

## Python3

1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
# 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 |

请尊重作者的劳动成果，转载请注明出处！花花保留对文章／视频的所有权利。

如果您喜欢这篇文章／视频，欢迎您捐赠花花。

If you like my articles / videos, donations are welcome.

## Be First to Comment