最长回文子序列 -- C语言

需求

 给定一个字符串s，找到其中最长的回文子序列。可以假设s的最大长度为1000。
 
 示例 1:
 输入:
 
 "bbbab"
 输出: 
 4
 一个可能的最长回文子序列为 "bbbb"。
 
 示例 2:
 输入:
 
 "cbbd"
 输出: 
 2
 一个可能的最长回文子序列为 "bb"。

 

思路

• 动态规划，四要素

状态

f[i][j] 表示 s 的第 i 个字符到第 j 个字符组成的子串中，最长的回文序列长度是多少。

转移方程

• 如果 s 的第 i 个字符和第 j 个字符相同的话

f[i][j] = f[i + 1][j - 1] + 2

• 如果 s 的第 i 个字符和第 j 个字符不同的话

f[i][j] = max(f[i + 1][j], f[i][j - 1])

然后注意遍历顺序，i 从最后一个字符开始往前遍历，j 从 i + 1 开始往后遍历，这样可以保证每个子问题都已经算好了。

初始化

f[i][i] = 1 单个字符的最长回文序列是 1

结果

f[0][n - 1]

 

代码实现

/*
 * 需求
 
 给定一个字符串s，找到其中最长的回文子序列。可以假设s的最大长度为1000。
 
 示例 1:
 输入:
 
 "bbbab"
 输出: 
 4
 一个可能的最长回文子序列为 "bbbb"。
 
 示例 2:
 输入:
 
 "cbbd"
 输出: 
 2
 一个可能的最长回文子序列为 "bb"。
 
  
 gcc LongestPalindromeSubseq.c -g -o a.exe -DDEBUG

 */
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

#ifdef DEBUG
#define LOG(fmt, args...) fprintf(stdout, fmt, ##args)
#define BREAKER(a, b, c) breaker(a, b, c)
#else
#define LOG(fmt,...)
#define BREAKER(a, b, c)
#endif

#define TRUE        1
#define FALSE       0

#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) > (b) ? (b) : (a))

#define _MUL_OVERFLOW(a, b) (((a) * (b)) / (b) != (a))
#define MUL_OVERFLOW(a, b)  (((b) == 0) ? FALSE : _MUL_OVERFLOW(a, b))

#define IN_RANGE(v, a, b)   ((v) >= (a) && (v) < (b))

#define ARRAY2_VALID_INDEX(arr, r, c)   \
    (IN_RANGE(r, 0, (arr)->size.row) && IN_RANGE(c, 0, (arr)->size.col))

#define ARRAY2_VALID_POS(arr, pos)    ARRAY2_VALID_INDEX(arr, (pos)->row, (pos)->col)

#define ARRAY2_VAL(arr, row, col) (arr)->p[row][col]
#define ARRAY2_VAL_P(arr, pos) (arr)->p[(pos)->row][(pos)->col]


#define SIZE	1000

int longestPalindromeSubseq(char * s){
	if(NULL == s){
		return 0;
	}

	int f[SIZE][SIZE];		/*最长子串记录表*/
	int len = strlen(s);
	int i = 0, j = 0;

	/*
	 * 遍历顺序需要 i 从后向前遍历，j在i后面，从i+1...n-1;
	 * 因为当前的顺序需要在更短的范围内结果的基础上计算
	 * (更短范围的序号都大于i，在i后面)，
	 * 所以，后面j的子串需要从最小变到最大，所以需要i从后向前遍历
	 */
	for(i = len - 1; i >= 0; i--){
		LOG("\n====== i = %d, j = %d len = %d==========\n", i, j, len);
		f[i][i] = 1; /*默认最小为1，因为1个字母也可能是回文串*/
		LOG("\t init f[%d][%d] = %d\n", i, j , f[i][j]);
		for(j = i + 1; j <= len - 1; j++){
			LOG("\t --------i = %d, j = %d len - 1 = %d--------\n", i, j, len - 1);
			if(s[i] == s[j]) { /*相同的话，原有最长可能上又多了两个字母*/			
				LOG("\t\t same f[i+1][j-1] = %d\n", f[i+1][j-1]);
				f[i][j] = f[i+1][j-1] + 2;
				LOG("\t\t same f[%d][%d] = %d\n", i, j , f[i][j]);				
			} else { /*不相同，看扩展出来的最大子串的值[i, j-1]和[i+1,j]，取最大的*/
				/*
				 * 注意：
				 * 因为 j 是从小到大增长，所以在计算 f[i][j] 的时候，f[i][j-1]一定存在
				 * 因为 i 是从大到小增长，所以在计算 f[i][j] 的时候，f[i+1][j]一定存在
				 * 这也是为什么循环顺序要求 i 从最大开始向前遍历的原因，
				 * 需要先有短串的值，再有长串的值，i越小，起始越靠前，串越长
			 	 */
				f[i][j] = MAX(f[i][j-1], f[i+1][j]);
			}
		}
	}
	
	return f[0][len -1];
	
}


void testlongestPalindromeSubseq(void){
	
	printf("\n************  testlongestPalindromeSubseq ************ \n");
	char str[100] = "bbbab";
	char str1[100] = "aa";
	int len = 0;

	/*testcase 1*/
	len = longestPalindromeSubseq(str);
	printf("The longest Palindrome of %s is %d\n", str,len);

	/*testcase 2*/
	len = longestPalindromeSubseq(str1);
	printf("The longest Palindrome of %s is %d\n", str1,len);


	return; 
}


 int main(int argc, char ** argv){
	testlongestPalindromeSubseq();
 }

代码编译

gcc LongestPalindromeSubseq.c -g -o a.exe -DDEBUG

调试输出

************  testlongestPalindromeSubseq ************

====== i = 4, j = 0 len = 5==========
         init f[4][0] = 0

====== i = 3, j = 5 len = 5==========
         init f[3][5] = 0
         --------i = 3, j = 4 len - 1 = 4--------

====== i = 2, j = 5 len = 5==========
         init f[2][5] = 0
         --------i = 2, j = 3 len - 1 = 4--------
         --------i = 2, j = 4 len - 1 = 4--------
                 same f[i+1][j-1] = 1
                 same f[2][4] = 3

====== i = 1, j = 5 len = 5==========
         init f[1][5] = 0
         --------i = 1, j = 2 len - 1 = 4--------
                 same f[i+1][j-1] = 0
                 same f[1][2] = 2
         --------i = 1, j = 3 len - 1 = 4--------
         --------i = 1, j = 4 len - 1 = 4--------
                 same f[i+1][j-1] = 1
                 same f[1][4] = 3

====== i = 0, j = 5 len = 5==========
         init f[0][5] = 0
         --------i = 0, j = 1 len - 1 = 4--------
                 same f[i+1][j-1] = 0
                 same f[0][1] = 2
         --------i = 0, j = 2 len - 1 = 4--------
                 same f[i+1][j-1] = 1
                 same f[0][2] = 3
         --------i = 0, j = 3 len - 1 = 4--------
         --------i = 0, j = 4 len - 1 = 4--------
                 same f[i+1][j-1] = 2
                 same f[0][4] = 4
The longest Palindrome of bbbab is 4

====== i = 1, j = 0 len = 2==========
         init f[1][0] = 0

====== i = 0, j = 2 len = 2==========
         init f[0][2] = 3
         --------i = 0, j = 1 len - 1 = 1--------
                 same f[i+1][j-1] = 0
                 same f[0][1] = 2
The longest Palindrome of aa is 2