notes/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_problem #difficulty-medium 
>
> ##### Additional tags:
>
> #leetcode #CS_list_need_practicing 
>
> ##### Revisions:
>
> N/A

##### Links:

- [Link to problem](https://leetcode.com/problems/partition-labels/)

---

### 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

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