You are given a list of preferences
for n
friends, where n
is always even.
For each person i
, preferences[i]
contains a list of friends sorted in the order of preference. In other words, a friend earlier in the list is more preferred than a friend later in the list. Friends in each list are denoted by integers from 0
to n-1
.
All the friends are divided into pairs. The pairings are given in a list pairs
, where pairs[i] = [xi, yi]
denotes xi
is paired with yi
and yi
is paired with xi
.
However, this pairing may cause some of the friends to be unhappy. A friend x
is unhappy if x
is paired with y
and there exists a friend u
who is paired with v
but:
x
prefersu
overy
, andu
prefersx
overv
.
Return the number of unhappy friends.
Example 1:
Input: n = 4, preferences = [[1, 2, 3], [3, 2, 0], [3, 1, 0], [1, 2, 0]], pairs = [[0, 1], [2, 3]] Output: 2 Explanation: Friend 1 is unhappy because: - 1 is paired with 0 but prefers 3 over 0, and - 3 prefers 1 over 2. Friend 3 is unhappy because: - 3 is paired with 2 but prefers 1 over 2, and - 1 prefers 3 over 0. Friends 0 and 2 are happy.
Example 2:
Input: n = 2, preferences = [[1], [0]], pairs = [[1, 0]] Output: 0 Explanation: Both friends 0 and 1 are happy.
Example 3:
Input: n = 4, preferences = [[1, 3, 2], [2, 3, 0], [1, 3, 0], [0, 2, 1]], pairs = [[1, 3], [0, 2]] Output: 4
Constraints:
2 <= n <= 500
n
is even.preferences.length == n
preferences[i].length == n - 1
0 <= preferences[i][j] <= n - 1
preferences[i]
does not containi
.- All values in
preferences[i]
are unique. pairs.length == n/2
pairs[i].length == 2
xi != yi
0 <= xi, yi <= n - 1
- Each person is contained in exactly one pair.
Solution: HashTable
Put the order in a map {x -> {y, order}}, since this is dense, we use can 2D array instead of hasthable which is much faster.
Then for each pair, we just need to check every other pair and compare their orders.
Time complexity: O(n^2)
Space complexity: O(n^2)
C++
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
class Solution { public: int unhappyFriends(int n, vector<vector<int>>& preferences, vector<vector<int>>& pairs) { vector<int> p(n); for (const auto& pair : pairs) { p[pair[0]] = pair[1]; p[pair[1]] = pair[0]; } vector<vector<int>> orders(n, vector<int>(n)); for (int x = 0; x < n; ++x) for (int i = 0; i < preferences[x].size(); ++i) orders[x][preferences[x][i]] = i; int ans = 0; for (int x = 0; x < n; ++x) { const int y = p[x]; bool found = false; for (int u = 0; u < n && !found; ++u) { if (u == x || u == y) continue; const int v = p[u]; found |= orders[x][u] < orders[x][y] && orders[u][x] < orders[u][v]; } if (found) ++ans; } return ans; } }; |
请尊重作者的劳动成果,转载请注明出处!花花保留对文章/视频的所有权利。
如果您喜欢这篇文章/视频,欢迎您捐赠花花。
If you like my articles / videos, donations are welcome.
Be First to Comment