最长回文子串 and 最长回文子序列

本文详细介绍了回文子序列的概念及其实现方法,包括最长回文子序列与最长回文子串的递归与动态规划解决方案,并对比了不同算法的时间复杂度。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

欢迎访问https://blog.youkuaiyun.com/lxt_Lucia~~
 

宇宙第一小仙女\(^o^)/~~萌量爆表求带飞=≡Σ((( つ^o^)つ~dalao们点个关注呗~~

 

一、概念

 

1、回文(palindrome)

       回文就是正读和反读都一样的字符串,如aba,abba,abcba等。

2、字符子串和字符子序列的区别

      (1)字符字串指的是字符串中连续的n个字符,如abcdefg中,ab,cde,fg等都属于它的字串。

      (2)字符子序列指的是字符串中不一定连续但先后顺序一致的n个字符,即可以去掉字符串中的部分字符,但不可改变其前后顺序。如abcdefg中,acdg,bdf属于它的子序列,而bac,dbfg则不是,因为它们与字符串的字符顺序不一致。再如cabbeaf,删掉‘c’、'e'、' f '后剩下的子串“abba”就是回文字符串,也是其中最长的回文子序列。

      (3)最长回文子串必须是连续的,而最长回文子序列不一定连续,但不可改变先后顺序。

 

二、最长回文子序列 and 最长回文子串

(一)最长回文子序列 LPS(Longest Palindromic Subsequence)

 

方法一:递归方法

str[0...n-1]是给定的字符串序列,长度为n,假设lps(0,n-1)表示序列str[0...n-1]的最长回文子序列的长度。

1.如果str的最后一个元素和第一个元素是相同的,则有:lps(0,n-1)=lps(1,n-2)+2;例如字符串序列“AABACACBA”,第一个元素和最后一个元素相同,其中lps(1,n-2)表示红色部分的最长回文子序列的长度;

2.如果str的最后一个元素和第一个元素是不相同的,则有:lps(0,n-1)=max(lps(1,n-1),lps(0,n-2));例如字符串序列“ABACACB”,其中lps(1,n-1)表示去掉第一元素的子序列,lps(0,n-2)表示去掉最后一个元素的子序列。

 

 

    #include<iostream>  
    #include<string>  
    #include<algorithm>  
    using namespace std;  
      
    //递归方法,求解最长回文子序列  
    int lps(char *str, int i, int j)  
    {  
        if (i == j)  
            return 1;   //只有一个元素,回文长度为1  
        if (i > j) return 0;   //因为只计算序列str[i....j]  
      
        //如果首尾相同  
        if (str[i] == str[j])  
            return lps(str, i + 1, j - 1) + 2;  
        //如果首尾不同  
        return max(lps(str, i, j - 1), lps(str, i + 1, j));  
    }  
    int main()  
    {  
        char str[] = "cabbeaf";  
        int n = strlen(str);  
        int res = lps(str, 0, n - 1);  
        cout << res<< endl;  
        getchar();  
        return 0;  
    }  

 

重叠子问题

但是通过上面递归的方法,会出现很多重复的计算,比如上面的L(1,4),所以可以采用动态规划的方法求解

 

方法二:动态规划方法

通过自下而上的方式记录子问题的最优解

 

    #include<iostream>  
    #include<algorithm>  
    using namespace std;  

    //动态规划求解最长回文子序列,时间复杂度为O(n^2)  
    int lpsDp(char *str, int n)  
    {  
        int dp[10][10], tmp;  
        memset(dp, 0, sizeof(dp));  
        for (int i = 0; i < n; ++i)  dp[i][i] = 1;  
      
        for (int i = 1; i < n; ++i)  
        {  
            tmp = 0;  
            //考虑所有连续的长度为i+1的子串,str[j....j+i]  
            for (int j = 0; j + i < n; j++)  
            {  
                //如果首尾相同  
                if (str[j] == str[j + i])  
                    tmp = dp[j + 1][j + i - 1] + 2;  
                //如果首尾不同  
                else   
                    tmp = max(dp[j + 1][j + i], dp[j][j + i - 1]);  
                dp[j][j + i] = tmp;  
            }  
        }  
        return dp[0][n - 1]; //返回字符串str[0...n-1]的最长回文子序列长度  
    }  
      
    int main()  
    {  
        char str[10] = "cabbeaf";  
        int res = lpsDp(str, strlen(str));  
        cout << res << endl;  
        getchar();  
        return 0;  
    }  

 

例1:腾讯2016实习笔试编程题

所谓回文字符串,就是一个字符串,从左到右读和从右到左读是完全一样的,比如“aba”、“c”,对于一个字符串,可以通过删除某些字符而变成回文字符串,如“cabebaf”,删除'c'、'e'、‘f’后剩下子串“abba”就是回文字符串。

要求,给定任意一个字符串,字符串最大长度1000,计算出最长的回文字符串长度。

如“cabebaf”的回文串包括“c”、“aba”、“abba”等,最长回文“abba”长度为4。

Input:字符串

Output:最大的回文字符长度。

Exmaple Inuput:

cabbeaf

Exmaple Output:

4

    #include<iostream>  
    #include<algorithm>  
    using namespace std;  
    #define MAXN 1000  
    //动态规划求解最长回文子序列,时间复杂度为O(n^2)  
    int lpsDp(char *str, int n)  
    {  
        int dp[MAXN>>1][MAXN>>1], tmp;  
        memset(dp, 0, sizeof(dp));  
      
        //字符串长度为1,最长回文子序列的长度就是1  
        for (int i = 0; i < n; ++i)  dp[i][i] = 1;  
        for (int i = 1; i < n; ++i)  
        {  
            tmp = 0;  
            //考虑所有连续的长度为i+1的子串,str[j....j+i]  
            for (int j = 0; j + i < n; j++)  
            {  
                //如果首尾相同  
                if (str[j] == str[j + i])  
                    tmp = dp[j + 1][j + i - 1] + 2;  
                //如果首尾不同  
                else   
                    tmp = max(dp[j + 1][j + i], dp[j][j + i - 1]);  
                dp[j][j + i] = tmp;  
            }  
        }  
        return dp[0][n - 1]; //返回字符串str[0...n-1]的最长回文子序列长度  
    }  
    int main()  
    {  
        char str[MAXN];  
        while (cin >> str)  
        {  
            int res = lpsDp(str, strlen(str));  
            cout << res << endl;  
        }  
        getchar();  
        return 0;  
    }  

 

 

例2:求最长回文子序列长度

题意:

 

给定字符串,求它的最长回文子序列长度。回文子序列反转字符顺序后仍然与原序列相同。例如字符串abcdfcba中,最长回文子序列长度为7,abcdcba或abcfcba。

思路:

动态规划思想

对于任意字符串,如果头尾字符相同,那么字符串的最长子序列等于去掉首尾的字符串的最长子序列加上首尾;如果首尾字符不同,则最长子序列等于去掉头的字符串的最长子序列和去掉尾的字符串的最长子序列的较大者。

因此动态规划的状态转移方程为:

设字符串为str,长度为n,p[i][j]表示第i到第j个字符间的子序列的个数(i<=j),则:

状态初始条件:dp[i][i]=1 (i=0:n-1)

状态转移方程:dp[i][j]=dp[i+1][j-1] + 2  if(str[i]==str[j])

                   dp[i][j]=max(dp[i+1][j],dp[i][j-1])  if (str[i]!=str[j])

代码:

以下代码中的两层循环变量i,j的顺序可以改变,但必须满足i<=j的条件。

计算dp[i][j]时需要计算dp[i+1][*]或dp[*][j-1],因此i应该从大到小,即递减;j应该从小到大,即递增。

#include <iostream>
#include <vector>
using namespace std;
int longestPalindromeSubSequence1(string str){
    int n=str.length();
    vector<vector<int> > dp(n,vector<int>(n));

    for(int j=0;j<n;j++){
        dp[j][j]=1;
        for(int i=j-1;i>=0;i--){
            if(str[i]==str[j])
                dp[i][j]=dp[i+1][j-1]+2;
            else
                dp[i][j]=max(dp[i+1][j],dp[i][j-1]);
        }
    }
    return dp[0][n-1];
}
int longestPalindromeSubSequence2(string str){
    int n=str.length();
    vector<vector<int> > dp(n,vector<int>(n));

    for(int i=n-1;i>=0;i--){
        dp[i][i]=1;
        for(int j=i+1;j<n;j++){
            if(str[i]==str[j])
                dp[i][j]=dp[i+1][j-1]+2;
            else
                dp[i][j]=max(dp[i+1][j],dp[i][j-1]);
        }
    }
    return dp[0][n-1];
}
int main()
{
    string s;
    int length;
    while(cin>>s){
        length=longestPalindromeSubSequence2(s);
        cout<<length<<endl;
    }
    return 0;
}

 

image

例3:求回文子序列的个数

 

给定字符串,求它的回文子序列个数。回文子序列反转字符顺序后仍然与原序列相同。例如字符串aba中,回文子序列为"a", "a", "aa", "b", "aba",共5个。内容相同位置不同的子序列算不同的子序列。

思路:

动态规划思想

对于任意字符串,如果头尾字符不相等,则字符串的回文子序列个数就等于去掉头的字符串的回文子序列个数+去掉尾的字符串的回文子序列个数-去掉头尾的字符串的回文子序列个数;如果头尾字符相等,那么除了上述的子序列个数之外,还要加上首尾相等时新增的子序列个数,1+去掉头尾的字符串的回文子序列个数,1指的是加上头尾组成的回文子序列,如aa,bb等。

因此动态规划的状态转移方程为:

设字符串为str,长度为n,p[i][j]表示第i到第j个字符间的最长子序列的长度(i<=j),则:

状态初始条件:dp[i][i]=1 (i=0:n-1)

状态转移方程:dp[i][j]=dp[i+1][j] + dp[i][j-1] - dp[i+1][j-1]  if(str[i]!=str[j])

                   dp[i][j]=dp[i+1][j] + dp[i][j-1] - dp[i+1][j-1]+dp[i+1][j-1]+1=dp[i+1][j] + dp[i][j-1]+1  if (str[i]==str[j])

#include <iostream>
#include <vector>
using namespace std;
int NumOfPalindromeSubSequence(string str){
    int len=str.length();
    vector<vector<int> > dp(len,vector<int>(len));
    for(int j=0;j<len;j++){
        dp[j][j]=1;
        for(int i=j-1;i>=0;i--){
            dp[i][j]=dp[i+1][j]+dp[i][j-1]-dp[i+1][j-1];
            if(str[i]==str[j])
                dp[i][j]+=1+dp[i+1][j-1];
        }
    }
    return dp[0][len-1];
}
int main()
{
    string str;
    int num;
    while(cin>>str){
        num=NumOfPalindromeSubSequence(str);
        cout<<num<<endl;
    }
    return 0;
}

 

image

 

 

 

(二)最长回文子串

 

题目:给定一个字符串s,找出s中的最长回文子串;

暴力法,DP法, 中心扩展法,manacher算法

方法一:暴力法

遍历字符串S的每一个子串,去判断这个子串是不是回文,是回文的话看看长度是不是比最大的长度maxlength大。遍历每一个子串的方法要O(n^2),判断每一个子串是不是回文的时间复杂度是O(n),所以暴利方法的总时间复杂度是O(n^3)。

public static String findLongestPalindrome(String s){
        int len = s.length(); // 字符串长度
        int maxlength = 0;  // 最长回文字符串长度
        int start = 0; // 回文开始的地方
        for(int i = 0; i < len; i++){
            for(int j = i + 1; j < len; j++){
                int index1 = 0;
                int index2 = 0;
                // 对每个子串都从两边开始向中间遍历
                for(index1 = i, index2 = j; index1 < index2; index1 ++, index2--){
                    if(s.charAt(index1) != s.charAt(index2))
                        break;
                }
                // 若index1=index2,表示串是类似于abcba这种类型;若大于,则是abccba这种类型
                if(index1 >= index2 && j - i > maxlength){
                    maxlength = j - i + 1;
                    start = i;
                }
            }

        }
        if(maxlength > 0)
            return s.substring(start, start + maxlength);
        return null;

    }

 

方法二:动态规划

 

回文字符串的子串也是回文,比如P[i,j](表示以i开始以j结束的子串)是回文字符串,那么P[i+1,j-1]也是回文字符串。这样最长回文子串就能分解成一系列子问题了。这样需要额外的空间O(N^2),算法复杂度也是O(N^2)。

首先定义状态方程和转移方程:

P[i,j]=false:表示子串[i,j]不是回文串。P[i,j]=true:表示子串[i,j]是回文串。

P[i,i]=true:当且仅当P[i+1,j-1] = true && (s[i]==s[j])

否则p[i,j] =false;

public static String findLongestPalindrome1(String s){
        int len = s.length();
        int start = 0;
        int maxlength = 0;
        boolean p[][] = new boolean[s.length()][s.length()];
        // 子串长度为1和为2的初始化
        for(int i = 0; i < len; i++){
            p[i][i] = true;
            if(i < len - 1 && s.charAt(i) == s.charAt(i + 1)){
                p[i][i + 1] = true;
                start = i;
                maxlength = 2;
            }
        }
        // 使用上述结果可以dp出子串长度为3~len -1的子串
        for(int strlen = 3; strlen < len; strlen ++){
            for(int i = 0; i <=len - strlen; i++){
                int j = i + strlen - 1; // 子串结束的位置
                if(p[i + 1][j - 1] && s.charAt(i) == s.charAt(j)){
                    p[i][j] = true;
                    maxlength = strlen;
                    start = i;
                }
            }
        }
        if(maxlength > 0)
            return s.substring(start, start + maxlength);
        return null;
    }

 

方法三:中心扩展法

 

 

中心扩展就是把给定的字符串的每一个字母当做中心,向两边扩展,这样来找最长的子回文串。算法复杂度为O(N^2)。

但是要考虑两种情况:

1、像aba,这样长度为奇数。

2、想abba,这样长度为偶数。

public static String findLongestPalindrome2(String s){
        int len = s.length();
        int maxlength = 0;
        int start = 0;
        // 类似于aba这种情况,以i为中心向两边扩展
        for(int i = 0; i < len; i++){
            int j = i - 1;
            int k = i + 1;
            while(j >= 0 && k < len && s.charAt(j) == s.charAt(k)){
                if(k - j + 1 > maxlength){
                    maxlength = k - j + 1;
                    start = j;
                }
                j --;
                k ++;
            }
        }
        // 类似于abba这种情况,以i,i+1为中心向两边扩展
        for(int i = 0; i < len; i++){
            int j = i;
            int k = i + 1;
            while(j >= 0 && k <len && s.charAt(j) == s.charAt(k)){
                if(k - j + 1 > maxlength){
                    maxlength = k - j + 1;
                    start = j;
                }
                j --;
                k ++;
            }
        }
        if(maxlength > 0)
            return s.substring(start, start + maxlength);
        return null;
    }

 

方法四:Manacher算法

 

 

Manacher法只能解决例如aba这样长度为奇数的回文串,对于abba这样的不能解决,于是就在里面添加特殊字符。我是添加了“#”,使abba变为a#b#b#a。这个算法就是利用已有回文串的对称性来计算的,具体算法复杂度为O(N)

详细规则可参考另一篇博客http://blog.sina.com.cn/s/blog_9ca3f6e70102wsb0.html

public static String findLongestPalindrome3(String s) {
        if(s == null || s.length() < 1)
            return "";
        String str = dealWithS(s);  // 处理一下s,即将给字符串s的中间加上特殊字符,这样无论对于奇数字符还是偶数字符可以做同样的处理
        int[] res = new int[str.length()];
        int R = 0; // 当前所能扩展的半径
        int C = 0; // C位置的半径为R
        int maxC= 0; // 最长的半径的位置
        res[0] = 0;
        for(int i = 1; i < str.length(); i++)
        {
            int j = 2 * C - i;  // i点的对称点
            if(j >= 0 && res[j] < R - i)  // 对称点存在且对称点的回文半径在C的回文中
            {
                res[i] = res[j];
            }
            else  // 否则,需要根据i点一点一点的计算
            {
                int k = 1;
                while(R + k < str.length() && 2 * i - R - k >= 0)
                {
                    if(str.charAt(R + k) == str.charAt(2 * i - R - k))
                        k ++;
                    else
                        break;
                }
                res[i] = R -i + k - 1;
                if(res[i] + i > R)
                {
                    R = res[i] + i;
                    C = i;
                }
            }
            maxC = res[maxC] > res[i] ? maxC : i;  // maxC保存的是回文半径最大的那个点的位置
        }
        String subStr = str.substring(maxC - res[maxC], maxC + res[maxC] + 1);
        StringBuffer sb = new StringBuffer();
        for(int i = 0; i < subStr.length(); i++)
        {
            if(subStr.charAt(i) != '#')
                sb.append(subStr.charAt(i));
        }
        return sb.toString();
    }
    public static String dealWithS(String s)  // 将原字符串进行处理
    {
        StringBuffer sb = new StringBuffer();
        sb.append("#");
        for(int i = 0; i < s.length (); i++)
        {
            sb.append(s.charAt(i));
            sb.append("#");
        }
        return sb.toString();
    }

 

 

三.相关知识:( 建议放在一起比较区分 )

1)最长上升子序列  ( LIS )  戳这里

2)最长公共子序列(LCS)戳这里 ~

 

 

 

宇宙第一小仙女\(^o^)/~~萌量爆表求带飞=≡Σ((( つ^o^)つ~dalao们求关注哦~~

 

 

 

 

参考资料:

https://www.cnblogs.com/leavescy/p/5878336.html

https://www.cnblogs.com/AndyJee/p/4465696.html

https://blog.youkuaiyun.com/geekmanong/article/details/51056375

<think>嗯,我现在想了解一下回文子串问题和最长回文子序列的区别。之前学过一些动态规划的知识,但这两个问题好像容易混淆,得仔细理清楚。 首先,回文子串应该是指连续的字符组成的回文,比如“abcba”中的“bcb”就是一个回文子串,对吧?而回文子序列可能不需要连续,只要字符顺序对称就行。比如在“abcda”里,最长回文子序列可能是“acda”或者类似的结构?不过具体例子可能需要再想想。 那它们的定义区别应该就是子串必须连续,子序列可以不连续。所以,在解决这两个问题的时候,算法上会有不同的处理方式。比如,动态规划的状态转移方程可能不一样。 比如回文子串的问题,我记得常用的方法可能是中心扩展法或者动态规划。比如用二维数组dp[i][j]表示从i到j是否为回文子串。如果是的话,当s[i]等于s[j]时,可能要看内部子串是否是回文。比如dp[i][j] = dp[i+1][j-1](当i+1到j-1是回文时)。但如果是子序列的话,可能即使i和j不相等,也要考虑选择左边或右边的结果,比如取dp[i+1][j]和dp[i][j-1]的最大值。 举个例子,最长回文子序列的动态规划解法。根据引用里的代码,当s[i]等于s[j]时,dp[i][j] = dp[i+1][j-1] + 2;如果不相等,则取dp[i+1][j]和dp[i][j-1]中的较大值。这样就能处理非连续的情况。而回文子串的动态规划可能只有当两端字符相等,并且中间子串是回文时,才标记为true,然后统计所有true的情况中的最长长度。 另外,回文子串的问题可能更关注连续的结构,所以像中心扩展法可能更高效,比如遍历每个可能的中心点,向两边扩展直到不匹配为止。而子序列的问题必须用动态规划或者其他方法处理非连续的情况。 还有,两者的应用场景可能不同。比如,子串可能用于查找具体的回文字符串,而子序列可能用于某些需要非连续匹配的场景,比如基因序列分析中的某些结构查找? 另外,时间复杂度上可能有差异。回文子串的动态规划解法是O(n²),而子序列的动态规划应该也是O(n²),但具体操作步骤可能不同。比如,子序列的dp数组填充可能需要特定的遍历顺序,比如i从后往前,j从i+1开始往后,像引用中的代码那样。 比如引用中的代码,最长回文子序列的动态规划解法中,循环是i从最后一个字符往前,j从i+1开始往后。这是因为计算dp[i][j]时需要先知道dp[i+1][j-1]、dp[i+1][j]、dp[i][j-1]的值,所以必须按这种顺序填充。 而回文子串的动态规划可能需要i从后往前,j从i到末尾,但判断条件更严格,需要s[i]==s[j]并且dp[i+1][j-1]为true。 总结起来,两者的主要区别在于子串要求连续,而子序列不要求。因此在动态规划的状态转移方程中,当两端字符不相同时,子序列需要取两边选择后的最大值,而子串则直接跳过这种情况,因为不连续的话无法形成更长的子串。 可能还需要注意边界条件的不同。例如,子序列的单个字符都是长度为1的回文,所以在初始化时每个dp[i][i] =1。而子串的初始化可能每个单个字符都是回文,所以dp[i][i] = true,同时两个相邻字符如果相同的话,dp[i][i+1] = true。 总的来说,回文子串和子序列的问题在定义、解法以及应用场景上都有明显差异,需要分别处理。</think>### 回文子串问题 vs 最长回文子序列的区别 #### 1. **定义差异** - **回文子串**:字符串中**连续字符**组成的回文序列。例如,字符串 `"abcba"` 的最长回文子串是 `"abcba"`,长度为5。 - **最长回文子序列**:字符串中**不要求连续**但保持相对顺序的回文序列。例如,字符串 `"abcda"` 的最长回文子序列是 `"acda"` 或 `"abda"`,长度为3。 #### 2. **算法实现差异** ##### **回文子串问题** - **动态规划思路**: - 定义 `dp[i][j]` 表示子串 `s[i..j]` 是否为回文。 - 状态转移方程: - 若 `s[i] == s[j]` 且 `j - i <= 1`,则 `dp[i][j] = true`。 - 若 `s[i] == s[j]` 且 `dp[i+1][j-1] == true`,则 `dp[i][j] = true`。 - 统计所有 `dp[i][j] == true` 的区间长度,取最大值。 - **中心扩展法**: - 遍历每个字符或相邻字符对作为中心,向两侧扩展直到不满足回文条件[^4]。 ##### **最长回文子序列问题** - **动态规划思路**: - 定义 `dp[i][j]` 表示子序列 `s[i..j]` 的最长回文长度。 - 状态转移方程: - 若 `s[i] == s[j]`,则 `dp[i][j] = dp[i+1][j-1] + 2`。 - 若 `s[i] != s[j]`,则 `dp[i][j] = max(dp[i+1][j], dp[i][j-1])`[^3]。 - 遍历顺序需从后往前,确保子问题已计算(如 `i` 从末尾开始,`j` 从 `i+1` 开始)。 #### 3. **时间复杂度与空间复杂度** - **回文子串**: - 动态规划:时间复杂度 $O(n^2)$,空间复杂度 $O(n^2)$。 - 中心扩展法:时间复杂度 $O(n^2)$,空间复杂度 $O(1)$。 - **最长回文子序列**: - 动态规划:时间复杂度 $O(n^2)$,空间复杂度 $O(n^2)$(可优化为 $O(n)$)。 #### 4. **应用场景** - **回文子串**:适用于需要连续对称结构的场景,如文本编辑器的拼写检查、DNA序列的连续回文识别。 - **最长回文子序列**:适用于非连续对称结构的场景,如基因序列分析、数据压缩中的模式匹配。 #### 5. **示例代码对比** - **回文子串**(动态规划): ```python def longest_palindrome_substring(s): n = len(s) dp = [[False] * n for _ in range(n)] max_len = 1 for i in range(n-1, -1, -1): for j in range(i, n): if s[i] == s[j]: if j - i <= 1 or dp[i+1][j-1]: dp[i][j] = True max_len = max(max_len, j-i+1) return max_len ``` - **最长回文子序列**(动态规划): ```python def longest_palindrome_subseq(s): n = len(s) dp = [[0] * n for _ in range(n)] for i in range(n-1, -1, -1): dp[i][i] = 1 for j in range(i+1, n): if s[i] == s[j]: dp[i][j] = dp[i+1][j-1] + 2 else: dp[i][j] = max(dp[i+1][j], dp[i][j-1]) return dp[0][n-1] ``` #### 表格总结 | **对比维度** | **回文子串** | **最长回文子序列** | |--------------------|----------------------------------|----------------------------------| | **连续性要求** | 必须连续 | 可不连续 | | **状态转移条件** | 依赖中间子串是否为回文 | 依赖左右子问题的最大值 | | **典型应用场景** | 文本对称性检测 | 基因序列分析 | | **初始化方式** | `dp[i][i] = True`(单字符回文) | `dp[i][i] = 1`(单字符长度为1) | ---
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值