Canine poetry
Contest: Good Bye 2020
Difficulty rating: 1300
Tags: dp, greedy, strings

After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.

Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.

We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string $$$a$$$ is a substring of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.

Unfortunately, Cerberus dislikes palindromes of length greater than $$$1$$$. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.

Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than $$$1$$$.

Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than $$$1$$$.

Input format:
The first line of the input contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^5$$$) denoting the number of test cases, then $$$t$$$ test cases follow.

The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.

The sum of the length of Orpheus' poems in all test cases will not exceed $$$10^5$$$.

Output format:
You should output $$$t$$$ lines, $$$i$$$-th line should contain a single integer, answer to the $$$i$$$-th test case.

Constraints:
Time limit: 2.0 s
Memory limit: 256.0 MB

Note:
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.

In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.

In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there.

Example input:
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a

Example output:
1
1
0
1
1
4
0

Editorial:
The main observation is that if there exists a palindrome of length larger than $$$3$$$, then there exists a palindrome of length $$$2$$$ or $$$3$$$. This observation allows us to simplify the task to erasing all palindromes of length $$$2$$$ or $$$3$$$. We can also notice that each character will be replaced at most once.
From now on, there are a few possible solutions. The easiest one is to iterate over a word from left to right. When we encounter a palindrome (of length $$$2$$$ or $$$3$$$) ending on the current position, consisting of unmarked elements, we greedily mark this character as the one we want to replace. The number of marked characters is the answer, as it turns out that we can obtain a valid palindrome-less sequence by replacing only the letters on the marked positions. The complexity is $$$\mathcal{O}(n)$$$.
The sketch of proof is as follows: it is sufficient to ensure that each marked character does not coincide with $$$4$$$ neighboring characters, so we are still left with $$$22$$$ remaining possibilities.
We can try different approaches too. One of these is a $$$dp$$$-based solution, where the state $$$dp[i][c_a][c_b]$$$ denotes the minimal result after analyzing first $$$i$$$ elements, where characters $$$s_i$$$ and $$$s_{i - 1}$$$ are equal to $$$c_a$$$ and $$$c_b$$$ respectively. This $$$dp$$$ can be implemented in $$$\mathcal{O}(n \cdot 26^2)$$$, which should pass, but is pretty messy to implement, so we want to improve it.
We can notice that we are not interested in the last $$$2$$$ characters' exact values, but only if these were changed or not (the same observation as in the greedy solution). Thanks to this, our state changes to $$$dp[i][c_i][c_{i - 1}]$$$, where $$$c_i$$$ encodes whether $$$i$$$-th character was changed. This $$$dp$$$ can be cleanly implemented in linear time.