If the fractional part is repeating, enclose the repeating part in parentheses.

If multiple answers are possible, return any of them.

It is guaranteed that the length of the answer string is less than 104 for all the given inputs.

Example 1:

Input: numerator = 1, denominator = 2
Output: "0.5"

Example 2:

Input: numerator = 2, denominator = 1
Output: "2"

Example 3:

Input: numerator = 2, denominator = 3
Output: "0.(6)"

Example 4:

Input: numerator = 4, denominator = 333
Output: "0.(012)"

Example 5:

Input: numerator = 1, denominator = 5
Output: "0.2"

Constraints:

• -231 <= numerator, denominator <= 231 - 1
• denominator != 0

Solution: Hashtable

Time complexity: O(?)

// Author: Huahua
class Solution {
public:
  string fractionToDecimal(int numerator, int denominator) {
    stringstream ss,ss2;

    long long n = numerator;
    long long d = denominator;

    if ( n > 0 && d < 0 || n < 0 && d > 0) {
      ss << "-";
      n = abs(n);
      d = abs(d);
    }

    ss << (n / d);

    long long r = n % d;

    bool loop = false;
    int count = 0;
    int loop_start;

    if (r) {   
      n = r;
      ss << ".";
      unordered_map<int, int> rs;
      rs[r] = 0;

      while (r) {
        n = n*10;
        r = n % d;
        ss2 << (n / d);
        n = r;
        if (r && rs.count(r)) {
          loop = true;
          loop_start = rs[r];
          break;
        }
        rs[r] = ++count;
      }

      if (loop) {
        auto s2 = ss2.str();
        ss << s2.substr(0, loop_start) << "(" << s2.substr(loop_start) << ")";
      } else  {
        ss << ss2.str();
      }
    }

    return ss.str();
  }
};

The post 花花酱 LeetCode 166. Fraction to Recurring Decimal appeared first on Huahua's Tech Road.

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 prefers u over y, and
• u prefers x over v.

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 contain i.
• 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)

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

The post 花花酱 LeetCode 1583. Count Unhappy Friends appeared first on Huahua's Tech Road.