You are given a 2D integer array adjacentPairs of size n - 1 where each adjacentPairs[i] = [ui, vi] indicates that the elements ui and vi are adjacent in nums.

It is guaranteed that every adjacent pair of elements nums[i] and nums[i+1] will exist in adjacentPairs, either as [nums[i], nums[i+1]] or [nums[i+1], nums[i]]. The pairs can appear in any order.

Return the original array nums. If there are multiple solutions, return any of them.

Example 1:

Input: adjacentPairs = [[2,1],[3,4],[3,2]]
Output: [1,2,3,4]
Explanation: This array has all its adjacent pairs in adjacentPairs.
Notice that adjacentPairs[i] may not be in left-to-right order.

Example 2:

Input: adjacentPairs = [[4,-2],[1,4],[-3,1]]
Output: [-2,4,1,-3]
Explanation: There can be negative numbers.
Another solution is [-3,1,4,-2], which would also be accepted.

Example 3:

Input: adjacentPairs = [[100000,-100000]]
Output: [100000,-100000]

Constraints:

• nums.length == n
• adjacentPairs.length == n - 1
• adjacentPairs[i].length == 2
• 2 <= n <= 105
• -105 <= nums[i], ui, vi <= 105
• There exists some nums that has adjacentPairs as its pairs.

Solution: Hashtable

Reverse thinking! For a given input array, e.g.
[1, 2, 3, 4, 5]
it’s adjacent pairs are [1,2] , [2,3], [3,4], [4,5]
all numbers appeared exactly twice except 1 and 5, since they are on the boundary.
We just need to find the head or tail of the input array, and construct the rest of the array in order.

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

// Author: Huahua
class Solution {
public:
  vector<int> restoreArray(vector<vector<int>>& adjacentPairs) {
    const int n = adjacentPairs.size() + 1;
    unordered_map<int, vector<int>> g;
    for (const auto& p : adjacentPairs) {
      g[p[0]].push_back(p[1]);
      g[p[1]].push_back(p[0]);
    }
    
    vector<int> ans(n);
    for (const auto& [u, vs] : g)
      if (vs.size() == 1) {
        ans[0] = u;
        ans[1] = vs[0];
        break;
      }
        
    for (int i = 2; i < n; ++i) {
      const auto& vs = g[ans[i - 1]];
      ans[i] = vs[0] == ans[i - 2] ? vs[1] : vs[0];      
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1743. Restore the Array From Adjacent Pairs appeared first on Huahua's Tech Road.

Given three integers a, b and c, return any string s, which satisfies following conditions:

• s is happy and longest possible.
• s contains at most a occurrences of the letter 'a', at most b occurrences of the letter 'b' and at most c occurrences of the letter 'c'.
• s will only contain 'a', 'b' and 'c' letters.

If there is no such string s return the empty string "".

Example 1:

Input: a = 1, b = 1, c = 7
Output: "ccaccbcc"
Explanation: "ccbccacc" would also be a correct answer.

Example 2:

Input: a = 2, b = 2, c = 1
Output: "aabbc"

Example 3:

Input: a = 7, b = 1, c = 0
Output: "aabaa"
Explanation: It's the only correct answer in this case.

Constraints:

• 0 <= a, b, c <= 100
• a + b + c > 0

Solution: Greedy

Put the char with highest frequency first if its consecutive length of that char is < 2
or put one char if any of other two chars has consecutive length of 2.

increase the consecutive length of itself and reset that for other two chars.

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

// Author: Huahua
class Solution {
public:
  string longestDiverseString(int a, int b, int c) {
    const int total = a + b + c;        
    vector<int> f{a, b, c};
    vector<int> l{0, 0, 0};
    string ans;
    for (int _ = 0; _ < total; ++_)
      for (int i = 0; i < 3; ++i) {
        const int j = (i + 1) % 3;
        const int k = (i + 2) % 3;        
        if ((f[i] >= f[j] && f[i] >= f[k] && l[i] != 2) 
            || (f[i] > 0 && (l[j] == 2 || l[k] == 2))) {
          ans += 'a' + i;
          ++l[i];
          --f[i];
          l[j] = l[k] = 0;
          break;
      }    
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1405. Longest Happy String appeared first on Huahua's Tech Road.