【LeetCode】分割回文串

The Begin点点关注，收藏不迷路

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

示例 1：

输入：s = “aab”
输出：[[“a”,“a”,“b”],[“aa”,“b”]]

示例 2：

输入：s = “a”
输出：[[“a”]]

提示：

1 <= s.length <= 16
s 仅由小写英文字母组成

// 函数 dfs 用于深度优先搜索，尝试不同的分割方式
void dfs(char* s, int n, int i, int** f, char*** ret, int* retSize, int* retColSize, char** ans, int* ansSize) {
    // 如果已经到达字符串末尾
    if (i == n) {
        // 为当前的分割结果分配内存并复制
        char** tmp = malloc(sizeof(char*) * (*ansSize));
        for (int j = 0; j < (*ansSize); j++) {
            int ansColSize = strlen(ans[j]);
            tmp[j] = malloc(sizeof(char) * (ansColSize + 1));
            strcpy(tmp[j], ans[j]);
        }
        // 将当前分割结果保存到 ret 中
        ret[*retSize] = tmp;
        retColSize[(*retSize)++] = *ansSize;
        return;
    }
    // 遍历从当前位置到字符串末尾的子串
    for (int j = i; j < n; ++j) {
        // 如果当前子串是回文串
        if (f[i][j]) {
            // 分配内存并复制当前子串
            char* sub = malloc(sizeof(char) * (j - i + 2));
            for (int k = i; k <= j; k++) {
                sub[k - i] = s[k];
            }
            sub[j - i + 1] = '\0';
            // 将子串添加到 ans 中
            ans[(*ansSize)++] = sub;
            // 继续递归搜索
            dfs(s, n, j + 1, f, ret, retSize, retColSize, ans, ansSize);
            // 回溯，减少 ans 的大小
            --(*ansSize);
        }
    }
}

// 主函数 partition 用于执行分割操作
char*** partition(char* s, int* returnSize, int** returnColumnSizes) {
    int n = strlen(s);
    int retMaxLen = n * (1 << n);
    // 为返回结果分配内存
    char*** ret = malloc(sizeof(char**) * retMaxLen);
    *returnSize = 0;
    // 为返回的列大小分配内存
    *returnColumnSizes = malloc(sizeof(int) * retMaxLen);
    // 动态分配二维数组 f 用于记录子串是否为回文串
    int* f[n];
    for (int i = 0; i < n; i++) {
        f[i] = malloc(sizeof(int) * n);
        for (int j = 0; j < n; j++) {
            f[i][j] = 1;
        }
    }
    // 计算子串是否为回文串
    for (int i = n - 1; i >= 0; --i) {
        for (int j = i + 1; j < n; ++j) {
            f[i][j] = (s[i] == s[j]) && f[i + 1][j - 1];
        }
    }
    // 用于存储当前的分割结果
    char* ans[n];
    int ansSize = 0;
    // 调用 dfs 函数进行深度优先搜索
    dfs(s, n, 0, f, ret, returnSize, *returnColumnSizes, ans, &ansSize);
    return ret;
}

The End点点关注，收藏不迷路