每日算法:回文子串

开发 前端 算法
给定一个字符串,你的任务是计算这个字符串中有多少个回文子串。具有不同开始位置或结束位置的子串,即使是由相同的字符组成,也会被视作不同的子串。

[[434467]]

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

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

示例 1:

  1. 输入:"abc" 
  2.  
  3. 输出:3 
  4.  
  5. 解释:三个回文子串: "a""b""c" 

示例 2:

  1. 输入:"aaa" 
  2.  
  3. 输出:6 
  4.  
  5. 解释:6个回文子串: "a""a""a""aa""aa""aaa" 

提示:

  • 输入的字符串长度不会超过 1000 。

解法一:暴力法

  1. let countSubstrings = function(s) { 
  2.   let count = 0 
  3.   for (let i = 0; i < s.length; i++) { 
  4.     for (let j = i; j < s.length; j++) { 
  5.       if (isPalindrome(s.substring(i, j + 1))) { 
  6.         count++ 
  7.       } 
  8.     } 
  9.   } 
  10.   return count 
  11.  
  12. let isPalindrome = function(s) { 
  13.   let i = 0, j = s.length - 1 
  14.   while (i < j) { 
  15.     if (s[i] != s[j]) return false 
  16.     i++ 
  17.     j-- 
  18.   } 
  19.   return true 

复杂度分析:

  • 时间复杂度:O(n3)
  • 空间复杂度:O(1)

解法二:动态规划

一个字符串是回文串,它的首尾字符相同,且剩余子串也是一个回文串。其中,剩余子串是否为回文串,就是规模小一点的子问题,它的结果影响大问题的结果。

我们怎么去描述子问题呢?

显然,一个子串由两端的 i 、j 指针确定,就是描述子问题的变量,子串 s[i...j] ( dp[i][j] ) 是否是回文串,就是子问题。

我们用二维数组记录计算过的子问题的结果,从base case出发,像填表一样递推出每个子问题的解。

  1.     j 
  2.     a  a  b  a 
  3. i a ✅ 
  4.   a    ✅   
  5.   b       ✅ 
  6.   a          ✅ 

注意: i<=j ,只需用半张表,竖向扫描

所以:

  1. i === j:dp[i][j]=true 
  2. j - i == 1 && s[i] == s[j]:dp[i][j] = true 
  3. j - i > 1 && s[i] == s[j] && dp[i + 1][j - 1]:dp[i][j] = true 

即:

  1. s[i] == s[j] && (j - i <= 1 || dp[i + 1][j - 1]): dp[i][j]=true 

否则为 false

代码实现:

  1. let countSubstrings = function(s) { 
  2.   const len = s.length 
  3.   let count = 0 
  4.   const dp = new Array(len) 
  5.  
  6.   for (let i = 0; i < len; i++) { 
  7.     dp[i] = new Array(len).fill(false
  8.   } 
  9.   for (let j = 0; j < len; j++) { 
  10.     for (let i = 0; i <= j; i++) { 
  11.       if (s[i] == s[j] && (j - i <= 1 || dp[i + 1][j - 1])) { 
  12.         dp[i][j] = true 
  13.         count++ 
  14.       } else { 
  15.         dp[i][j] = false 
  16.       } 
  17.     } 
  18.   } 
  19.   return count 

代码实现(优化):

把上图的表格竖向一列看作一维数组,还是竖向扫描,此时仅仅需要将 dp 定义为一维数组即可

  1. let countSubstrings = function(s) { 
  2.   const len = s.length 
  3.   let count = 0 
  4.   const dp = new Array(len) 
  5.  
  6.   for (let j = 0; j < len; j++) { 
  7.     for (let i = 0; i <= j; i++) { 
  8.       if (s[i] === s[j] && (j - i <= 1 || dp[i + 1])) { 
  9.         dp[i] = true 
  10.         count++ 
  11.       } else { 
  12.         dp[i] = false 
  13.       } 
  14.     } 
  15.   } 
  16.   return count

复杂度分析:

  • 时间复杂度:O(n2)
  • 空间复杂度:O(n)

 

leetcode:https://leetcode-cn.com/problems/palindromic-substrings/solution/leetcode647hui-wen-zi-chuan-by-user7746o/

 

责任编辑:武晓燕 来源: 三分钟学前端
相关推荐

2021-09-03 09:41:36

字符串时间复杂度

2021-09-02 09:22:13

算法无重复字符

2021-09-10 08:31:54

翻转字符串单词

2016-12-29 17:14:41

回文串算法代码

2021-10-29 07:25:32

螺旋矩阵整数

2021-09-27 09:18:30

分割回文串循环

2021-08-26 05:08:25

相邻重复项算法

2016-12-29 15:58:00

字符串子串算法

2021-08-30 14:34:10

有效算法字符

2021-10-28 19:33:36

矩阵图像内存

2021-11-19 07:54:40

前端

2020-02-04 18:06:28

千年一遇对称日回文算法

2021-09-30 09:58:14

路径总和二叉树

2021-11-04 09:59:03

动态规划策略

2021-10-26 00:23:26

算法高频元素

2021-09-29 10:19:00

算法平衡二叉树

2021-10-27 10:43:36

数据流中位数偶数

2021-09-08 09:52:34

语言

2017-12-11 13:50:17

LinuxBash子字符串

2021-09-15 07:56:32

二叉树层次遍历
点赞
收藏

51CTO技术栈公众号