C++ 算法库(1) 不修改内容的序列操作

最新推荐文章于 2024-08-02 23:32:39 发布
最新推荐文章于 2024-08-02 23:32:39 发布
阅读量2.2k 收藏
点赞数
分类专栏： 1.3 数据结构和算法 文章标签： c++ c++11
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/akof1314/article/details/18561779
版权

不修改内容的序列操作：

adjacent_find 查找两个相邻的等价元素
all_of C++11 检测在给定范围中是否所有元素都满足给定的条件
any_of C++11 检测在给定范围中是否存在元素满足给定条件
count 返回值等价于给定值的元素的个数
count_if 返回值满足给定条件的元素的个数
equal 返回两个范围是否相等
find 返回第一个值等价于给定值的元素
find_end 查找范围 A 中与范围 B 等价的子范围最后出现的位置
find_first_of  查找范围 A 中第一个与范围 B 中任一元素等价的元素的位置
find_if 返回第一个值满足给定条件的元素
find_if_not C++11 返回第一个值不满足给定条件的元素
for_each 对范围中的每个元素调用指定函数
mismatch 返回两个范围中第一个元素不等价的位置
none_of C++11 检测在给定范围中是否不存在元素满足给定的条件
search 在范围 A 中查找第一个与范围 B 等价的子范围的位置
search_n 在给定范围中查找第一个连续 n 个元素都等价于给定值的子范围的位置

adjacent_find

查找两个相邻的等价元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// adjacent_find example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::adjacent_find
 #include <vector>        // std::vector
bool myfunction ( int i,  int j) {
   return (i==j);
}

int main () {
   int myints[] = { 5, 20, 5, 30, 30, 20, 10, 10, 20};
  std::vector< int> myvector (myints,myints+ 8);
  std::vector< int>::iterator it;

   // using default comparison:
  it = std::adjacent_find (myvector.begin(), myvector.end());

   if (it!=myvector.end())
    std::cout <<  "the first pair of repeated elements are: " << *it <<  '\n';

   //using predicate comparison:
  it = std::adjacent_find (++it, myvector.end(), myfunction);

   if (it!=myvector.end())
    std::cout <<  "the second pair of repeated elements are: " << *it <<  '\n';

   return  0;
}

输出：

1
2
the first pair of repeated elements are: 30
the second pair of repeated elements are: 10

all_of

检测在给定范围中是否所有元素都满足给定的条件

1
2
3
4
5
6
7
8
9
10
11
12
13
// all_of example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::all_of
 #include <array>         // std::array
int main () {
  std::array< int, 8> foo = { 3, 5, 7, 11, 13, 17, 19, 23};

   if ( std::all_of(foo.begin(), foo.end(), []( int i){ return i% 2;}) )
    std::cout <<  "All the elements are odd numbers.\n";

   return  0;
}

输出：

1
All the elements are odd numbers.

any_of

检测在给定范围中是否存在元素满足给定条件

1
2
3
4
5
6
7
8
9
10
11
12
13
// any_of example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::any_of
 #include <array>         // std::array
int main () {
  std::array< int, 7> foo = { 0, 1,- 1, 3,- 3, 5,- 5};

   if ( std::any_of(foo.begin(), foo.end(), []( int i){ return i< 0;}) )
    std::cout <<  "There are negative elements in the range.\n";

   return  0;
}

输出：

1
There are negative elements in the range.

count

返回值等价于给定值的元素的个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// count algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::count
 #include <vector>        // std::vector
int main () {
   // counting elements in array:
   int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20};    // 8 elements
   int mycount = std::count (myints, myints+ 8,  10);
  std::cout <<  "10 appears " << mycount <<  " times.\n";

   // counting elements in container:
  std::vector< int> myvector (myints, myints+ 8);
  mycount = std::count (myvector.begin(), myvector.end(),  20);
  std::cout <<  "20 appears " << mycount  <<  " times.\n";

   return  0;
}

输出：

1
2
10 appears 3 times.
20 appears 3 times.

count_if

返回值满足给定条件的元素的个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// count_if example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::count_if
 #include <vector>        // std::vector
bool IsOdd ( int i) {  return ((i% 2)== 1); }

int main () {
  std::vector< int> myvector;
   for ( int i= 1; i< 10; i++) myvector.push_back(i);  // myvector: 1 2 3 4 5 6 7 8 9
   int mycount = count_if (myvector.begin(), myvector.end(), IsOdd);
  std::cout <<  "myvector contains " << mycount  <<  " odd values.\n";

   return  0;
}

输出：

1
myvector contains 5 odd values.

equal

返回两个范围是否相等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// equal algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::equal
 #include <vector>        // std::vector
bool mypredicate ( int i,  int j) {
   return (i==j);
}

int main () {
   int myints[] = { 20, 40, 60, 80, 100};                //   myints: 20 40 60 80 100
  std::vector< int>myvector (myints,myints+ 5);      // myvector: 20 40 60 80 100
   // using default comparison:
   if ( std::equal (myvector.begin(), myvector.end(), myints) )
    std::cout <<  "The contents of both sequences are equal.\n";
   else
    std::cout <<  "The contents of both sequences differ.\n";

  myvector[ 3]= 81;                                  // myvector: 20 40 60 81 100
   // using predicate comparison:
   if ( std::equal (myvector.begin(), myvector.end(), myints, mypredicate) )
    std::cout <<  "The contents of both sequences are equal.\n";
   else
    std::cout <<  "The contents of both sequences differ.\n";

   return  0;
}

输出：

1
2
The contents of both sequences are equal.
The contents of both sequence differ.

find

返回第一个值等价于给定值的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// find example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::find
 #include <vector>        // std::vector
int main () {
   int myints[] = {  10,  20,  30 , 40 };
   int * p;

   // pointer to array element:
  p = std::find (myints,myints+ 4, 30);
  ++p;
  std::cout <<  "The element following 30 is " << *p <<  '\n';

  std::vector< int> myvector (myints,myints+ 4);
  std::vector< int>::iterator it;

   // iterator to vector element:
  it = find (myvector.begin(), myvector.end(),  30);
  ++it;
  std::cout <<  "The element following 30 is " << *it <<  '\n';

   return  0;
}

输出：

1
2
The element following 30 is 40
The element following 30 is 40

find_end

查找范围 A 中与范围 B 等价的子范围最后出现的位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// find_end example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::find_end
 #include <vector>        // std::vector
bool myfunction ( int i,  int j) {
   return (i==j);
}

int main () {
   int myints[] = { 1, 2, 3, 4, 5, 1, 2, 3, 4, 5};
  std::vector< int> haystack (myints,myints+ 10);

   int needle1[] = { 1, 2, 3};

   // using default comparison:
  std::vector< int>::iterator it;
  it = std::find_end (haystack.begin(), haystack.end(), needle1, needle1+ 3);

   if (it!=haystack.end())
    std::cout <<  "needle1 last found at position " << (it-haystack.begin()) <<  '\n';

   int needle2[] = { 4, 5, 1};

   // using predicate comparison:
  it = std::find_end (haystack.begin(), haystack.end(), needle2, needle2+ 3, myfunction);

   if (it!=haystack.end())
    std::cout <<  "needle2 last found at position " << (it-haystack.begin()) <<  '\n';

   return  0;
}

输出：

1
2
needle1 found at position 5
needle2 found at position 3

find_first_of 

返回第一个值不满足给定条件的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// find_first_of example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::find_first_of
 #include <vector>        // std::vector
 #include <cctype>        // std::tolower
bool comp_case_insensitive ( char c1,  char c2) {
   return (std::tolower(c1)==std::tolower(c2));
}

int main () {
   int mychars[] = { 'a', 'b', 'c', 'A', 'B', 'C'};
  std::vector< char> haystack (mychars,mychars+ 6);
  std::vector< char>::iterator it;

   int needle[] = { 'A', 'B', 'C'};

   // using default comparison:
  it = find_first_of (haystack.begin(), haystack.end(), needle, needle+ 3);

   if (it!=haystack.end())
    std::cout <<  "The first match is: " << *it <<  '\n';

   // using predicate comparison:
  it = find_first_of (haystack.begin(), haystack.end(),
  needle, needle+ 3, comp_case_insensitive);

   if (it!=haystack.end())
    std::cout <<  "The first match is: " << *it <<  '\n';

   return  0;
}

输出：

1
2
The first match is: A
The first match is: a

for_each

对范围中的每个元素调用指定函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// for_each example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::for_each
 #include <vector>        // std::vector
void myfunction ( int i) {   // function:
  std::cout <<  ' ' << i;
}

struct myclass {            // function object type:
   void  operator() ( int i) {std::cout <<  ' ' << i;}
} myobject;

int main () {
  std::vector< int> myvector;
  myvector.push_back( 10);
  myvector.push_back( 20);
  myvector.push_back( 30);

  std::cout <<  "myvector contains:";
  for_each (myvector.begin(), myvector.end(), myfunction);
  std::cout <<  '\n';

   // or:
  std::cout <<  "myvector contains:";
  for_each (myvector.begin(), myvector.end(), myobject);
  std::cout <<  '\n';

   return  0;
}

输出：

1
2
myvector contains: 10 20 30
myvector contains: 10 20 30

mismatch

返回两个范围中第一个元素不等价的位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// mismatch algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::mismatch
 #include <vector>        // std::vector
 #include <utility>       // std::pair
bool mypredicate ( int i,  int j) {
   return (i==j);
}

int main () {
  std::vector< int> myvector;
   for ( int i= 1; i< 6; i++) myvector.push_back (i* 10);  // myvector: 10 20 30 40 50
   int myints[] = { 10, 20, 80, 320, 1024};                 //   myints: 10 20 80 320 1024
  std::pair<std::vector< int>::iterator, int*> mypair;

   // using default comparison:
  mypair = std::mismatch (myvector.begin(), myvector.end(), myints);
  std::cout <<  "First mismatching elements: " << *mypair.first;
  std::cout <<  " and " << *mypair.second <<  '\n';

  ++mypair.first; ++mypair.second;

   // using predicate comparison:
  mypair = std::mismatch (mypair.first, myvector.end(), mypair.second, mypredicate);
  std::cout <<  "Second mismatching elements: " << *mypair.first;
  std::cout <<  " and " << *mypair.second <<  '\n';

   return  0;
}

输出：

1
2
First mismatching elements: 30 and 80
Second mismatching elements: 40 and 320

none_of

检测在给定范围中是否不存在元素满足给定的条件

1
2
3
4
5
6
7
8
9
10
11
12
13
// none_of example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::none_of
 #include <array>         // std::array
int main () {
  std::array< int, 8> foo = { 1, 2, 4, 8, 16, 32, 64, 128};

   if ( std::none_of(foo.begin(), foo.end(), []( int i){ return i< 0;}) )
    std::cout <<  "There are no negative elements in the range.\n";

   return  0;
}

输出：

1
There are no negative elements in the range.

search

在范围 A 中查找第一个与范围 B 等价的子范围的位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// search algorithm example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::search
 #include <vector>        // std::vector
bool mypredicate ( int i,  int j) {
   return (i==j);
}

int main () {
  std::vector< int> haystack;

   // set some values:        haystack: 10 20 30 40 50 60 70 80 90
   for ( int i= 1; i< 10; i++) haystack.push_back(i* 10);

   // using default comparison:
   int needle1[] = { 40, 50, 60, 70};
  std::vector< int>::iterator it;
  it = std::search (haystack.begin(), haystack.end(), needle1, needle1+ 4);

   if (it!=haystack.end())
    std::cout <<  "needle1 found at position " << (it-haystack.begin()) <<  '\n';
   else
    std::cout <<  "needle1 not found\n";

   // using predicate comparison:
   int needle2[] = { 20, 30, 50};
  it = std::search (haystack.begin(), haystack.end(), needle2, needle2+ 3, mypredicate);

   if (it!=haystack.end())
    std::cout <<  "needle2 found at position " << (it-haystack.begin()) <<  '\n';
   else
    std::cout <<  "needle2 not found\n";

   return  0;
}

输出：

1
2
match1 found at position 3
match2 not found

search_n

在给定范围中查找第一个连续 n 个元素都等价于给定值的子范围的位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// search_n example
 #include <iostream>      // std::cout
 #include <algorithm>     // std::search_n
 #include <vector>        // std::vector
bool mypredicate ( int i,  int j) {
   return (i==j);
}

int main () {
   int myints[]={ 10, 20, 30, 30, 20, 10, 10, 20};
  std::vector< int> myvector (myints,myints+ 8);

  std::vector< int>::iterator it;

   // using default comparison:
  it = std::search_n (myvector.begin(), myvector.end(),  2,  30);

   if (it!=myvector.end())
    std::cout <<  "two 30s found at position " << (it-myvector.begin()) <<  '\n';
   else
    std::cout <<  "match not found\n";

   // using predicate comparison:
  it = std::search_n (myvector.begin(), myvector.end(),  2,  10, mypredicate);

   if (it!=myvector.end())
    std::cout <<  "two 10s found at position " <<  int(it-myvector.begin()) <<  '\n';
   else
    std::cout <<  "match not found\n";

   return  0;
}

输出：

1
2
Two 30s found at position 2
Two 10s found at position 5

特别说明：函数的中文释义来自：http://classfoo.cn/cpp/head/76573_319/，例子来自：http://www.cplusplus.com/reference/algorithm/


无幻
关注
专栏目录
c++ 标准模板库 STL 算法之 for_each 函数的使用用法详解
聚精会神搞建设
05-15 6923
std::for_each template Function for_each (InputIterator first, InputIterator last, Function fn); Apply function to range Applies function fn to each of the elements in the range [first,las
C++标准库中的算法与应用之一
IT_Beijing_BIT的博客
05-24 1468
C++标准库中的算法与应用非修改序列操作all_of/any_of/none_offor_eachcount/count_iffor_each三级目录 非修改序列操作 all_of/any_of/none_of for_each 按顺序将给定的函数对象f应用于解引用范围为[first，last）的每个迭代器的结果。 将给定的函数对象f应用于解引用[first，last）范围内的每个迭代器的结果（不一定按顺序）。该算法是根据策略执行的。除非std :: is_execution_policy_v <s
STL之非修改性序列算法1
Android移动开发者
08-11 804
非修改性序列算法是不用使用循环就可以从序列中中找出某些东西的工具。 可分为： for_each算法 元素计数算法 最小值和最大值算法 搜寻算法 区间比较算法 for_each()算法 函数原型: for_each(Iterator begin ,Iterator end ,proc op)算法主要对[begin,end]区间的每个元素调用op。 其中,op可
为什么不要在 foreach 循环里进行元素的 remove/add 操作
小锴的学习笔记
07-21 1909
在阿里巴巴java开发手册中有这样一条: 【强制】不要在 foreach 循环里进行元素的 remove/add 操作。remove 元素请使用 Iterator 方式，如果并发操作，需要对 Iterator 对象加锁。 正例： Iterator iterator = list.iterator(); while (iterator.hasNext()) { Strin...
C++算法库 不修改内容的序列操作函数
杜甲同学的专栏
02-09 1231
/* adjacent_find  查找两个相邻的等价元素*/ #include #include #include using namespace std; /* adjacent_find 查找两个相邻的等价元素*/ bool myfunction(int i , int j) { return (i == j); } void adjacentFineFunction(
C++中常用的算法库函数大总结
最新发布
qq_73117567的博客
08-02 1440
C++中常见的算法库函数大总结
C++ 算法库(2) 修改内容的序列操作
无幻
01-22 2386
修改内容的序列操作： copy 将一个范围中的元素拷贝到新的位置处 copy_backward 将一个范围中的元素按逆序拷贝到新的位置处 copy_if C++11 将一个范围中满足给定条件的元素拷贝到新的位置处 copy_n C++11 拷贝 n 个元素到新的位置处 fill 将一个范围的元素
【C++】算法库(批量操作、搜索操作)
qq_60755751的博客
12-09 1485
算法库提供大量用途的函数（例如查找、排序、计数、操作），它们在元素范围上操作。》》》》C++20 在命名空间 std::ranges 中提供大多数算法的受约束版本，在这些算法中，范围既可以由迭代器-哨位对，也可以由单个 range 实参指定，还支持投影和成员指针可调用对象。
C++ 算法库 常用函数汇总
Raymond_YP的博客
03-03 2183
参考了**《C++STL 标准程序库开发指南》** 1. for_each 函数：for_each(Iterator begin , Iterator end , proc op) 说明：for_each 算法实现对区间 [begin,end] 中的每个元素均调用进程op 例子：将数组 a 和 vector b中的全部元素按顺序打印出来。 #include<cstdio> #inclu...
C++开源算法库OpenSAL1.1(Open Standardized Algorithm Library)——动态链接库
03-01
序列算法：最长公共子序列、KMP序列匹配*、键值分离排序。 数论算法：大数类（兼容浮点数、整数、与内置类型兼容运算）*、RSA加解密系统*、解同余方程*、孙子定理解同余方程组*、Miller_Rabin素数测试（产生大质数）...
C++开源算法库OpenSAL1.1(Open Standardized Algorithm Library) ——静态链接库
03-01
序列算法：最长公共子序列、KMP序列匹配*、键值分离排序。 数论算法：大数类（兼容浮点数、整数、与内置类型兼容运算）*、RSA加解密系统*、解同余方程*、孙子定理解同余方程组*、Miller_Rabin素数测试（产生大质数）...
C++算法-最大子序列和.zip
02-08
在压缩包内的“algorithm-master”可能包含了一个完整的C++算法库，其中可能有各种其他数据结构和算法的实现，例如排序算法、图算法、搜索算法等。学习和理解这些算法对于提升C++编程技能和解决实际问题至关重要。...
algorithm 不修改序列的操作
一十一的博客
08-10 138
STL算法 非修正序列算法 函数 算法 adjacent_find(first, last) 搜索相邻的重复元素 count(first, last, val) 计数 equal(first, last, first2) 判断是否相等 find(first, last, val) 搜索 find_end(first, last, first2, last2) 搜索某...
图---邻接表(建立，深度遍历，广度遍历)
热门推荐
无幻
07-28 4万+
图的邻接表表示法类似于树的孩子链表表示法。对于图G中的每个顶点vi，该方法把所有邻接于vi的顶点vj链成一个带头结点的单链表，这个单链表就称为顶点vi的邻接表(Adjacency List)。以下代码测试过，为图的邻接表表示方式。/*******************************************************************
棋盘覆盖问题
无幻
03-27 1万+
在一个 2^k * 2^k 个方格组成的棋盘中，若恰有一个方格与其它方格不同，则称该方格为一特殊方格，称该棋盘为一特殊棋盘。显然特殊方格在棋盘上出现的位置有 4^k 种情形。因而对任何 k>=0 ，有 4^k 种不同的特殊棋盘。下图所示的特殊棋盘为 k=2 时 16 个特殊棋盘中的一个。在棋盘覆盖问题中，要用下图中 4 中不同形态的 L 型骨牌覆盖一个给定的特殊棋牌上除特殊方格以外的所
图---邻接矩阵(建立，深度遍历，广度遍历)
无幻
07-28 1万+
    图的存储方式可以用邻接矩阵来表示，我们假定顶点序号从0开始，即图G的顶点集的一般形式是V(G)={v0，vi，…，Vn-1}。以下代码测试过，为图的邻接矩阵表示方式。/************************************************************************//* 图的邻接矩阵存储结构
数据结构----图(笔记)
无幻
07-28 8736
 图G由两个集合V和E组成，记为：        G=(V，E)　　其中：　　V是顶点的有穷非空集合，　　E是V中顶点偶对(称为边)的有穷集。    　通常，也将图G的顶点集和边集分别记为V(G)和E(G)。E(G)可以是空集。若E(G)为空，则图G只有顶点而没有边。图有两种存储结构：邻接矩阵和邻接表 邻接矩阵：   ① 用邻接矩阵表示顶点间的相邻关系         　     
C语言算法速查手册
无幻
04-24 7989
第1章　绪论　1 1.1　程序设计语言概述　1 1.1.1　机器语言　1 1.1.2　汇编语言　2 1.1.3　高级语言　2 1.1.4　C语言　3 1.2　C语言的优点和缺点　4 1.2.1　C语言的优点　4 1.2.2　C语言的缺点　6 1.3　算法概述　7 1.3.1　算法的基本特征　7 1.3.2　算法的复杂度　8 1.3.3　算法的准确性　10 1.3.4　算法的稳定性　...
用C++归并算法实现对序列逆序对个数的计算，不用算法库
06-09
归并算法求逆序对的思路如下： 1. 将原序列递归地二分成左右两个子序列，对左右两个子序列分别计算逆序对个数； 2. 对左右两个子序列进行归并排序，同时统计左右两个子序列之间的逆序对个数； 3. 将排序后的左右两个子序列合并成一个有序序列，最终得到整个序列的逆序对个数。 具体实现如下： ```c++ #include <iostream> #include <vector> using namespace std; long long merge(vector<int>& nums, int left, int mid, int right) { int i = left, j = mid + 1; long long count = 0; vector<int> temp; while (i <= mid && j <= right) { if (nums[i] <= nums[j]) { temp.push_back(nums[i++]); } else { count += mid - i + 1; // 统计逆序对个数 temp.push_back(nums[j++]); } } while (i <= mid) temp.push_back(nums[i++]); while (j <= right) temp.push_back(nums[j++]); for (int k = 0; k < temp.size(); k++) { nums[left + k] = temp[k]; } return count; } long long mergeSort(vector<int>& nums, int left, int right) { long long count = 0; if (left < right) { int mid = left + (right - left) / 2; count += mergeSort(nums, left, mid); count += mergeSort(nums, mid + 1, right); count += merge(nums, left, mid, right); } return count; } int main() { vector<int> nums = {7, 5, 6, 4}; cout << mergeSort(nums, 0, nums.size() - 1) << endl; // 5 return 0; } ``` 以上代码中，merge() 函数实现了对左右子序列的归并排序，并统计左右两个子序列之间的逆序对个数。mergeSort() 函数实现了归并排序的递归调用，并返回整个序列的逆序对个数。main() 函数中给出了一个样例，输出结果为 5。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值