Given a string `s`

, a *k* *duplicate removal* consists of choosing `k`

adjacent and equal letters from `s`

and removing them causing the left and the right side of the deleted substring to concatenate together.

We repeatedly make `k`

duplicate removals on `s`

until we no longer can.

Return the final string after all such duplicate removals have been made.

It is guaranteed that the answer is unique.

**Example 1:**

```
Input: s = "abcd", k = 2
Output: "abcd"
Explanation: There's nothing to delete.
```

**Example 2:**

```
Input: s = "deeedbbcccbdaa", k = 3
Output: "aa"
Explanation:
First delete "eee" and "ccc", get "ddbbbdaa"
Then delete "bbb", get "dddaa"
Finally delete "ddd", get "aa"
```

**Example 3:**

```
Input: s = "pbbcggttciiippooaais", k = 2
Output: "ps"
```

**Constraints:**

`1 <= s.length <= 10^5`

`2 <= k <= 10^4`

`s`

only contains lower case English letters.

**Solution:**

Iterate from left to right, maintain a cound of how many consecutive chars we have at position i and a result string. Whenever the count reaches k we remove k elements.

```
class Solution {
public:
string removeDuplicates(string s, int k) {
string cur = "";
vector<int> dp(s.size()+1, 0);
for(int i = 1; i<=s.size();i++){
if(cur.empty()){
cur += s[i-1];
dp[i] = 1;
}else{
if(cur[cur.size()-1] == s[i-1]){
cur += s[i-1];
dp[cur.size()] = dp[cur.size()-1]+1;
if(dp[cur.size()] == k){
cur = cur.substr(0,cur.size()-k);
}
}else{
cur += s[i-1];
dp[cur.size()] = 1;
}
}
// cout<<cur<<" "<<dp[cur.size()]<<"\n";
}
return cur;
}
};
```