2025-11-14：移除相邻字符后字典序最小的字符串。用go语言，给出一个只包含小写字母的字符串 s。你可以多次（也可以不做任何操作）执行如下步骤：任意选取一对相邻字符，如果这两个字母在字母表中相邻——顺序不限（例如 ‘a’ 与 ‘b’ 或 ‘b’ 与 ‘a’），且字母表循环连接（‘a’ 与 ‘z’ 也视为相邻）——就同时删除这两个字符，剩下的字符自动向左收缩合并。经过任意次这样的删除后，目标是让最终得到的字符串在字典序上尽可能小。字典序按常规定义比较：从左到右找第一个不同字符，字母表靠前者更小；若一个字符串是另一个的前缀，则更短的那个更小。输出能达到的最小字典序字符串。
1 <= s.length <= 250。
s 仅由小写英文字母组成。
输入： s = “zdce”。
输出： “zdce”。
解释：
从字符串中移除 “dc”，剩下 “ze”。
无法对 “ze” 进行更多操作。
然而，由于 “zdce” 的字典序小于 “ze”。因此，经过所有可能的移除后，字典序最小的字符串是 “zdce”。
题目来自力扣3563。
算法步骤详细描述
-
初始化与预处理
- 算法首先计算字符串
s的长度n。 - 创建一个大小为
n x n的二维布尔数组canBeEmpty。这个数组用于记录子串s[i:j+1]（即从索引i到索引j的子串）是否可以通过题目描述的移除操作被完全删除（即变为空字符串）。canBeEmpty[i][j] = true表示该子串可被完全移除。
- 算法首先计算字符串
-
动态规划填充
canBeEmpty表- 填充顺序是从字符串的末尾开始，向前处理较小的子串，逐步扩展到整个字符串。具体来说，索引
i从n-2递减到0，对于每个i，索引j从i+1开始，以步长2递增到n-1（因为每次移除两个字符，只有长度为偶数的子串才有可能被完全移除）。 - 对于每一对
(i, j)，通过以下两种方式判断子串s[i:j+1]是否可被完全移除：- 直接移除两端字符：如果子串两端的字符
s[i]和s[j]在字母表上是相邻的（包括循环相邻，如'a'和'z'），并且它们之间的子串s[i+1:j]已经被判定为可完全移除（即canBeEmpty[i+1][j-1]为true），那么移除中间部分后再移除这对相邻字符，整个子串就可以被清空。此时，将canBeEmpty[i][j]设为true。 - 分割为两个可移除子串：如果存在一个分割点
k（i+1到j-2之间，且步长为2），使得子串s[i:k+1]和s[k+1:j+1]都可以被完全移除（即canBeEmpty[i][k]和canBeEmpty[k+1][j]均为true），那么整个子串s[i:j+1]也可以被移除。算法会检查所有可能的分割点k，一旦找到满足条件的分割点，就将canBeEmpty[i][j]设为true。
- 直接移除两端字符：如果子串两端的字符
- 填充顺序是从字符串的末尾开始，向前处理较小的子串，逐步扩展到整个字符串。具体来说，索引
-
构造最小字典序结果字符串
- 创建一个字符串数组
f，其长度为n+1。f[i]表示从原始字符串的第i个位置开始（即子串s[i:]）到末尾，经过若干次移除操作后能得到的字典序最小的字符串。 - 从字符串末尾开始向前计算（
i从n-1递减到0）：- 基础情况：
f[n]被初始化为空字符串，表示超出字符串末尾的情况。 - 对于每个位置
i，考虑两种可能，并选择字典序更小的结果作为f[i]：- 保留当前字符
s[i]：将s[i]与后面子串的结果f[i+1]拼接起来，形成一种可能的结果。 - 移除从
i开始的某个子串：遍历所有可能的j（j从i+1到n-1，步长为2），如果子串s[i:j+1]可以被完全移除（即canBeEmpty[i][j]为true），那么可以考虑直接跳过这个子串，将后面子串的结果f[j+1]作为当前的可能结果。这是因为移除这个子串不会在结果中留下任何字符。
- 保留当前字符
- 在所有上述可能的结果中，使用字典序比较（从左到右第一个不同字符决定大小，前缀更短的更小），选择最小的那个字符串赋值给
f[i]。
- 基础情况：
- 创建一个字符串数组
-
返回最终结果
- 整个过程的最终结果是
f[0]，它代表了从字符串开头到末尾的整个字符串经过操作后能得到的最小字典序字符串。
- 整个过程的最终结果是
复杂度分析
-
总的时间复杂度：O(n³)。
- 填充
canBeEmpty表需要三层循环：外层循环i为 O(n)，内层循环j为 O(n)，最内层寻找分割点k的循环也是 O(n)。因此这部分是 O(n³)。 - 构造结果字符串
f的过程也需要两层循环：外层循环i为 O(n)，内层循环j为 O(n)。但在每次比较和拼接字符串时，最坏情况下字符串长度可能为 O(n)，因此这部分的时间复杂度也是 O(n³)。 - 综上，算法的总时间复杂度为 O(n³)。
- 填充
-
总的额外空间复杂度：O(n²)。
- 主要用于存储二维数组
canBeEmpty，它占用 O(n²) 的空间。 - 字符串数组
f存储了 n+1 个字符串，在最坏情况下，每个字符串的长度可能为 O(n)，因此存储f也需要 O(n²) 的空间。 - 因此，算法的总空间复杂度为 O(n²)。
- 主要用于存储二维数组
这个算法通过动态规划系统地探索了所有移除可能性，并确保最终得到的是字典序最小的结果。对于题目中约定的字符串长度（n <= 250），O(n³) 的复杂度在可接受范围内。
Go完整代码如下：
package main
import (
"fmt"
)
func isConsecutive(x, y byte) bool {
d := abs(int(x) - int(y))
return d == 1 || d == 25
}
func lexicographicallySmallestString(s string) (ans string) {
n := len(s)
canBeEmpty := make([][]bool, n)
for i := range canBeEmpty {
canBeEmpty[i] = make([]bool, n)
}
for i := n - 2; i >= 0; i-- {
canBeEmpty[i+1][i] = true // 空串
for j := i + 1; j < n; j += 2 {
// 性质 2
if isConsecutive(s[i], s[j]) && canBeEmpty[i+1][j-1] {
canBeEmpty[i][j] = true
continue
}
// 性质 3
for k := i + 1; k < j-1; k += 2 {
if canBeEmpty[i][k] && canBeEmpty[k+1][j] {
canBeEmpty[i][j] = true
break
}
}
}
}
f := make([]string, n+1)
for i := n - 1; i >= 0; i-- {
// 包含 s[i]
res := string(s[i]) + f[i+1]
// 不包含 s[i]，注意 s[i] 不能单独消除，必须和其他字符一起消除
for j := i + 1; j < n; j += 2 {
if canBeEmpty[i][j] { // 消除 s[i] 到 s[j]
res = min(res, f[j+1])
}
}
f[i] = res
}
return f[0]
}
func abs(x int) int {
if x < 0 {
return -x
}
return x
}
func main() {
s := "zdce"
result := lexicographicallySmallestString(s)
fmt.Println(result)
}
Python完整代码如下：
# -*-coding:utf-8-*-
def is_consecutive(x, y):
d = abs(ord(x) - ord(y))
return d == 1 or d == 25
def lexicographically_smallest_string(s):
n = len(s)
# 初始化 can_be_empty 二维数组
can_be_empty = [[False] * n for _ in range(n)]
# 初始化空串情况
for i in range(n - 2, -1, -1):
can_be_empty[i + 1][i] = True # 空串
# 填充 can_be_empty 数组
for i in range(n - 2, -1, -1):
for j in range(i + 1, n, 2):
# 性质 2：如果首尾字符相邻且中间可以清空
if is_consecutive(s[i], s[j]) and (i + 1 > j - 1 or can_be_empty[i + 1][j - 1]):
can_be_empty[i][j] = True
continue
# 性质 3：如果可以被分成两个可清空的子串
for k in range(i + 1, j - 1, 2):
if can_be_empty[i][k] and can_be_empty[k + 1][j]:
can_be_empty[i][j] = True
break
# 初始化 f 数组
f = [""] * (n + 1)
# 从后往前计算 f
for i in range(n - 1, -1, -1):
# 包含 s[i]
res = s[i] + f[i + 1]
# 不包含 s[i]，寻找可以消除的区间
for j in range(i + 1, n, 2):
if can_be_empty[i][j]: # 消除 s[i] 到 s[j]
candidate = f[j + 1]
if candidate < res:
res = candidate
f[i] = res
return f[0]
def abs(x):
return x if x >= 0 else -x
# 测试
if __name__ == "__main__":
s = "zdce"
result = lexicographically_smallest_string(s)
print(result)
C++完整代码如下：
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cmath>
using namespace std;
bool isConsecutive(char x, char y) {
int d = abs(x - y);
return d == 1 || d == 25;
}
string lexicographicallySmallestString(string s) {
int n = s.length();
// 初始化 canBeEmpty 二维数组
vector<vector<bool>> canBeEmpty(n, vector<bool>(n, false));
// 初始化空串情况
for (int i = n - 2; i >= 0; i--) {
canBeEmpty[i + 1][i] = true; // 空串
for (int j = i + 1; j < n; j += 2) {
// 性质 2：如果首尾字符相邻且中间可以清空
if (isConsecutive(s[i], s[j]) && (i + 1 > j - 1 || canBeEmpty[i + 1][j - 1])) {
canBeEmpty[i][j] = true;
continue;
}
// 性质 3：如果可以被分成两个可清空的子串
for (int k = i + 1; k < j - 1; k += 2) {
if (canBeEmpty[i][k] && canBeEmpty[k + 1][j]) {
canBeEmpty[i][j] = true;
break;
}
}
}
}
// 初始化 f 数组
vector<string> f(n + 1);
// 从后往前计算 f
for (int i = n - 1; i >= 0; i--) {
// 包含 s[i]
string res = string(1, s[i]) + f[i + 1];
// 不包含 s[i]，寻找可以消除的区间
for (int j = i + 1; j < n; j += 2) {
if (canBeEmpty[i][j]) { // 消除 s[i] 到 s[j]
string candidate = f[j + 1];
if (candidate < res) {
res = candidate;
}
}
}
f[i] = res;
}
return f[0];
}
int main() {
string s = "zdce";
string result = lexicographicallySmallestString(s);
cout << result << endl;
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
