leetcode 647. 回文子串动态规划

原创已于 2023-12-17 11:40:41 修改 · 134 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #动态规划 #算法

于 2023-10-28 11:54:49 首次发布

博客围绕计算字符串中回文子串数量展开，指出具有不同开始或结束位置的子串，即便字符相同也视为不同子串，并给出示例，输入'abc'，输出为 3，即三个回文子串 'a'、'b'、'c'。

给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。

具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

示例 1：

输入："abc"
输出：3
解释：三个回文子串: "a", "b", "c"

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

#define min(a, b) (((a) > (b)) ? (b) : (a))

int maxLen(char* str1, int strSize1){
    int dp[strSize1+1][2];
    int result=0;
    for (int i = strSize1-1; i >= 0; --i) {
        for (int j = i; j < strSize1; ++j) {
            if (str1[i] == str1[j] && (j - i <= 1 || dp[i + 1][j - 1])){
                result++;
                dp[i][j]=1;    //如果相等则i-j范围内是回文串
            }
        }
    }
    printf("%d ",result);

}
int main()
{
    char str1[]="abc";
    maxLen(str1,3);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>    //填空
#include "string.h"

typedef struct node{
    int n;
    struct node *next;   //填空
}Node;
void show(Node *head){
    while (head){
        printf("%d ",head->n);
        head = head->next;
    }
    printf("\n");
}
Node *newNode(int n,Node *next){
    Node *node=(Node *)malloc(sizeof(Node));  //填空
    node->n=n;
    node->next=next;  //填空
    return node;
}
Node *newList(int a[],int n){
    int i;
    Node *head = NULL,*tail;
    for (int i = 0; i < n; ++i) {
        Node *t = newNode(a[i],NULL);     //填空
        if (head == NULL)   //填空
            head=t;      //填空
        else
            tail->next=t;
        tail = t;
    }
    return head;
}
Node *delete(Node *head){
    Node *p=head,*q;
    while (p && p->next){
        if (p->n != p->next->n)
            p=p->next;
        else
            p->next = p->next->next;     //填空
    }
    return head;
}
int main(){
    int data[]={1,1,2,2,3,3,4,4,5,5,6,6};
    int n = sizeof(data) / sizeof(int);
    Node *head = newList(data,n);     //填空
    head = delete(head);
    show(head);
    return 0;
}