LeetCode5

最新推荐文章于 2021-06-13 11:39:02 发布

可耳（keer）

最新推荐文章于 2021-06-13 11:39:02 发布

阅读量194

点赞数

分类专栏： LeetCode题库文章标签： leetcode 算法 c语言

本文链接：https://blog.csdn.net/weixin_41938180/article/details/104279812

版权

LeetCode题库专栏收录该内容

13 篇文章 0 订阅

订阅专栏

如果饿了就吃，困了就睡，渴了就喝，人生就太无趣了
本次c代码在Clion编译器中可以跑通，在LeetCode官网不行，本人因准备考研复试才开始c，功力不足，请大家多多包涵，我也在努力修改中……

题源：https://leetcode-cn.com/problems/longest-palindromic-substring

问题描述：最长回文子串

给定一个字符串s，找到 s中最长的回文子串。你可以假设s的最大长度为 1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。

示例 2：

输入: "cbbd"
输出: "bb"

解题思路

1 回文定义

正读和反读都一样的字符串。例如：“aba”,“a”。但是"abca"就不是。

如果一个字符串第1个和最后一个字符不相等，这个字符串一定不是回文
如果一个字符串第一个和最后一个相等，需要在深入判断：
- 如果子串是回文，该字符串就是回文
- 如果子串不是回文，该字符串不是回文

2 暴力匹配（Brute Force）

根据回文的定义，找出所有长度大于2的子串，一次判断是否为回文。
记录最长回文子串时候，将当前寻找的回文，与记录好最长回文进行比较，如果比记录的长度长，就替换原有记录。
记录最长回文只需要记录其起始位置和长度，在方法最后再去截取字符串。

此种方法就是时间复杂度应该在O(N^3)，空间复杂度在O(1)，常数个变量，与字符串长度无关。虽然时间复杂度较高，但是逻辑简单，思路清晰，就不在做过多赘述，直接看看代码吧！

/**
 * 暴力检索
 * @param s
 * @return
 */
char *longestPalindrome1(char *s) {
    int maxlong, flag, num, length;
    int checkPalindrome(char *s, int start, int end);
    length = strlen(s);
    if (length < 2) {
        return s;
    }
    maxlong = flag = 0;
    for (int i = 0; i < length; i++) {
        num = 1;
        for (int j = i + 1; j < length; j++) {
            if (checkPalindrome(s, i, j) == 1) {
                if (num > maxlong) {
                    maxlong = num;
                    flag = i;
                }
            }
            num++;
        }
    }
    char *a = (char *) malloc(sizeof(char) * (maxlong + 2));
    strncpy(a, s + flag, maxlong + 2);
    a[maxlong + 2] = '\0';

    return a;
}

/**
 * 判断字符串是否为回文
 * @param s
 * @param start 起始位置
 * @param end 结束位置
 * @return 是回文返回1，不是返回0
 */
int checkPalindrome(char *s, int start, int end) {
    for (; start <= end;) {
        if (s[start] != s[end]) {
            return 0;
        }
        start++;
        end--;
    }
    return 1;
}

3 动态规划（以"babad"为例）

3.1 定义状态

用二维数组来存储子串是否为回文子串的状态，1表示是回文子串，0表示不是回文子串。

定义state[i][j]二维数组，存储子串s(i,j)是不是回文的状态。
i和j分别表示子串的开始位置和结束位置。
数组大小：s.length*s.length （s.length:字符串长度)

如图1：
在这里插入图片描述

3.2 思考状态转移方程

这道题的状态转移方程，就是如何对state[i][j]进行赋值。
根据1中的对回文的定义和分析，可以得出下面的状态转移方程：

state[i][j]=(s[i]==s[j]) and state[i+1][j-1]

(1)因为i表示的子串的起始位置，j表示的是子串的结束位置，所以 i和j的关系i<=j，因此只需要填写这个表格的上半部分。如图2：红色的位置就不用了填写。
在这里插入图片描述
(2)考虑子串的state[i+1][j-1]边界情况。
边界条件：s(i+1,j-1)的长度大于等于2就行,也就是j-1-(i+1)>=2，化简之后j-i>=3(从0计数)，s(i,j)子串长度是大于等于4的。

当s(i,j)的长度：1时，如图3：都不用判断state[i+1][j-1]，本身自己就是最基础的一个回文串。
当s(i,j)的长度：2时，如图4：如果头尾字符相同，子串s(i+1,j-1)不存在，必然是回文。
当s(i,j)的长度：3时，如图5：如果头尾字符相同，子串s(i+1,j-1)只有一个字符，必然是回文。

结论：在s[i]=s[j]成立和j-i<3的条件下，可以直接将state[i][j]=1

3.3 初始化

初始化state[i][j]时，因为单个字符串一定是回文，所以将对角线上的值全部置1.如图6

在这里插入图片描述

3.4 以`babad`为例，逐步解释。

(1) 如图7：i=0,j=1，头尾字符串不相等，置0
在这里插入图片描述
(2)如图8：i=0,j=2，头尾字符串相等，子串也是回文，置1

(3)如图9：i=1,j=2，头尾字符串不相等，置0

(4)如图10：i=0,j=3，头尾字符串不相等，置0

(5)如图11：i=1,j=3，头尾字符串相等，子串也是回文，置1
在这里插入图片描述
(6)如图12：i=2,j=3，头尾字符串不相等，置0

(7)如图13：i=0,j=4，头尾字符串不相等，置0

(8)如图14：i=1,j=4，头尾字符串不相等，置0

(9)如图15：i=2,j=4，头尾字符串不相等，置0

(10)如图16：i=3,j=4，头尾字符串不相等，置0
在这里插入图片描述

3.5 代码如下

/**
 * 动态规划
 * @param s
 * @return
 */
char *longestPalindrome(char *s) {
    int length = strlen(s);
    if (length < 2) {
        return s;
    }

    int maxlong = 1;
    int start = 0;
    int **a = (int **) malloc(sizeof(int *) * length);
    for (int i = 0; i < length; i++) {
        a[i] = (int *) malloc(sizeof(int) * length);
    }
    for (int i = 0; i < length; i++) {
        a[i][i] = 1;
    }

    for (int j = 1; j < length; j++) {
        for (int i = 0; i < j; i++) {
            if (s[i] == s[j]) {
                if (j - i < 3) {
                    a[i][j] = 1;
                } else {
                    a[i][j] = a[i + 1][j - 1];
                }
            } else {
                a[i][j] = 0;
            }

            if (a[i][j] == 1) {
                int curLen = j - i + 1;
                if (curLen > maxlong) {
                    maxlong = curLen;
                    start = i;
                }
            }
        }
    }
    char *b = (char *) malloc(sizeof(char) * (maxlong));
    strncpy(b, s + start, maxlong);
    b[maxlong] = '\0';
    return b;

}

4 中心扩散

4.1 分析

前两种方法是从头尾向中间计算，中心扩散则是从中间向两边计算。
根据字符串的长度是偶数还是奇数，回文的扩散中心是不一样的。

回文长度是偶数，如图17
回文长度是奇数，如图18

遍历字符串中所有的中心，以babad为例。如图19：边界值小于length-2之后。
在这里插入图片描述

4.2 代码

/**
 * 中心扩散算法
 * @param s
 * @return
 */
char *longestPalindrome(char *s) {
    int len = strlen(s);
    char *centerSpread(char *s, int left, int right);
    if (len < 2) {
        return s;
    }
    int left, right, maxlong = 1;
    char *res;
    for (int i = 0; i < len; i++) {
        char *odd = centerSpread(s, i, i);//偶数
        char *even = centerSpread(s, i, i + 1);//奇数
        char *max;
        if (strlen(odd) > strlen(even)) {
            max = odd;
        } else {
            max = even;
        }

        if (strlen(max) > maxlong) {
            maxlong = strlen(max);
            res = max;
        }
    }
    return res;
}

/**
 * 找出回文
 * @param s
 * @param left
 * @param right
 * @return
 */
char *centerSpread(char *s, int left, int right) {
    int len = strlen(s);
    while (left >= 0 && right < len) {
        if (s[left] == s[right]) {
            left--;
            right++;
        } else {
            break;
        }
    }
    char *a = (char *) malloc(sizeof(char) * (right - (left + 1)));
    strncpy(a, s + left + 1, right - (left + 1));
    a[right - (left + 1)] = '\0';
    return a;
}

可耳（keer）

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode5

如果饿了就吃，困了就睡，渴了就喝，人生就太无趣了本次c代码在Clion编译器中可以跑通，在LeetCode官网不行，本人因准备考研复试才开始c，功力不足，请大家多多包涵，我也在努力修改中……题源：https://leetcode-cn.com/problems/longest-palindromic-substring问题描述：最长回文子串给定一个字符串s，找到 s中最长的回文子串。...
复制链接

扫一扫