时间复杂度：O(n)
空间复杂度：O(1) // no extra space used except for output

class Solution {
public:
  vector<int> pivotArray(vector<int>& nums, int pivot) {
    vector<int> ans;
    for (int x: nums)
      if (x < pivot) ans.push_back(x);
    for (int x : nums)
      if (x == pivot) ans.push_back(x);
    for (int x : nums)
      if (x > pivot) ans.push_back(x);
    return ans;
  }
};

You are given a string s containing lowercase letters and an integer k. You need to :

• First, change some characters of s to other lowercase English letters.
• Then divide s into k non-empty disjoint substrings such that each substring is palindrome.

Return the minimal number of characters that you need to change to divide the string.

Example 1:

Input: s = "abc", k = 2
Output: 1
Explanation: You can split the string into "ab" and "c", and change 1 character in "ab" to make it palindrome.

Example 2:

Input: s = "aabbc", k = 3
Output: 0
Explanation: You can split the string into "aa", "bb" and "c", all of them are palindrome.

Example 3:

Input: s = "leetcode", k = 8
Output: 0

Constraints:

• 1 <= k <= s.length <= 100.
• s only contains lowercase English letters.

Solution: DP

dp[i][k] := min changes to make s[0~i] into k palindromes
dp[i][k] = min(dp[j][k – 1] + cost(j + 1, i)) 0 <= j < i

ans = dp[n-1][K]

Time complexity: O(n^2 * K) = O(n^3)
Space complexity: O(n*n + n*K) = O(n^2)

// Author: Huahua, 8 ms, 9.1 MB
class Solution {
public:
  int palindromePartition(string s, int K) {
    const int n = s.length();
    auto minChange = [&](int i, int j) {
      int c = 0;
      while (i < j) 
        if (s[i++] != s[j--]) ++c;      
      return c;
    };
    vector<vector<int>> cost(n, vector<int>(n));
    for (int i = 0; i < n; ++i)
      for (int j = i + 1; j < n; ++j)
        cost[i][j] = minChange(i, j);

    // dp[i][j] := min changes to make s[0~i] into k palindromes
    vector<vector<int>> dp(n, vector<int>(K + 1, INT_MAX / 2));
    for (int i = 0; i < n; ++i) {      
      dp[i][1] = cost[0][i];
      for (int k = 1; k <= K; ++k)
        for (int j = 0; j < i; ++j)
          dp[i][k] = min(dp[i][k], dp[j][k - 1] + cost[j + 1][i]);        
    }
    return dp[n - 1][K];
  }
};

// Author: Huahua, 4 ms, 9.1MB
class Solution {
public:
  int palindromePartition(string s, int K) {
    const int n = s.length();    
    vector<vector<int>> cost(n, vector<int>(n));
    for (int l = 2; l <= n; ++l)
      for (int i = 0, j = l - 1; j < n; ++i, ++j)
        cost[i][j] = (s[i] != s[j]) + cost[i + 1][j - 1];
    
    vector<vector<int>> dp(n, vector<int>(K + 1, INT_MAX / 2));
    for (int i = 0; i < n; ++i) {      
      dp[i][1] = cost[0][i];
      for (int k = 2; k <= K; ++k)
        for (int j = 0; j < i; ++j)
          dp[i][k] = min(dp[i][k], dp[j][k - 1] + cost[j + 1][i]);        
    }
    return dp[n - 1][K];
  }
};

// Author: Huahua
import functools
class Solution:
  def palindromePartition(self, s: str, K: int) -> int:
    @functools.lru_cache(None)
    def cost(i: int, j: int) -> int:
      if i >= j: return 0
      return cost(i + 1, j - 1) + (1 if s[i] != s[j] else 0)
    
    @functools.lru_cache(None)
    def dp(i: int, k: int) -> int:
      if k == 1: return cost(0, i)
      if k == i + 1: return 0
      if k > i + 1: return 1**9
      return min([dp(j, k - 1) + cost(j + 1, i) for j in range(i)])        
    
    return dp(len(s) - 1, K)

You should preserve the original relative order of the nodes in each of the two partitions.

Example:

Input: head = 1->4->3->2->5->2, x = 3
Output: 1->2->2->4->3->5

Solution: Two dummy heads

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

// Author: Huahua
class Solution {
public:
  ListNode* partition(ListNode* head, int x) {
    ListNode dl(0);
    ListNode dr(0);
    ListNode* l = &dl;
    ListNode* r = &dr;
    while (head) {
      ListNode*& h = (head->val < x) ? l : r;
      h = h->next = head;
      head = head->next;
    }
    r->next = nullptr; // important, to avoid loop
    l->next = dr.next;
    return dl.next;
  }
};

https://leetcode.com/problems/reorder-log-files/description/

You have an array of logs.  Each log is a space delimited string of words.

For each log, the first word in each log is an alphanumeric identifier.  Then, either:

• Each word after the identifier will consist only of lowercase letters, or;
• Each word after the identifier will consist only of digits.

We will call these two varieties of logs letter-logs and digit-logs.  It is guaranteed that each log has at least one word after its identifier.

Reorder the logs so that all of the letter-logs come before any digit-log.  The letter-logs are ordered lexicographically ignoring identifier, with the identifier used in case of ties.  The digit-logs should be put in their original order.

Return the final order of the logs.

Example 1:

Input: ["a1 9 2 3 1","g1 act car","zo4 4 7","ab1 off key dog","a8 act zoo"]
Output: ["g1 act car","a8 act zoo","ab1 off key dog","a1 9 2 3 1","zo4 4 7"]

Note:

1. 0 <= logs.length <= 100
2. 3 <= logs[i].length <= 100
3. logs[i] is guaranteed to have an identifier, and a word after the identifier.

Solution: Partition + Sort

1. partition the array such that all digit logs are after all letter logs
2. sort the letter logs part based on the log content

Time complexity: O(n + aloga)

Space complexity: O(n)

class Solution {
public:
    vector<string> reorderLogFiles(vector<string>& logs) {
      auto alpha_end = std::stable_partition(begin(logs),  end(logs), 
        [](const string& log){ return isalpha(log.back()); });
      std::sort(begin(logs), alpha_end, [](const string& a, const string& b){
        return a.substr(a.find(' ')) < b.substr(b.find(' '));
      });
      return logs;
    }
};

Problem

Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a₁, b₁), (a₂, b₂), …, (a_n, b_n) which makes sum of min(a_i, b_i) for all i from 1 to n as large as possible.

Example 1:

Input: [1,4,3,2]

Output: 4
Explanation: n is 2, and the maximum sum of pairs is 4 = min(1, 2) + min(3, 4).

Note:

1. n is a positive integer, which is in the range of [1, 10000].
2. All the integers in the array will be in the range of [-10000, 10000].

Solution 1: Sorting

Time complexity: O(nlogn)

Space complexity: O(1)

// Author: Huahua
// Running time: 52 ms
class Solution {
public:
  int arrayPairSum(vector<int>& nums) {
    std::sort(nums.begin(), nums.end());
    int ans = 0;
    for(int i = 0; i < nums.size(); i += 2)
        ans += nums[i];
    return ans;
  }
};

Solution 2: HashTable

Time complexity: O(n + max(nums) – min(nums))

Space complexity: O(max(nums) – min(nums))

// Author: Huahua
// Running time: 39 ms
class Solution {
public:
  int arrayPairSum(vector<int>& nums) {
    const int max_val = *max_element(begin(nums), end(nums));
    const int min_val = *min_element(begin(nums), end(nums));
    const int offset = -min_val;
    vector<int> c(max_val - min_val + 1);

    for (int num : nums)
        ++c[num + offset];

    int ans = 0;
    int index = 0;

    int n = min_val;

    while (n <= max_val) {
      if (c[n + offset] == 0) {
        ++n;
        continue;
      }
      ans += (++index & 1) ? n : 0;
      --c[n + offset];
    }
    return ans;
  }
};

Problem

Given a set of N people (numbered 1, 2, ..., N), we would like to split everyone into two groups of any size.

Each person may dislike some other people, and they should not go into the same group.

Formally, if dislikes[i] = [a, b], it means it is not allowed to put the people numbered a and b into the same group.

Return true if and only if it is possible to split everyone into two groups in this way.

Example 1:

Input: N = 4, dislikes = [[1,2],[1,3],[2,4]]
Output: true
Explanation: group1 [1,4], group2 [2,3]

Example 2:

Input: N = 3, dislikes = [[1,2],[1,3],[2,3]]
Output: false

Example 3:

Input: N = 5, dislikes = [[1,2],[2,3],[3,4],[4,5],[1,5]]
Output: false

Note:

1. 1 <= N <= 2000
2. 0 <= dislikes.length <= 10000
3. 1 <= dislikes[i][j] <= N
4. dislikes[i][0] < dislikes[i][1]
5. There does not exist i != j for which dislikes[i] == dislikes[j].

Solution: Graph Coloring

Color a node with one color, and color all it’s disliked nodes with another color, if can not finish return false.

Time complexity: O(V+E)

Space complexity: O(V+E)

// Author: Huahua
// Running time: 96 ms
class Solution {
public:
    bool possibleBipartition(int N, vector<vector<int>>& dislikes) {
      g_ = vector<vector<int>>(N);
      for (const auto& d : dislikes) {
        g_[d[0] - 1].push_back(d[1] - 1);
        g_[d[1] - 1].push_back(d[0] - 1);
      }
      colors_ = vector<int>(N, 0);  // 0: unknown, 1: red, -1: blue
      for (int i = 0; i < N; ++i)
        if (colors_[i] == 0 && !dfs(i, 1)) return false;
      return true;      
    }
private:
  vector<vector<int>> g_;
  vector<int> colors_;
  bool dfs(int cur, int color) {
    colors_[cur] = color;
    for (int nxt : g_[cur]) {
      if (colors_[nxt] == color) return false;      
      if (colors_[nxt] == 0 && !dfs(nxt, -color)) return false;
    }
    return true;
  }
};

// Author: Huahua
// Running time: 100 ms
class Solution {
public:
  bool possibleBipartition(int N, vector<vector<int>>& dislikes) {
    vector<vector<int>> g(N);
    for (const auto& d : dislikes) {
      g[d[0] - 1].push_back(d[1] - 1);
      g[d[1] - 1].push_back(d[0] - 1);
    }
    queue<int> q;
    vector<int> colors(N, 0);  // 0: unknown, 1: red, -1: blue
    for (int i = 0; i < N; ++i) {
      if (colors[i] != 0) continue;
      q.push(i);
      colors[i] = 1;
      while (!q.empty()) {
        int cur = q.front(); q.pop();
        for (int nxt : g[cur]) {
          if (colors[nxt] == colors[cur]) return false;
          if (colors[nxt] != 0) continue;
          colors[nxt] = -colors[cur];
          q.push(nxt);
        }
      }
    }    
    return true;
  }
};

Related Problem

• 花花酱 LeetCode 785. Is Graph Bipartite?

Problem

题目大意：把一个数组分成k个段，求每段平均值和的最大值。

https://leetcode.com/problems/largest-sum-of-averages/description/

We partition a row of numbers A into at most K adjacent (non-empty) groups, then our score is the sum of the average of each group. What is the largest score we can achieve?

Note that our partition must use every number in A, and that scores are not necessarily integers.

Example:
Input: 
A = [9,1,2,3,9]
K = 3
Output: 20
Explanation: 
The best choice is to partition A into [9], [1, 2, 3], [9]. The answer is 9 + (1 + 2 + 3) / 3 + 9 = 20.
We could have also partitioned A into [9, 1], [2], [3, 9], for example.
That partition would lead to a score of 5 + 2 + 6 = 13, which is worse.

Note:

• 1 <= A.length <= 100.
• 1 <= A[i] <= 10000.
• 1 <= K <= A.length.
• Answers within 10^-6 of the correct answer will be accepted as correct.

Idea

DP, use dp[k][i] to denote the largest average sum of partitioning first i elements into k groups.

Init

dp[1][i] = sum(a[0] ~ a[i – 1]) / i, for i in 1, 2, … , n.

Transition

dp[k][i] = max(dp[k – 1][j] + sum(a[j] ~ a[i – 1]) / (i – j)) for j in k – 1,…,i-1.

that is find the best j such that maximize dp[k][i]

largest sum of partitioning first j elements (a[0] ~ a[j – 1]) into k – 1 groups (already computed)

+ average of a[j] ~ a[i – 1] (partition a[j] ~ a[i – 1] into 1 group).

Answer

dp[K][n]

Solution 1: DP

Time complexity: O(kn^2)

Space complexity: O(kn)

// Author: Huahua
// Running time: 9 ms
class Solution {
public:
  double largestSumOfAverages(vector<int>& A, int K) {
    const int n = A.size();
    vector<vector<double>> dp(K + 1, vector<double>(n + 1, 0.0));
    vector<double> sums(n + 1, 0.0);
    for (int i = 1; i <= n; ++i) {
      sums[i] = sums[i - 1] + A[i - 1];
      dp[1][i] = static_cast<double>(sums[i]) / i;
    }
    for (int k = 2; k <= K; ++k)
      for (int i = k; i <= n; ++i)
        for (int j = k - 1; j < i; ++j)
          dp[k][i] = max(dp[k][i], dp[k - 1][j] + (sums[i] - sums[j]) / (i - j));
    return dp[K][n];
  }
};

// Author: Huahua
// Running time: 8 ms
class Solution {
public:
  double largestSumOfAverages(vector<int>& A, int K) {
    const int n = A.size();
    vector<double> dp(n + 1, 0.0);
    vector<double> sums(n + 1, 0.0);
    for (int i = 1; i <= n; ++i) {
      sums[i] = sums[i - 1] + A[i - 1];
      dp[i] = static_cast<double>(sums[i]) / i;
    }
    for (int k = 2; k <= K; ++k) {
      vector<double> tmp(n + 1, 0.0);
      for (int i = k; i <= n; ++i)
        for (int j = k - 1; j < i; ++j)
          tmp[i] = max(tmp[i], dp[j] + (sums[i] - sums[j]) / (i - j));
      dp.swap(tmp);
    }
    return dp[n];
  }
};

Solution 2: DFS + memoriation 

// Author: Huahua
// Running time: 10 ms
class Solution {
public:
  double largestSumOfAverages(vector<int>& A, int K) {
    const int n = A.size();
    m_ = vector<vector<double>>(K + 1, vector<double>(n + 1, 0.0));
    sums_ = vector<double>(n + 1, 0.0);
    for (int i = 1; i <= n; ++i)
      sums_[i] = sums_[i - 1] + A[i - 1];
    return LSA(A, n, K);
  }
private:
  vector<vector<double>> m_;
  vector<double> sums_;
  
  // Largest sum of averages for first n elements in A paritioned into k groups
  double LSA(const vector<int>& A, int n, int k) {
    if (m_[k][n] > 0) return m_[k][n];
    if (k == 1) return sums_[n] / n;
    for (int i = k - 1; i < n; ++i)
      m_[k][n] = max(m_[k][n], LSA(A, i, k - 1) + (sums_[n] - sums_[i]) / (n - i));
    return m_[k][n];
  }
};

题目大意：把字符串分割成尽量多的不重叠子串，输出子串的长度数组。要求相同字符只能出现在一个子串中。

Problem:

A string S of lowercase letters is given. We want to partition this string into as many parts as possible so that each letter appears in at most one part, and return a list of integers representing the size of these parts.

Example 1:

Input: S = "ababcbacadefegdehijhklij"
Output: [9,7,8]
Explanation:
The partition is "ababcbaca", "defegde", "hijhklij".
This is a partition so that each letter appears in at most one part.
A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.

Solution 0: Brute Force

Time complexity: O(n^2)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 15 ms
class Solution {
public:
    vector<int> partitionLabels(string S) {
      vector<int> ans;
      size_t start = 0;
      size_t end = 0;
      for (size_t i = 0; i < S.size(); ++i) {
        end = max(end, S.find_last_of(S[i]));
        if (i == end) {
          ans.push_back(end - start + 1);
          start = end + 1;
        }
      }
      return ans;
    }
};

Python

"""
Author: Huahua
Running time : 48 ms
"""
class Solution:
  def partitionLabels(self, S):
    ans = []
    start, end = 0, 0
    for i in range(len(S)):
      end = max(end, S.rfind(S[i]))
      if i == end:
        ans.append(end - start + 1)
        start = end + 1
    return ans

Solution 1: Greedy

Time complexity: O(n)

Space complexity: O(26/128)

C++

// Author: Huahua
// Running time: 6 ms
class Solution {
public:
    vector<int> partitionLabels(string S) {
      vector<int> last_index(128, 0);
      for (int i = 0; i < S.size(); ++i)
        last_index[S[i]] = i;
      vector<int> ans;
      int start = 0;
      int end = 0;
      for (int i = 0; i < S.size(); ++i) {
        end = max(end, last_index[S[i]]);
        if (i == end) {
          ans.push_back(end - start + 1);
          start = end + 1;
        }
      }
      return ans;
    }
};

Java

// Author: Huahua
// Running time: 16 ms
class Solution {
  public List<Integer> partitionLabels(String S) {
    int lastIndex[] = new int[128];
    for (int i = 0; i < S.length(); ++i)
      lastIndex[(int)S.charAt(i)] = i;
    List<Integer> ans = new ArrayList<>();
    int start = 0;
    int end = 0;
    for (int i = 0; i < S.length(); ++i) {
      end = Math.max(end, lastIndex[(int)S.charAt(i)]);
      if (i == end) {
        ans.add(end - start + 1);
        start = end + 1;
      }
    }
    return ans;
  }
}

Python3

"""
Author: Huahua
Running time: 78 ms
"""
class Solution:
  def partitionLabels(self, S):
    last_index = {}
    for i, ch in enumerate(S):
      last_index[ch] = i
    start = end = 0
    ans = []
    for i, ch in enumerate(S):
      end = max(end, last_index[ch])
      if i == end:
        ans.append(end - start + 1)
        start = end + 1
    return ans

Problem:

Input: 
root = [1, 2, 3], k = 5
Output: [[1],[2],[3],[],[]]
Explanation:
The input and each element of the output are ListNodes, not arrays.
For example, the input root has root.val = 1, root.next.val = 2, \root.next.next.val = 3, and root.next.next.next = null.
The first element output[0] has output[0].val = 1, output[0].next = null.
The last element output[4] is null, but it's string representation as a ListNode is [].

Input: 
root = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 3
Output: [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
Explanation:
The input has been split into consecutive parts with size difference at most 1, and earlier parts are a larger size than the later parts.

// Author: Huahua
// Runtime: 9 ms
class Solution {
public:
    vector<ListNode*> splitListToParts(ListNode* root, int k) {
        int len = 0;
        for (ListNode* head = root; head; head = head->next) ++len;
        vector<ListNode*> ans(k, nullptr);
        int l = len / k;
        int r = len % k;        
        ListNode* head = root;
        ListNode* prev = nullptr;
        for (int i = 0; i < k; ++i, --r) {
            ans[i] = head;
            for (int j = 0; j < l + (r > 0); ++j) {
                prev = head;
                head = head->next;
            }
            if (prev) prev->next = nullptr;
        }
        return ans;
    }
};

Java

// Author: Huahua
// Runtime: 4 ms
class Solution {
    public ListNode[] splitListToParts(ListNode root, int k) {
        ListNode[] ans = new ListNode[k];
        int len = 0;
        for (ListNode head = root; head != null; head = head.next) ++len;
        int l = len / k;
        int r = len % k;
        ListNode prev = null;   
        ListNode head = root;
        for (int i = 0; i < k; ++i, --r) {
            ans[i] = head;
            int part_len = l + ((r > 0) ? 1 : 0);
            for (int j = 0; j < part_len; ++j) {
                prev = head;
                head = head.next;
            }            
            if (prev != null) prev.next = null;
        }
        return ans;
    }
}

Python

"""
Author: Huahua
Runtime: 79 ms
"""
class Solution:
    def splitListToParts(self, root, k):
        total_len = 0
        head = root
        while head:
            total_len += 1
            head = head.next
        
        ans = [None for _ in range(k)]
        
        l, r = total_len // k, total_len % k
        
        prev, head = None, root
        
        for i in range(k):
            ans[i] = head
            for j in range(l + (1 if r > 0 else 0)):
                prev, head = head, head.next
            if prev: prev.next = None
            r -= 1
        
        return ans