Move from brute-force thinking to an efficient approach using dynamic programming strategy.
You are given a 0-indexed string word.
In one operation, you can pick any index i of word and change word[i] to any lowercase English letter.
Return the minimum number of operations needed to remove all adjacent almost-equal characters from word.
Two characters a and b are almost-equal if a == b or a and b are adjacent in the alphabet.
Example 1:
Input: word = "aaaaa" Output: 2 Explanation: We can change word into "acaca" which does not have any adjacent almost-equal characters. It can be shown that the minimum number of operations needed to remove all adjacent almost-equal characters from word is 2.
Example 2:
Input: word = "abddez" Output: 2 Explanation: We can change word into "ybdoez" which does not have any adjacent almost-equal characters. It can be shown that the minimum number of operations needed to remove all adjacent almost-equal characters from word is 2.
Example 3:
Input: word = "zyxyxyz" Output: 3 Explanation: We can change word into "zaxaxaz" which does not have any adjacent almost-equal characters. It can be shown that the minimum number of operations needed to remove all adjacent almost-equal characters from word is 3.
Constraints:
1 <= word.length <= 100word consists only of lowercase English letters.Problem summary: You are given a 0-indexed string word. In one operation, you can pick any index i of word and change word[i] to any lowercase English letter. Return the minimum number of operations needed to remove all adjacent almost-equal characters from word. Two characters a and b are almost-equal if a == b or a and b are adjacent in the alphabet.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Dynamic Programming · Greedy
"aaaaa"
"abddez"
"zyxyxyz"
minimum-changes-to-make-alternating-binary-string)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #2957: Remove Adjacent Almost-Equal Characters
class Solution {
public int removeAlmostEqualCharacters(String word) {
int ans = 0, n = word.length();
for (int i = 1; i < n; ++i) {
if (Math.abs(word.charAt(i) - word.charAt(i - 1)) < 2) {
++ans;
++i;
}
}
return ans;
}
}
// Accepted solution for LeetCode #2957: Remove Adjacent Almost-Equal Characters
func removeAlmostEqualCharacters(word string) (ans int) {
for i := 1; i < len(word); i++ {
if abs(int(word[i])-int(word[i-1])) < 2 {
ans++
i++
}
}
return
}
func abs(x int) int {
if x < 0 {
return -x
}
return x
}
# Accepted solution for LeetCode #2957: Remove Adjacent Almost-Equal Characters
class Solution:
def removeAlmostEqualCharacters(self, word: str) -> int:
ans = 0
i, n = 1, len(word)
while i < n:
if abs(ord(word[i]) - ord(word[i - 1])) < 2:
ans += 1
i += 2
else:
i += 1
return ans
// Accepted solution for LeetCode #2957: Remove Adjacent Almost-Equal Characters
// Rust example auto-generated from java reference.
// Replace the signature and local types with the exact LeetCode harness for this problem.
impl Solution {
pub fn rust_example() {
// Port the logic from the reference block below.
}
}
// Reference (java):
// // Accepted solution for LeetCode #2957: Remove Adjacent Almost-Equal Characters
// class Solution {
// public int removeAlmostEqualCharacters(String word) {
// int ans = 0, n = word.length();
// for (int i = 1; i < n; ++i) {
// if (Math.abs(word.charAt(i) - word.charAt(i - 1)) < 2) {
// ++ans;
// ++i;
// }
// }
// return ans;
// }
// }
// Accepted solution for LeetCode #2957: Remove Adjacent Almost-Equal Characters
function removeAlmostEqualCharacters(word: string): number {
let ans = 0;
for (let i = 1; i < word.length; ++i) {
if (Math.abs(word.charCodeAt(i) - word.charCodeAt(i - 1)) < 2) {
++ans;
++i;
}
}
return ans;
}
Use this to step through a reusable interview workflow for this problem.
Pure recursion explores every possible choice at each step. With two choices per state (take or skip), the decision tree has 2ⁿ leaves. The recursion stack uses O(n) space. Many subproblems are recomputed exponentially many times.
Each cell in the DP table is computed exactly once from previously solved subproblems. The table dimensions determine both time and space. Look for the state variables — each unique combination of state values is one cell. Often a rolling array can reduce space by one dimension.
Review these before coding to avoid predictable interview regressions.
Wrong move: An incomplete state merges distinct subproblems and caches incorrect answers.
Usually fails on: Correctness breaks on cases that differ only in hidden state.
Fix: Define state so each unique subproblem maps to one DP cell.
Wrong move: Locally optimal choices may fail globally.
Usually fails on: Counterexamples appear on crafted input orderings.
Fix: Verify with exchange argument or monotonic objective before committing.