// Author: Huahua
class Solution {
public:
  int minSwaps(string s) {    
    auto count = [&](int m) {
      vector<int> swaps(2);
      for (int i = 0; i < s.length(); ++i, m ^= 1)
        if (s[i] - '0' != m)
          ++swaps[s[i] - '0'];
      return swaps[0] == swaps[1] ? swaps[0] : INT_MAX;
    };
    
    int ans = min(count(0), count(1));
    return ans != INT_MAX ? ans : -1;
  }
};

class Solution {
public:
  ListNode* swapNodes(ListNode* head, int k) {
    int l = 0;
    ListNode* cur = head;    
    while (cur) { cur = cur->next; ++l; }    
    
    cur = head;
    ListNode* n1 = nullptr;
    ListNode* n2 = nullptr;
    for (int i = 1; i <= l; ++i, cur = cur->next) {
      if (i == k) n1 = cur;
      if (i == l - k + 1) n2 = cur;
    }
    swap(n1->val, n2->val);
    return head;
  }
};

// Author: Huahua
class Solution {
public:
  bool canMakeArithmeticProgression(vector<int>& arr) {
    sort(begin(arr), end(arr));
    const int diff = arr[1] - arr[0];
    for (int i = 2; i < arr.size(); ++i)
      if (arr[i] - arr[i - 1] != diff) return false;
    return true;
  }
};

// Author: Huahua
class Solution {
  public boolean canMakeArithmeticProgression(int[] arr) {
    Arrays.sort(arr);
    int diff = arr[1] - arr[0];
    for (int i = 2; i < arr.length; ++i)
      if (arr[i] - arr[i - 1] != diff) return false;
    return true;
  }
}

class Solution:
  def canMakeArithmeticProgression(self, arr: List[int]) -> bool:
    arr.sort()
    diff = arr[1] - arr[0]
    return all(i - j == diff for i, j in zip(arr[1:], arr[:-1]))

// Author: Huahua
class Solution {
public:
  bool canMakeArithmeticProgression(vector<int>& arr) {
    const int n = arr.size();
    const auto [loit, hiit] = minmax_element(cbegin(arr), cend(arr));
    const auto [lo, hi] = pair{*loit, *hiit};
    if ((hi - lo) % (n - 1)) return false;
    const int diff = (hi - lo) / (n - 1);
    if (diff == 0) return true;
    for (int i = 0; i < n; ++i) {
      if ((arr[i] - lo) % diff) return false;
      const int idx = (arr[i] - lo) / diff;
      if (idx != i) swap(arr[i--], arr[idx]);
    }
    return true;
  }
};

// Author: Huahua
class Solution {
public:
  int makeArrayIncreasing(vector<int>& a, vector<int>& c) {
    constexpr int kInf = 1e9;
    int m = a.size();    
    // Sort b and make it only containing unique numbers.
    sort(begin(c), end(c));
    vector<int> b;
    for (int i = 0; i < c.size(); ++i) {
      if (!b.empty() && c[i] == b.back()) continue;
      b.push_back(c[i]);
    }    
    int n = b.size();
    
    // min steps to make a[0~i] valid by keeping a[i]
    vector<int> keep(m, kInf);
    keep[0] = 0;
    // swap[i][j] := min steps to make a[0~i] valid by a[i] = b[j]
    vector<int> swap(n, 1);
    
    for (int i = 1; i < m; ++i) {
      int min_keep = kInf;
      int min_swap = kInf;
      vector<int> temp(n, kInf);
      for (int j = 0; j < n; ++j) {
        if (j > 0) min_swap = min(min_swap, swap[j - 1] + 1);
        if (a[i] > b[j]) min_keep = min(min_keep, swap[j]);        
        if (a[i] > a[i - 1]) keep[i] = keep[i - 1];
        if (b[j] > a[i - 1]) temp[j] = keep[i - 1] + 1;        
        temp[j] = min(temp[j], min_swap);
        keep[i] = min(keep[i], min_keep);
      }
      temp.swap(swap);
    }
    
    int s = *min_element(begin(swap), end(swap));
    int k = keep.back();
    int ans = min(s, k);
    return ans >= kInf ? -1 : ans;
  }
};

class Solution {
public:
  vector<int> flipMatchVoyage(TreeNode* root, vector<int>& voyage) {
    vector<int> flips;
    int pos = 0;
    solve(root, voyage, pos, flips);
    return flips;
  }
private:
  void solve(TreeNode* root, const vector<int>& voyage, int& pos, vector<int>& flips) {
    if (!root) return;
    if (root->val != voyage.at(pos)) {
      flips.clear();
      flips.push_back(-1);
      return;
    }
    if (root->left && root->left->val != voyage.at(pos + 1)) {
      swap(root->left, root->right);
      flips.push_back(root->val);
    }
    ++pos;
    solve(root->left, voyage, pos, flips);
    solve(root->right, voyage, pos, flips);   
  }
};

# Author: Huahua, 60 ms
class Solution:
  def flipMatchVoyage(self, root, voyage):
    self.pos = 0
    self.flips = []
    def solve(root):
      if not root: return      
      if root.val != voyage[self.pos]:
        self.flips = [-1]
        return
      if root.left and root.left.val != voyage[self.pos + 1]:
        root.left, root.right = root.right, root.left
        self.flips.append(root.val)
      self.pos += 1
      solve(root.left)
      solve(root.right)    
    solve(root)
    return self.flips

// Author: Huahua
class Solution {
public:
  ListNode *reverseKGroup(ListNode *head, int k) {
    if (!head || k == 1) return head;
    ListNode dummy(0);
    dummy.next = head;
    int len = 1;
    while (head = head->next) len++;
    ListNode* pre = &dummy;    
    for (int l = 0; l + k <= len; l += k) {
      ListNode* cur = pre->next;
      ListNode* nxt = cur->next;
      for (int i = 1; i < k; ++i) {
        cur->next = nxt->next;
        nxt->next = pre->next;
        pre->next = nxt;
        nxt = cur->next;
      }
      pre = cur;
    }
    return dummy.next;
  }
};

// Author: Huahua
class Solution {
public:
  ListNode *swapPairs(ListNode *head) {
    if (!head || !head->next) return head;    

    ListNode d(0);
    d.next = head;
    head = &d;

    while (head && head->next && head->next->next) {
      auto n1 = head->next;
      auto n2 = n1->next;

      n1->next = n2->next;
      n2->next = n1;

      head->next = n2;
      head = n1;
    }
    return d.next;
  }
};

class Solution:
  def swapPairs(self, head):
    if not head or not head.next: return head
    dummy = ListNode(0)
    dummy.next = head
    head = dummy
    while head.next and head.next.next:
      n1, n2 = head.next, head.next.next
      n1.next = n2.next
      n2.next = n1
      head.next = n2      
      head = n1
    return dummy.next