删除部分字符使字符串对称

给定一个字符串和最多能进行删除操作的次数，怎样用最少的删除操作才能使该字符串对称（这也使结果字符串变的最长了），即成为palindrome？

例如一个字符串s = "abcbdda"，我们可以删除"dd"获得"abcba"使得s变为palindrome

很容易想到DFS（回溯）的方法：

（1）从左边i和右边j同时扫描字符串，直到两个指针相遇或出现两字符不同，即i >= j || s[i] != s[j]

（2）如果指针相遇之前所有字符都相同，即i >= j，则字符串必然是对称的；如果遇到两个不同的字符，即出现s[i]  != s[j]，则我们可以试着删除s[i]或者s[j]，并且看两种操作那种可以获得更优的结果，这样我们将原问题的最优解转化为两个规模更小的子问题的最优解

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int compareInt(const void* p, const void* q)
{
    return *(int*)p - *(int*)q;
}
int isPalindrome(const char* s, int i, int j)
{
    for(; i < j; ++i, --j){
        if(s[i] != s[j]) return 0;
    }
    return 1;
}
int helper(const char* src, int i, int j, int* indexToDelete, int maxDeletion)
{
    if(i >= j) return 0;
    
    int res = 0, tmp = 0;
    while(i < j){
        if(src[i] == src[j]) ++i, --j;
        else if(maxDeletion > 0){
            res = helper(src, i + 1, j, indexToDelete + 1, maxDeletion - 1);
            tmp = helper(src, i, j - 1, indexToDelete + 1, maxDeletion - 1);
            if(res < 0){
                if(tmp < 0) return -1;
                else{
                    res = tmp;
                    *indexToDelete = j;
                }
            }
            else if(tmp >= 0 && res > tmp) {
                res = tmp;
                *indexToDelete = j;
            }
            else *indexToDelete = i;
            ++res;
            break;
        }
        else return -1;
    }
    return res;
}
int makePalindrome(char* des, const char* src, int maxDeletion)
{
    if(maxDeletion > 0){
        int len = strlen(src), indexToDelete[maxDeletion];
        int n = helper(src, 0, len - 1, indexToDelete, maxDeletion);
        if(n == 0) strcpy(des, src);
        else if(n > 0){
            qsort(indexToDelete, n, sizeof(int), compareInt);
            int i = 0, j = 0, k = 0;
            for(; i < len; ++i){
                if(k < n && i == indexToDelete[k]) ++k;
                else des[j++] = src[i];
            }
            des[j] = '\0';
        }
        return n;
    }
    else if(isPalindrome(src, 0, strlen(src) - 1)){
        strcpy(des, src);
        return 0;
    }
    
    return -1;
}

int main()
{
    char src[] = "abcbdda", des[sizeof(src)];
    int maxDeletion = 3, deletion = makePalindrome(des, src, maxDeletion);
    if(deletion < 0) 
        printf("\"%s\" can not be made palindrome by %d deletions\n", src, maxDeletion);
    else
        printf("\"%s\" can be made palindrome \"%s\" by %d deletions\n", src, des, deletion);
    
    return 0;
}

上述算法是一定能找到最优解的，但算法时间复杂度呈指数型增长、空间复杂度呈线性增长（与递归深度呈正比），因此当maxDeletion较大且原字符串偏离palindrome较多时，上述算法很难达到复杂度的要求。

实际上，顺推一下我们可以这样：令f(i,j)表示将子字符串s[i,j]变为palindrome所需要的最少删除操作，则

当s[i] != s[j]时，f(i,j) = min(f(i,j-1), f(i+1,j))

当s[i] ==s[j]时，f(i,j) = f(i-1,j-1)

而且我们有f(i,i) = 0, f(i,i+1) = s[i] != s[j]，感觉DP已经要出来了：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int makePalindrome(char* des, const char* src, int maxDeletion)
{
    int i, j, len = strlen(src), n = sizeof(int) * len;
    //allocate space and initialize
    int** f = (int**)malloc(sizeof(int*) * len);
    for(i = 0; i < len; ++i){
        f[i] = (int*)malloc(n);
        for(j = 0; j < len; ++j) f[i][j] = len;
        f[i][i] = 0;
    }
    for(i = 1; i < len; ++i) f[i-1][i] = src[i-1] != src[i];
    //DP
#define min(a,b) ((a) < (b) ? (a) : (b))
    for(n = 3; n <= len; ++n){
        for(i = 0; i + n <= len; ++i){
            j = i + n - 1;
            if(src[i] == src[j]) f[i][j] = f[i+1][j-1];
            f[i][j] = min(f[i][j], min(f[i][j-1], f[i+1][j]) + 1);
        }
    }
    if(f[0][len-1] == len || f[0][len-1] <= maxDeletion){
        //backward deduce, des has length of len - f[0][len-1]
        n = f[0][len-1];
        char* p = des, *q = des + len - n - 1;
        q[1] = '\0';
        for(i = 0, j = len - 1; i <= j; ){
            if(f[i][j] == f[i+1][j] + 1){//delete s[i], reserve s[j]
                ++i;
            }
            else if(f[i][j] == f[i][j-1] + 1){//delete s[j], reserve s[i]
                --j;
            }
            else{//reserve s[i] and s[j]
                *p++ = src[i++];
                *q-- = src[j--];
            }
        }
    }
    else n = -1;
    //free space
    for(i = 0; i < len; ++i) free(f[i]);
    free(f);
    return n;
}

int main()
{
    char src[] = "abcbdda", des[sizeof(src)];
    int maxDeletion = 3, deletion = makePalindrome(des, src, maxDeletion);
    if(deletion < 0) 
        printf("\"%s\" can not be made palindrome by %d deletions\n", src, maxDeletion);
    else
        printf("\"%s\" can be made palindrome \"%s\" by %d deletions\n", src, des, deletion);
    
    return 0;
}

上述DP算法时间和空间复杂度都是O(n*n), n = strlen(s)，如果不需要求出最长的对称字符串，而只需要知道经过几次删除操作能使原字符串变为palindrome，则由于f[i][j]仅与f[i+1][j]、f[i][j-1]、f[i+1][j-1]有关，可以使用滚动数组使空间复杂度进一步降低到O(n)