C++ 不修改内容的序列操作 算法（1）

最新推荐文章于 2024-08-05 22:59:16 发布
最新推荐文章于 2024-08-05 22:59:16 发布
阅读量453 收藏
点赞数
分类专栏： C++ 算法 文章标签： c++

算法（Algorithm）为一个计算的具体步骤，常用于计算、数据处理和自动推理。C++ 算法库（Algorithms library）为 C++ 程序提供了大量可以用来对容器及其它序列进行算法操作的函数。这些组件可以为函数或函数模板，大部份由头文件 <algorithm> 提供，一小部份位于 <numeric>、<cstdlib> 中。

 

不修改内容的序列操作：

adjacent_find 查找两个相邻的等价元素
all_ofC++11 检测在给定范围中是否所有元素都满足给定的条件
any_ofC++11 检测在给定范围中是否存在元素满足给定条件
count 返回值等价于给定值的元素的个数
count_if 返回值满足给定条件的元素的个数
equal 返回两个范围是否相等
find 返回第一个值等价于给定值的元素
find_end 查找范围A 中与范围B 等价的子范围最后出现的位置
find_first_of 查找范围A 中第一个与范围B 中任一元素等价的元素的位置
find_if 返回第一个值满足给定条件的元素
find_if_notC++11 返回第一个值不满足给定条件的元素
for_each 对范围中的每个元素调用指定函数
mismatch 返回两个范围中第一个元素不等价的位置
none_ofC++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/

虚心请教学习
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++ 最长子序列 longest subsequence算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-27 2196
该算法的目标是找到给定字符串或数组中的最长连续子序列，使得该子序列满足特定条件，例如满足递增、递减或其他自定义条件。该算法的目标是找到给定字符串或数组中的最长连续子序列，使得该子序列满足特定条件，例如满足递增、递减或其他自定义条件。该算法的目标是找到给定字符串或数组中的最长连续子序列，使得该子序列满足特定条件，例如满足递增、递减或其他自定义条件。该算法的目标是找到给定字符串或数组中的最长连续子序列，使得该子序列满足特定条件，例如满足递增、递减或其他自定义条件。
C/C++ 克拉茨Collatz序列算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-28 2166
给定一个正整数n，如果n是偶数，则将n除以2；如果n是奇数，则将n乘以3再加1。给定一个正整数n，如果n是偶数，则将n除以2；给定一个正整数n，如果n是偶数，则将n除以2；克拉茨（Collatz）序列算法，又被称为3n+1问题，是一个简单但著名的数学算法。克拉茨（Collatz）序列算法，又被称为3n+1问题，是一个简单但著名的数学算法。克拉茨（Collatz）序列算法，又被称为3n+1问题，是一个简单但著名的数学算法。克拉茨（Collatz）序列算法，又被称为3n+1问题，是一个简单但著名的数学算法。
网易2018内推笔试题_操作序列_C++
oDaHaiTaoTao的博客
08-26 395
#include <bits/stdc++.h>using namespace std;int main(){ vector<int> int_a, int_b; int n; cin >> n; int i, val; for(int i=0; i<n; ++i){ cin >> val; int_a.push_back(val
操作序列（STL）
Anterior_condyle的博客
02-25 918
时间限制：C/C++ 5秒，其他语言10秒 空间限制：C/C++ 131072K，其他语言262144K 64bit IO Format: %lld 题目描述 给出一个长度无限的数列，初始全部为零，有三种操作： 增加操作：给下标为 tt 的数加 cc 。特别注意，如果在下标 [t-30,t+30][t−30,t+30] 内有不为零的数，增加操作无效。 削减操作：让数列中下标最小的不为零数变为零。...
关于C++中rebegin显示错误的问题
weixin_30706507的博客
11-07 287
调试代码的时候发现使用rebegin之后，第一个获取出来的是没初始化的随机数。 std::map<int,int> testMap; testMap[1] = 2; testMap[3] = 4; testMap[5] = 6; testMap[7] = 8; testMap[9] = 0; int i = 0; for (std::map<int, i...
C++二分算法：1713得到子序列的最少操作次数
闻缺陷则喜何志丹
11-23 2684
给你一个数组 target ，包含若干 互不相同 的整数，以及另一个整数数组 arr ，arr 可能 包含重复元素。 每一次操作中，你可以在 arr 的任意位置插入任一整数。比方说，如果 arr = [1,4,1,2] ，那么你可以在中间添加 3 得到 [1,4,3,1,2] 。你可以在数组最开始或最后面添加整数。 请你返回 最少 操作次数，使得 target 成为 arr 的一个子序列。 一个数组的 子序列 指的是删除原数组的某些元素（可能一个元素都不删除），同时不改变其余元素的相对顺序得到的数组。比方说
操作系统课设(页面置换算法C++版)
学习笔记
01-16 3693
存储管理的主要功能之一是合理地分配空间。 请求页式管理是一种常用的虚拟存储管理技术。 本次设计的目的是通过请求页式存储管理中页面置换算法模拟设计， 了解虚拟存储技术的特点， 掌握请求页式管理的页面置换算法。 在进程运行过程中，如果要访问的页面不在内存，就须将此页面调入内存，但当内存已无空闲空间时，为了保证该进程可以正常运行，系统必须从内存中换出与其页面大小相同的程序或数据到磁盘的对换区中，然后将需要访问的页面调入内存。将哪个页面调出，必须根据系统采用的算法来确定。通常，把选择进行页面置换的算法称为页面置换算
C++ 求最大子序列和（贪心算法）
weixin_53064820的博客
05-23 864
/ 得到一个最大的负数，如果全部不是负数，就会返回一个最大的正数。// 如果这个数大于maxsum，就更新这个maxsum。// 如果是一个最大的负数，就直接返回这个最大的负数。// 如果sum是一个小于0的数，就舍去这个和。
操作系统实验：银行家算法（C++）
a2822849890的博客
11-01 8757
（新人上路，C++基本新手，用了很多for循环以及goto） 一、实验目的 死锁会引起计算机工作僵死，因此操作系统中必须防止。本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂 上所讲授的知识的理解。 二、实验要求 设计有 n 个进程共享 m 个系统资源的系统，进程可动态的申请和释放资源，系 统按各进程的申请动态的分配资源。 系统能显示各个进程申请和释放资源，以及系统动态分配资源的过.
C++ 补充之常用遍历算法
热门推荐
百锦再的博客
02-27 2万+
通过transform算法，可以方便地对容器中的每个元素进行转换操作，并将结果存储在另一个容器中，减少了显式循环的编写。通过for_each算法，可以方便地对容器中的每个元素进行操作，而不需要显式地编写循环。transform算法用于对序列中的每个元素应用指定的操作，并将结果存储在另一个序列中。find算法用于在容器中查找指定值第一次出现的位置，返回指向第一个等于该值的元素的迭代器，若未找到，则返回迭代器指向容器的末尾。通过使用这些算法，可以方便地对容器中的元素进行各种不同的操作和处理。
【C语言】Top K问题【建小堆】
2301_80840905的博客
08-04 387
在我们生活中，经常会遇到TopK问题。建小堆解决
C++ STL copy, move 用法
08-04 169
前向（从前向后的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
OD C卷 - 中庸行者
weixin_45228198的博客
08-04 178
DFS
c++——map、set底层之AVL树（动图演示旋转）
2301_80687320的博客
08-05 747
我们之前学了过二叉搜索树，二这里的AVL也是一种搜索树，当我们二叉搜索树发生偏移时，搜索时间就会边长，就不树logN了，变成N；而AVL就修复了这一点。一、{}// 该节点的左孩子// 该节点的右孩子// 该节点的双亲T _data;int _bf;// 该节点的平衡因子。
3.C_Demo_最大公约数、最小公倍数
Fresh_man111的博客
08-03 287
假设两个数字a和b，求两个数字相除的余数c=a%b，如果余数为0，则b为最大公约数。如果b不为零，a=b,b=c,继续循环计算。两个数的最小公倍数数等于两个数的乘积除以两个数的最大公约数。即：x，y的最小公倍数 min(公倍数)=x*y÷max(公约数)参数a，b：传入的两个数值，两个数都不能为0。参数a，b：传入的两个数值，不能全为0。返回值：0代表错误，正常返回最大公约数。返回值：0代表错误，正常返回最小公倍数。功能：求a，b最大公约数。功能：求a，b最小公倍数。
嵌入式初学-C语言-十五
MaBaB的博客
08-05 492
函数：实现一定功能的，独立的代码模块，我们的函数一定是先定义后使用使用函数的优势可以通过函数提供功能给别人使用，当然我们也可以使用别人提供的函数，减少代码量借助函数可以减少重复性代码。实现结构化（模块化）程序设计思想结构化程序设计思想：将大型的任务功能，划分为相互独立的小型的任务模块来设计3.函数是c语言程序的基本组成单元：C语言程序是由一个（必然是main函数）或多个函数组成。语法：返回类型 函数名(形参列表) -- 函数头 | 函数首部。
C语言编译和链接
最新发布
Ajiang2824735304的博客
08-05 868
带你了解编译过程以及宏定义。
HDU - 2057 (纯C语言模拟16进制加减法)
qq_62224565的博客
08-05 213
首先将16进制转成10进制，再将10进制转成16进制。有个问题就是题目说输入不超过15位，但是。第二，使用abs函数时注意，当数爆int时，用long long 储存使用abs会有误。第一，多组输入注意清空字符数组，令每个字符等于’\0’即可。纯模拟，过了后发现可以用%x，直接输入输出。第三，模拟时记得用long long。以前做题没有怎么用C写过HDU的题。就是求16进制的加法。
【c++】用c++指针传递来模拟“靶向治疗”
weixin_56334307的博客
08-02 688
这个程序通过模拟靶向治疗的过程，展示了C++中指针和数组的基本用法。通过传递数组元素的地址给函数，函数能够直接修改数组中的值，这种机制在C++中非常常见且强大，因为它允许函数对外部数据进行修改。在这个例子中，它用于模拟将癌变细胞治疗为健康细胞的过程。
C++实现最长不下降序列算法示例
本资源是一份关于“最长不下降序列”问题的C++编程实例，针对不同难度等级设计了两个示例。首先，【例9.3】"求最长不下降序列"（2020.01.24）-A，目标是解决一个经典的动态规划问题，主要关注如何在给定一个整数数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值