logseq_notes/pages/OJ notes/pages/Leetcode Partition-Labels.md

Leetcode Partition-Labels

2022-09-06 13:46

Algorithms:

#algorithm #greedy

Data structures:

#DS #hash_table

Difficulty:

#coding_problems #difficulty_medium

Additional tags:

#leetcode #CS_list_need_practicing

Revisions:

N/A

Links:

• Link to problem

  ---

Problem

You are given a string s. We want to partition the string into as many parts as possible so that each letter appears in at most one part.

Note that the partition is done so that after concatenating all the parts in order, the resultant string should be s.

Return a list of integers representing the size of these parts.

Examples

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.

Example 2:

Input: s = "eccbbbbdec" Output: [10]

Constraints

Thoughts

[!summary] This is a #greedy problem.

Why is it a greedy problem?

Consider this situation:

s: ababc
partition: abab|c

Note that, for every appearance ch, it has be in one interval.

ababc
|-|
 |-|
  |

if the interval for a element b is bigger than a, merge it.

acdcdabb
|----|
 |-|
|
    ||

We have to make interval from one side of string to another, to save space and do it efficiently.

Solution

class Solution {
public:
vector<int> partitionLabels(string s) {
  // greedy hash table, O(N)

  // We don't have to init values, as every element in
  // s must have a value here.
  vector<int> last(26);

  int segEnd = 0, segStart = 0;

  vector<int> ans;

  for (int i = 0, size = s.size(); i < size; i++) {
    last[s[i] - 'a'] = i;
  }

  for (int i = 0, size = s.size(); i < size; i++) {
    segEnd = max(segEnd, last[s[i] - 'a']);

    if (i == segEnd) {
      ans.push_back(segEnd - segStart + 1);
      segStart = segEnd + 1;
    }
  }

  return ans;
}
};