[AC自动机+矩阵快速幂] poj2778 与 hdu2243

于 2021-04-01 15:31:18 发布
阅读量252 收藏
点赞数 2
文章标签： 算法 数据结构 字符串 矩阵
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ECNU_SF/article/details/115373898
版权

poj 2778link

题面

  给定了 m m m 个 A, C, G, T 构成的基因片段(字符串)，让你构造一个不含这 m m m 个片段的，长度为 n n n 的由A, C, G, T构成的字符串，问有几种方式。

分析

  这题刚开始以为有关动态规划哈希什么的，看了题解才发现这是AC自动机的构造神题。AC自动机的基本介绍网上有很多，这里就不赘述。
  首先对于这 m m m 个字符串，可以建一个 AC 自动机，就如普通的AC自动机一样，维护 fail 数组，用 t r [ i ] [ j ] tr[i][j] tr[i][j] 表示第 i i i 个状态读入字符 j j j 之后变成的状态。然后对于每一个状态，需要记录这个状态是否包含一个完整的基因片段，其中 e [ i ] e[i] e[i] 表示从根到状态 i i i 的字符串是否为基因片段，然后用 l s t [ i ] lst[i] lst[i] 表示从根到状态 i i i 的字符串的某一个后缀是否为基因片段。
  这两个数组可以在建立自动机的时候维护，我们可以知道，若是到了某个状态， e [ i ] ! = 0   ∣ ∣   l s t [ i ] ! = 0 e[i] != 0 \ || \ lst[i] != 0 e[i]!=0 ∣∣ lst[i]!=0，这个状态就包含了一个基因片段，所以不可进入这个状态(不可达)。
  
  之后，我们建立一个邻接矩阵A，其中 A [ i ] [ j ] A[i][j] A[i][j] 表示从 i i i 到 j j j 的转移方式(每个转移方式对应一个字符)，但是要注意不可达状态的行和列要置为0。这样 A [ i ] [ j ] A[i][j] A[i][j] 就表示 从 状态 i i i 到 状态 j j j 长度为 1 的合法字符串个数， A n [ i ] [ j ] A^{n}[i][j] An[i][j] 就表示 从 状态 i i i 到 状态 j j j 长度为 n 的合法字符串个数，我们所要求的就是 ∑ A n [ 0 ] [ j ] \sum A^{n}[0][j] ∑An[0][j]。
  对于 A n [ i ] [ j ] A^{n}[i][j] An[i][j] 则需要用矩阵快速幂来计算，由于poj卡的比较紧，所以取mod的地方要在保证正确的时候尽可能减少。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<vector>
#include<cmath>
#include<string>
#include<sstream>
#include<bitset>
#define here printf("modassing [%s] in LINE %d\n", __FUNCTION__, __LINE__);
#define debug(x) cout << #x << ":\t" << (x) << endl;

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
const int maxn = 1000 + 10;
const int maxm = 2e6 + 10;
const int INF = 0x3f3f3f3f;
const ll mod = 1e9 + 7;
const double pi = acos(-1.0);
const double eps = 0.0000001;

int N;

struct mt                            //N表示方阵的维数
{
    ll a[102][102];
}mat;

mt mult(mt A, mt B, ll mod)          //计算方阵A * B
{
    mt res;
    for(int i = 0; i < N; i++)
    {
        for(int j = 0; j < N; j++)
        {
            res.a[i][j]=0;
            for(int k = 0; k < N; k++)
            {
                res.a[i][j] += A.a[i][k] * B.a[k][j];
            }
            res.a[i][j] %= mod;
        }
    }
    return res;
}
 
mt power(mt a,ll b, ll mod)         //计算方阵A^b
{
    mt res;
    for(int i = 0; i < N; i++)
        for(int j = 0; j < N; j++)
            res.a[i][j] = 0;
    for(int i = 0; i < N; i++) res.a[i][i] = 1;   //res为单位矩阵
 
    while(b)
    {
        if(b & 1) res = mult(res, a, mod);
        b >>= 1;
        a = mult(a, a, mod);
    }
    return res;
}


//tot记录trie树结点个数，0是根结点
int tr[maxn][4], tot;
int e[maxn], fail[maxn], lst[maxn];          //e记录有几个这样的字符串

int getch(char ch)
{
    if(ch == 'A')
        return 0;
    if(ch == 'C')
        return 1;
    if(ch == 'G')
        return 2;
    return 3;
}

void insertString(char *s)         //字符串从1开始
{
    int u = 0;
    for (int i = 1; s[i]; i++)
    {
        if (!tr[u][getch(s[i])]) tr[u][getch(s[i])] = ++tot;
        u = tr[u][getch(s[i])];
    }
    e[u] = 1;
}

void build()
{
    queue<int> q;
    for (int i = 0; i < 4; i++)
        if (tr[0][i]) q.push(tr[0][i]);    //先插入深度为1的结点
    
    while(q.size())
    {
        int u = q.front();
        q.pop();
        for (int i = 0; i < 4; i++)
        {
            if(tr[u][i]) //有i+'a'的子结点，则让它的fail指针指向 它父亲的fail指针指向的那个结点 的i+'a'结点
            {
                fail[tr[u][i]] = tr[fail[u]][i];
                q.push(tr[u][i]);
                lst[tr[u][i]] = (e[fail[tr[u][i]]] ? fail[tr[u][i]] : lst[fail[tr[u][i]]]);	 //lst指向存储了完整串的fail节点
            }
            else tr[u][i] = tr[fail[u]][i];  //若是没有子结点，让它指向 它父亲的fail指针指向的那个结点 的i+'a'结点
        }
    }
}

int m;
ll n;
char s[110];

int main()
{
    scanf("%d %lld", &m, &n);
    for (int i = 1; i <= m; i++)
    {
        scanf("%s", s + 1);
        insertString(s);
    }
    build();

    for (int i = 0; i <= tot; i++)
    {
        if(e[i] || lst[i]) continue;
        for (int j = 0; j < 4; j++)
        {
            int tmp = tr[i][j];
            if(e[tmp] || lst[tmp]) continue;
            mat.a[i][tmp]++;
        }
    }
    N = tot + 1;
    mt ans = power(mat, n, 100000);
    ll res = 0;
    for (int i = 0; i <= tot; i++)
        res = (res + ans.a[0][i]) % 100000;
    printf("%lld\n", res);
}

hdu 2243link

题面

  也是给你一些字符串表示词根，让你构造一个答案不超过 L L L 的字符串，其中这个字符串至少包括一个词根。
  要求答案对 2 64 2^{64} 264 取模，即自然溢出。

分析

  其实若是求恰好为 L L L 的字符串，就是poj那题的补集。若是不超过，答案就是 (不超过 L L L 的字符串 - 不超过 L L L 且不包含词根的字符串)。

  不超过 L L L 的字符串，数量总共有 2 6 1 + 2 6 2 + . . . + 2 6 L 26^1 + 26^2 +... + 26^L 261+262+...+26L 个，若是用倍增公式的话，有一个除数，取模的数不是素数，并且很大，不太好取逆元，快速幂是一种求和的方法：
  令 a k = 2 6 k ,   s k = ∑ i = 1 k a k a_k = 26 ^ k, \ s_k = \sum_{i = 1}^{k}a_k ak​=26k, sk​=∑i=1k​ak​，则 s k = s i − k + a k s_k = s_{i-k} + a_k sk​=si−k​+ak​，写成矩阵的形式：
[ 26 0 1 1 ] [ a i s i − 1 ] = [ a i + 1 s i ] \left[ \begin{matrix} 26 & 0\\ 1 & 1\\ \end{matrix} \right] \left[ \begin{matrix} a_i\\ s_{i-1}\\ \end{matrix} \right] = \left[ \begin{matrix} a_{i+1}\\ s_{i}\\ \end{matrix} \right]\\ [261​01​][ai​si−1​​]=[ai+1​si​​]
于是就有：
[ a n + 1 s n ] = [ 26 0 1 1 ] n [ a 1 s 0 ] = [ 26 0 1 1 ] n [ 26 0 ] \left[ \begin{matrix} a_{n+1}\\ s_{n}\\ \end{matrix} \right] = \left[ \begin{matrix} 26 & 0\\ 1 & 1\\ \end{matrix} \right]^n \left[ \begin{matrix} a_1\\ s_{0}\\ \end{matrix} \right] = \left[ \begin{matrix} 26 & 0\\ 1 & 1\\ \end{matrix} \right]^n \left[ \begin{matrix} 26\\ 0\\ \end{matrix} \right] [an+1​sn​​]=[261​01​]n[a1​s0​​]=[261​01​]n[260​]

  不超过 L L L 且不包含词根的字符串，若用poj那题 A [ i ] [ j ] A[i][j] A[i][j] 的定义，数量总共有 A 1 + A 2 + . . . + A L A^1 + A^2 +... + A^L A1+A2+...+AL 个。
  令 S k = ∑ i = 1 k A k S_k = \sum_{i = 1}^{k}A_k Sk​=∑i=1k​Ak​，则 S k = S i − k + A k S_k = S_{i-k} + A_k Sk​=Si−k​+Ak​，写成矩阵的形式：
[ A 0 1 1 ] [ A i S i − 1 ] = [ A i + 1 S i ] \left[ \begin{matrix} A & 0\\ 1 & 1\\ \end{matrix} \right] \left[ \begin{matrix} A_i\\ S_{i-1}\\ \end{matrix} \right] = \left[ \begin{matrix} A_{i+1}\\ S_{i}\\ \end{matrix} \right]\\ [A1​01​][Ai​Si−1​​]=[Ai+1​Si​​]
于是就有：
[ A n + 1 S n ] = [ A 0 1 1 ] n [ A 1 S 0 ] = [ A 0 1 1 ] n [ A 0 ] \left[ \begin{matrix} A_{n+1}\\ S_{n}\\ \end{matrix} \right] = \left[ \begin{matrix} A & 0\\ 1 & 1\\ \end{matrix} \right]^n \left[ \begin{matrix} A_1\\ S_{0}\\ \end{matrix} \right] = \left[ \begin{matrix} A & 0\\ 1 & 1\\ \end{matrix} \right]^n \left[ \begin{matrix} A\\ 0\\ \end{matrix} \right] [An+1​Sn​​]=[A1​01​]n[A1​S0​​]=[A1​01​]n[A0​]
值得注意的是，这里的 1 指的不是全 1 矩阵，而是单位矩阵。还有多组数据记得清空。

#include <bits/stdc++.h>
#define here printf("modassing [%s] in LINE %d\n", __FUNCTION__, __LINE__);
#define debug(x) cout << #x << ":\t" << (x) << endl;

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
const int maxn = 1000 + 10;
const int maxm = 2e6 + 10;
const int INF = 0x3f3f3f3f;
const ll mod = 1e9 + 7;
const double pi = acos(-1.0);
const double eps = 0.0000001;

ull qpow(ull a, ll b)
{
    ull t = 1;
    for(; b; b >>= 1, a = a * a)
        if(b & 1)  t = t * a;
    return t;
}

int N;

struct mt                            //N表示方阵的维数
{
    ull a[70][70];
}mat, M;

mt mult(mt A, mt B)          //计算方阵A * B
{
    mt res;
    for(int i = 0; i < N; i++)
    {
        for(int j = 0; j < N; j++)
        {
            res.a[i][j]=0;
            for(int k = 0; k < N; k++)
            {
                res.a[i][j] += A.a[i][k] * B.a[k][j];
            }
        }
    }
    return res;
}
 
mt power(mt a,ll b)         //计算方阵A^b
{
    mt res;
    for(int i = 0; i < N; i++)
        for(int j = 0; j < N; j++)
            res.a[i][j] = 0;
    for(int i = 0; i < N; i++) res.a[i][i] = 1;   //res为单位矩阵
 
    while(b)
    {
        if(b & 1) res = mult(res, a);
        b >>= 1;
        a = mult(a, a);
    }
    return res;
}


//tot记录trie树结点个数，0是根结点
int tr[maxn][26], tot;
int e[maxn], fail[maxn], lst[maxn];          //e记录有几个这样的字符串

void insertString(char *s)         //字符串从1开始
{
    int u = 0;
    for (int i = 1; s[i]; i++)
    {
        if (!tr[u][s[i]-'a']) tr[u][s[i]-'a'] = ++tot;
        u = tr[u][s[i]-'a'];
    }
    e[u] = 1;
}

void build()
{
    queue<int> q;
    for (int i = 0; i < 26; i++)
        if (tr[0][i]) q.push(tr[0][i]);    //先插入深度为1的结点
    
    while(q.size())
    {
        int u = q.front();
        q.pop();
        for (int i = 0; i <26; i++)
        {
            if(tr[u][i]) //有i+'a'的子结点，则让它的fail指针指向 它父亲的fail指针指向的那个结点 的i+'a'结点
            {
                fail[tr[u][i]] = tr[fail[u]][i];
                q.push(tr[u][i]);
                lst[tr[u][i]] = (e[fail[tr[u][i]]] ? fail[tr[u][i]] : lst[fail[tr[u][i]]]);	 //lst指向存储了完整串的fail节点
            }
            else tr[u][i] = tr[fail[u]][i];  //若是没有子结点，让它指向 它父亲的fail指针指向的那个结点 的i+'a'结点
        }
    }
}

void clear()
{
    memset(mat.a, 0, sizeof(mat.a));
    memset(M.a, 0, sizeof(M.a));
    for (int i = 0; i <= tot; i++)
    {
        e[i] = fail[i] = lst[i] = 0;
        for (int j = 0; j < 26; j++)
            tr[i][j] = 0;
    }
    tot = 0;
}


int m;
ll n;
char s[110];

int main()
{
    while(~scanf("%d %lld", &m, &n))
    {
        N = 2;
        mt g1;
        g1.a[0][0] = 26;
        g1.a[0][1] = 0;
        g1.a[1][0] = g1.a[1][1] = 1;
        mt g2 = power(g1, n);
        ull res = g2.a[1][0] * 26;

        for (int i = 1; i <= m; i++)        
        {
            scanf("%s", s + 1);
            insertString(s);
        }
        build();                    //构造AC自动机

        for (int i = 0; i <= tot; i++)            //构造A
        {
            if(e[i] || lst[i]) continue;
            for (int j = 0; j < 26; j++)
            {
                int tmp = tr[i][j];
                if(e[tmp] || lst[tmp]) continue;
                mat.a[i][tmp]++;
            }
        }

        N = 2 * tot + 2; 
        for (int i = 0; i < N; i++)            //构造M
        {
            if(i <= tot)
                for (int j = 0; j <= tot; j++)
                    M.a[i][j] = mat.a[i][j];
            else
                for (int j = 0; j < N; j++)
                    if(j == i - (tot+1) || j == i) M.a[i][j] = 1;
        }

        mt ans = power(M, n);

        N = tot + 1;
        mt tmp;
        for (int i = 0; i < N; i++)
            for (int j = 0; j < N; j++)
                tmp.a[i][j] = ans.a[i + N][j];
        ans = mult(mat, tmp);

        for (int i = 0; i < N; i++)
            res -=ans.a[0][i];
        printf("%I64u\n", res);
        clear();
    }
}
W_Zifan
关注
AC自动机（模板+例题）
等我，等我变的更好就去找你
06-12 1495
首先要明白AC自动机是干什么的： AC自动机其实就是一种多模匹配算法，那么你可能会问什么叫做多模匹配算法。下面是我对多模匹配的理解，与多模与之对于的是单模，单模就是给你一个单词，然后给你一个字符串，问你这个单词是否在这个字符串中出现过（匹配），这个问题可以用kmp算法在比较高效的效率上完成这个任务。那么现在我们换个问题，给你很多个单词，然后给你一段字符串，问你有多少个单词在这个字符串中出现...
【kuangbin带你飞】专题十七AC自动机
cjlu zx的博客
11-25 223
文章目录hdu3247 - Resource Archiver思路代码 hdu3247 - Resource Archiver 思路 n的数据范围只有10，一开始想的是设置状态dp[i][j]dp[i][j]dp[i][j]表示第一维当前选择好字符串的状态为i，那么第一维最对为(1<<10)，此时AC自动机上的状态为j。转移方程即为dp[i∣vis[p]][p]=min(dp[i][j]+1)dp[i|vis[p]][p]=min(dp[i][j]+1)dp[i∣vis[p]][p]=min(d
HDU 2243（AC自动机+矩阵快速幂）
weixin_30487201的博客
08-24 187
传送门 题面： 背单词，始终是复习英语的重要环节。在荒废了3年大学生涯后，Lele也终于要开始背单词了。 一天，Lele在某本单词书上看到了一个根据词根来背单词的方法。比如"ab",放在单词前一般表示"相反，变坏，离去"等。 于是Lele想，如果背了N个词根，那这些词根到底会不会在单词里出现呢。更确切的描述是：长度不超过L，只由小写字母组成的，至少包含一个词根的单...
HDU2243--考研路茫茫——单词情结
SCUT_Pein
09-08 904
Problem Description 背单词，始终是复习英语的重要环节。在荒废了3年大学生涯后，Lele也终于要开始背单词了。 一天，Lele在某本单词书上看到了一个根据词根来背单词的方法。比如"ab",放在单词前一般表示"相反，变坏，离去"等。 于是Lele想，如果背了N个词根，那这些词根到底会不会在单词里出现呢。更确切的描述是：长度不超过L，只由小写字母组成的，至少包含一个词根
HDU 2243
Bysen32
03-30 543
这题WA了.. 实在找不出错，CP了很多AC代码，大数据都是一样的。 哪位大神行行好帮我看看哪错了吧..... #include #include #include #define kind 26 #define MAX 100 using namespace std; struct node{ int fail,flag; int next[kind]; vo
hdu 2243
weixin_30751947的博客
10-23 128
题意求包含模板的长度小于等于L的单词个数。 N和L的范围 感觉是构造矩阵。然后开始想状态：对于所有模板建立AC自动机，这样得到每个节点的是否可以包含模板串，构造矩阵。 答案=总数-合法数。 对L加1 会超出int范围。 代码丑的醉了、 1 #include <iostream> 2 #include <cstdio> 3 #include ...
HDU2243-----AC自动机+矩阵乘法+矩阵公式
Bob Lee's Blog For CS
05-27 1001
题目地址：http://acm.hdu.edu.cn/showproblem.php?pid=2243 题目意思： 给你n个字符串，然后给你一个长度L 问你在长度不超过L的所有字符串中（a~z）有多少个至少含有一个子串 意思很明确了，下面说解法，这题和POJ2778很类似，详见：http://blog.csdn.net/dr5459/article/details/8971626
[置顶]AC自动机-算法详解
热门推荐
北岛知寒
03-05 1万+
What's Aho-Corasick automaton? 　　一种多模式串匹配算法，该算法在1975年产生于贝尔实验室，是著名的多模式匹配算法之一。 　　简单的说，KMP用来在一篇文章中匹配一个模式串；但如果有多个模式串，需要在一篇文章中把出现过的模式串都匹配出来，就需要Aho-Corasick automaton算法了。 My Understanding About Aho-Coras
【算法笔记】Aho-Corasick 算法（AC自动机） 小结
slowlight93的专栏
08-10 641
参考： 《训练指南》 http://codeforces.com/blog/entry/14854这个改进《训练指南》中说过， 本文的目的是总结并实现一个自用的模板。。 AC自动机每个节点有一个 fail 指针， 作用与KMP中相同。 假如我们的节点是这样的// link 就是 fail指针 struct Node { Node *go[CharSet], *link; in
HDU2243
Do It Youself!
09-23 380
HDU2243 题意 求长度为m且包含1-n个子串的种类数. 思路 首先计算26+262+....+26m26+26^2+....+26^m26+262+....+26m,构造矩阵为 [sum(m+1)1]=[sum(m)(初始sum(1)=26)1]∗[260261] \left[ \begin{matrix} sum(m+1) & 1 \end{matrix} \...
HDU 2243 (AC自动机 矩阵快速幂)
morejarphone~
06-16 475
题目链接:点击这里题意:求所有长度在LL之内的出现至少一种模式串的文本串个数. 对2642^{64}取模.对2642^{64}取模可以简单的看成无符号64位整数的自然溢出, 然后就可以忽略取模了. 和这题类似. 求出所有不存在模式串的文本串然后减一下就好了.先用AC自动机插入所有的文本串, 然后就在自动机上走找所有的不存在模式串的文本串, 建立矩阵AA, 因为是长度小于等于LL, 所以要求出A1+A
hdu-2243（AC自动机+矩阵快速幂）
weixin_30606669的博客
05-04 116
题意：给你n个字符串，和长度m，问你长度<=m的字符串中，包括这n个字符串的有多少个 解题思路：这题和poj2778差不多，但是那道题求的是不包含的，所有我们换个角度，求出所有的可能性减去不包括的就是了，但这道题有一个和那道题不一样的地方就是，他是<=长度len的所有，所有需要构造矩阵的时候加一列全为1的元素，然后求所有可能性也需要这样，构造一个2x2的矩阵【26 1 0 1】的矩阵...
hdu 2243(ac自动机+矩阵快速幂)
俯瞰风景
10-06 1450
题意：有n个小写字母组成的模式串，问长度不超过L的小写字母串中至少出现一个模式串的种类是多少。 题解：这道题和poj 2778类似，不过是把长度小于L的串的可能情况也计入，把邻接矩阵多一维存总和，然后结果用总种类数减一个模式串也不出现的种类数。总种类数很大，26^1 + 26^2 + 26^3 + … + 26^n，也用矩阵快速幂计算。f(n) = 26 * f(n - 1) + 26。 初始矩
hdu 2243 (AC自动机 + dp + 矩阵快速幂)
__夜
08-25 850
略恶心人的东东 /* * ===================================================================================== * * Filename: 2243.cpp * Version: 1.0 * Created: 2013-08-25 21:28:30 *
HDU 2243 AC自动机->DP->附矩阵乘法板子
ACMer不要报考高校代码为13627的移通学院！
08-28 1864
题目大意： 给一些字母串，问长度为L【以内】的全部字母串中，有多少个字母串，【包含】给定的字母串。答案mod 2^64 首先，对于答案mod 2^64,只要全部使用unsigned long long进行运算，就会自动实现这个功能了。 然后假设，问题只求长度为L，而不是长度小于L的，这个问题怎么做呢？ 参考前一个题解…… 题目转换为求【不包含】给定字母串来
hdu2243.考研路茫茫——单词情结(Trie图 && 矩阵乘法)
ALXPCUN的博客
04-22 725
背单词，始终是复习英语的重要环节。在荒废了3年大学生涯后，Lele 也终于要开始背单词了。一天，Lele 在某本单词书上看到了一个根据词根来背单词的方法。比如"ab",放在单词前一般表示"相反，变坏，离去"等。 于是Lele想，如果背了 N 个词根，那这些词根到底会不会在单词里出现呢。更确切的描述是：长度不超过L , 只由小写字母组成的，至少包含一个词根的单词，一共可能有多少个呢？
【AC自动机+矩阵幂的和】考研路茫茫――单词情结 HDU - 2243 （求包含特殊字符串的长度不超过n的字符串总数）
EnjoyingAC的博客
05-28 406
题目链接 考研路茫茫――单词情结 HDU - 2243 题目 背单词，始终是复习英语的重要环节。在荒废了3年大学生涯后，Lele也终于要开始背单词了。 一天，Lele在某本单词书上看到了一个根据词根来背单词的方法。比如”ab”,放在单词前一般表示”相反，变坏，离去”等。 于是Lele想，如果背了N个词根，那这些词根到底会不会在单词里出现呢。更确切的描述是：长度不超过L，只由小写字母组...
hdu 2243 AC+矩阵快速幂
llc_9012的专栏
07-16 558
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2243 做这道题前，得先去做这道题：http://poj.org/problem?id=2778 题目大意：给定m个词根，现在要用26个字母组成长度小等于n的字符串并且至少含一个词根的组合种数，n   这道题跟POJ那道差不多，不过这道更恶心，结果要对2^64取模（巨坑啊，害我卡了那么久），
Java编程：深入理解AC自动机算法与实现
"这篇文档详细介绍了AC自动机在Java编程中的应用，主要关注其工作原理、构建方法以及Java实现代码。AC自动机是一种高效的多模式字符串匹配算法，源于1975年的贝尔实验室，它结合了Trie树和KMP算法的思想。在处理大量...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值