【算法笔记自学】第 4 章 入门篇（2）——算法初步

已于 2024-07-06 16:18:36 修改
阅读量316 收藏
点赞数 2
分类专栏： 算法笔记自学 文章标签： 算法 c++ c语言
于 2024-07-05 18:09:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62704693/article/details/140160249
版权

 4.1排序

自己写的题解

#include <stdio.h>
#include <stdlib.h>

void selectSort(int A[], int n) {
    for(int i = 0; i < n - 1; i++) { // 修正索引范围
        int k = i;
        for(int j = i + 1; j < n; j++) { // 修正索引范围
            if(A[j] < A[k]) {
                k = j;
            }
        }
        if (k != i) { // 仅在需要时进行交换
            int temp = A[i];
            A[i] = A[k];
            A[k] = temp;
        }
    }
}

int main() {
    int n = 0;
    scanf("%d", &n);
    int A[n];
    for(int i = 0; i < n; i++) {
        scanf("%d", &A[i]);
    }
    selectSort(A, n); // 直接传递数组名
    for(int i = 0; i < n; i++) {
        if(i!=n-1)
        {
            printf("%d ", A[i]);
        }
        else
        {
            printf("%d", A[i]);
        }
    }
    system("pause"); // 防止运行后自动退出，需头文件stdlib.h
    return 0;
}

 自己写的题解

#include <stdio.h>
#include <stdlib.h>
void insertSort(int A[], int n) {
    for(int i=1;i<=n-1;i++){
        int temp=A[i],j=i;
        while(j>0&&temp<A[j-1]){
            A[j]=A[j-1];
            j--;
        }
        A[j]=temp;
    }
}

int main() {
    int n = 0;
    scanf("%d", &n);
    int A[n];
    for(int i = 0; i < n; i++) {
        scanf("%d", &A[i]);
    }
    insertSort(A, n); // 直接传递数组名
    for(int i = 0; i < n; i++) {
        if(i!=n-1)
        {
            printf("%d ", A[i]);
        }
        else
        {
            printf("%d", A[i]);
        }
    }
    system("pause"); // 防止运行后自动退出，需头文件stdlib.h
    return 0;
}

4.2散列

#include <stdio.h>
#include <stdlib.h>

const int maxn = 100010;
int hashTable[maxn] = {0};

int main() {
    int n, x;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &x);
        if (x >= 0 && x < maxn) { // 确保x在合法范围内
            hashTable[x]++;
        }
    }
    for (int i = 0; i < maxn; i++) { // 修正遍历范围
        if (hashTable[i] != 0) {
            printf("%d %d\n", i, hashTable[i]); // 修正输出格式
        }
    }
    system("pause"); // 防止运行后自动退出，需头文件stdlib.h
    return 0;
}

 标答

#include <cstdio>
#include <cstring>

const int MAXN = 26;
const int MAXL = 1001;
char str1[MAXL], str2[MAXL];
bool hashTable[MAXN] = {false};

int getHashKey(char c) {
    return c - 'a';
}

int main () {
    scanf("%s%s", str1, str2);
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    for (int i = 0; i < len1; i++) {
        hashTable[getHashKey(str1[i])] = true;
    }
    for (int i = 0; i < len2; i++) {
        printf("%d", hashTable[getHashKey(str2[i])]);
        printf(i < len2 - 1 ? " " : "\n");
    }
    return 0;
}

#include <cstdio>

const int MAXN = 26 * 26 * 26;
const int MAXL = 1001;
char str[MAXL];
int hashTable[MAXN] = {0};

int getHashKey(char s[]) {
    return (s[0] - 'A') * 26 * 26 + (s[1] - 'A') * 26 + (s[2] - 'A');
}

int main () {
    int n, m;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%s", str);
        hashTable[getHashKey(str)]++;
    }
    scanf("%d", &m);
    for (int i = 0; i < m; i++) {
        scanf("%s", str);
        printf("%d", hashTable[getHashKey(str)]);
        printf(i < m - 1 ? " " : "\n");
    }
    return 0;
}

 4.3递归

#include <stdio.h>
#include <stdlib.h>


void print(int n) {
    if (n == 0) {
        printf("讲你妹的故事啊！快点去睡觉！！！\n");
    } else {
        printf("从前有座山，山上有座庙\n庙里有一个老和尚和一个小和尚\n睡前老和尚给小和尚讲故事：\n");
        print(n - 1);
        printf("然后老和尚和小和尚就睡觉啦\n");
    }
}

int main() {
    int n;
    scanf("%d", &n);
    print(n);
    system("pause"); // 防止运行后自动退出，需头文件stdlib.h
    return 0;
}


#include <stdio.h>
#include <stdlib.h>


int F(int n) {
    if(n==1)return 1;
    if(n==2)return 1;
    if(n>2)return F(n-1)+F(n-2);
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d",F(n));
    system("pause"); // 防止运行后自动退出，需头文件stdlib.h
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
const int maxn=11;
int n,P[maxn],hashTable[maxn]={false};
void generateP(int index){
    if(index==n+1){
        for(int i=1;i<=n;i++)
        {
            printf("%d",P[i]);
            printf(i<n ? " " : "\n");
        }
        return;
    }
    for(int x=1;x<=n;x++){
        if(hashTable[x]==false){
            P[index]=x;
            hashTable[x]=true;
            generateP(index+1);
            hashTable[x]=false;
        }
    }
}

int main() {
    n=3;
    scanf("%d",&n);
    generateP(1);
    system("pause"); // 防止运行后自动退出，需头文件stdlib.h
    return 0;
}

4.4贪心

#include <cstdio>
#include <algorithm>
using namespace std;
const int MAXN = 100000;    // 箱子数量上限
int a[MAXN];                // 箱子数组
int main() {
    int n, maxW;            // 箱子数量、载重
    scanf("%d%d", &n, &maxW);
    for (int i = 0; i < n; i++) {    // 输入各箱子重量
        scanf("%d", &a[i]);
    }
    sort(a, a + n);                  // 将箱子按重量从小到大排序
    int num = 0, sum = 0;            // 最大箱子数量、最大累计重量
    for (int i = 0; i < n; i++) {    // 从小到大遍历箱子
        if (sum + a[i] <= maxW) {    // 如果加上当前箱子的重量之后没有超过载重
            num++;                   // 最大箱子数量加1
            sum += a[i];             // 最大累计重量加上当前箱子的重量
        } else {                     // 如果超过载重，那么退出循环
            break;
        }
    }
    printf("%d %d", num, sum);       // 输出最大箱子数量和最大累计重量
    return 0;
}

#include <cstdio>
#include <algorithm>
using namespace std;
const int MAXN = 10000;
struct Interval {    // 区间结构体定义
    int l, r;
} interval[MAXN];    // 区间数组

bool cmp(Interval a, Interval b) {    // 区间的比较函数
    if (a.l != b.l) {                 // 如果左端点不同，那么按左端点从大到小
        return a.l > b.l;
    } else {                          // 否则，按右端点从小到大
        return a.r < b.r;
    }
}

int main() {
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {         // 输入n个区间的左右端点
        scanf("%d%d", &interval[i].l, &interval[i].r);
    }
    sort(interval, interval + n, cmp);    // 将区间数组进行排序
    int num = 1, lastL = interval[0].l;   // 排序后的第一个区间总是被选中
    for (int i = 1; i < n; i++) {         // 遍历剩余的区间
        if (interval[i].r <= lastL) {     // 如果和上一个选中的区间不相交
            lastL = interval[i].l;        // 那么选中当前区间
            num++;                        // 并令选中的区间数量加1
        }
    }
    printf("%d", num);                    // 输出选中的区间数量
    return 0;
}

4.5二分法

#include <cstdio>
#include <algorithm>
using namespace std;
const int MAXN = 10000;
int binarySearch(int A[],int left,int right,int x)
{
    int mid;
    while(left<=right){
        mid=(left+right)/2;
        if(A[mid]==x)return mid;
        else if(A[mid]>x){
            right=mid-1;
        }else{
            left=mid+1;
        }
    }
    return -1;
}
int main() {
    int n=0,x=0;
    scanf("%d %d", &n,&x);
    int a[n];
    for (int i = 0; i < n; i++) {         // 输入n个区间的左右端点
        scanf("%d", &a[i]);
    }
    printf("%d", binarySearch(a,0,n-1,x));                    // 输出选中的区间数量
    return 0;
}

#include <cstdio>
#include <algorithm>
using namespace std;
const int MAXN = 10000;
int lower_bound(int A[],int left,int right,int x)
{
    int mid;
    while(left<right){
        mid=(left+right)/2;
        if(A[mid]>=x){
            right=mid;
        }else{
            left=mid+1;
        }
    }
    return left;
}
int main() {
    int n=0,x=0;
    scanf("%d %d", &n,&x);
    int a[n];
    for (int i = 0; i < n; i++) {         // 输入n个区间的左右端点
        scanf("%d", &a[i]);
    }
    printf("%d", lower_bound(a,0,n,x));                    // 输出选中的区间数量
    return 0;
}

#include <cstdio>
#include <algorithm>
using namespace std;
const int MAXN = 10000;
int upper_bound(int A[],int left,int right,int x)
{
    int mid;
    while(left<right){
        mid=(left+right)/2;
        if(A[mid]>x){
            right=mid;
        }else{
            left=mid+1;
        }
    }
    return left;
}
int main() {
    int n=0,x=0;
    scanf("%d %d", &n,&x);
    int a[n];
    for (int i = 0; i < n; i++) {         // 输入n个区间的左右端点
        scanf("%d", &a[i]);
    }
    printf("%d", upper_bound(a,0,n,x));                    // 输出选中的区间数量
    return 0;
}

#include <cstdio>

const int MAXN = 100000;
int n, a[MAXN], target;

int binarySearch() {
    int l = 0, r = n;
    while (l < r) {
        int mid = l + (r - l) / 2;
        if (a[mid] >= target) {
            r = mid;
        } else {
            l = mid + 1;
        }
    }
    if (l < n && a[l] == target) {
        return l;
    } else {
        return -1;
    }
}

int main() {
    scanf("%d%d", &n, &target);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    printf("%d", binarySearch());
    return 0;
}

#include <cstdio>

const int MAXN = 100000;
int n, a[MAXN], target;

int binarySearch() {
    int l = 0, r = n;
    while (l < r) {
        int mid = l + (r - l) / 2;
        if (a[mid] > target) {
            r = mid;
        } else {
            l = mid + 1;
        }
    }
    if (l >0 && a[l-1] == target) {
        return l-1;
    } else {
        return -1;
    }
}

int main() {
    scanf("%d%d", &n, &target);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    printf("%d", binarySearch());
    return 0;
}

#include <cstdio>
const int MAXN = 100000;
const double eps=1e-6;
double a;
double f(double x){
    return x*x*x+x*x+x-a;
}
double calSqrt(){
    double left=-100,right=100,mid;
    while(right-left>eps){
        mid=(left+right)/2;
        if(f(mid)>0){
            right=mid;
        }else{
            left=mid;
        }
    }
    return mid;
}



int main() {
    scanf("%lf",&a);
    printf("%.2f",calSqrt());
    return 0;
}

4.6 two pointers

#include <cstdio>

const int MAXN = 100000;
int n, k, a[MAXN];

int twoSum() {
    int counter = 0;
    int i = 0, j = n - 1;
    while (i < j) {
        if (a[i] + a[j] == k) {
            counter++;
            i++;
            j--;
        } else if (a[i] + a[j] < k) {
            i++;
        } else {
            j--;
        }
    }
    return counter;
}

int main() {
    scanf("%d%d", &n, &k);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    printf("%d", twoSum());
    return 0;
}

#include <cstdio>

const int MAXN = 100000;
int n, a[MAXN];
int m, b[MAXN];
int merged[MAXN * 2];

void merge() {
    int i = 0, j = 0, cnt = 0;
    while (i < n && j < m) {
        if (a[i] < b[j]) {
            merged[cnt++] = a[i++];
        } else {
            merged[cnt++] = b[j++];
        }
    }
    while (i < n) {
        merged[cnt++] = a[i++];
    }
    while (j < m) {
        merged[cnt++] = b[j++];
    }
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    for (int i = 0; i < m; i++) {
        scanf("%d", &b[i]);
    }
    merge();
    for (int i = 0; i < n + m; i++) {
        printf("%d", merged[i]);
        if (i < n + m - 1) {
            printf(" ");
        }
    }
    return 0;
}

#include <cstdio>

const int MAXN = 1000;
int n, a[MAXN];
int merged[MAXN];

void merge(int l1, int r1, int l2, int r2) {
    int i = l1, j = l2, cnt = 0;
    while (i <= r1 && j <= r2) {
        if (a[i] < a[j]) {
            merged[cnt++] = a[i++];
        } else {
            merged[cnt++] = a[j++];
        }
    }
    while (i <= r1) {
        merged[cnt++] = a[i++];
    }
    while (j <= r2) {
        merged[cnt++] = a[j++];
    }
    for (i = 0; i < cnt; i++) {
        a[l1 + i] = merged[i];
    }
}

void mergeSort(int l, int r) {
    if (l < r) {
        int mid = (l + r) / 2;
        mergeSort(l, mid);
        mergeSort(mid + 1, r);
        merge(l, mid, mid + 1, r);
    }
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    mergeSort(0, n - 1);
    for (int i = 0; i < n; i++) {
        printf("%d", a[i]);
        if (i < n - 1) {
            printf(" ");
        }
    }
    return 0;
}

#include <cstdio>

const int MAXN = 1000;
int n, a[MAXN];
int mergedNums[MAXN];

int partition(int l, int r) {
    int temp = a[l];
    while (l < r) {
        while (l < r && a[r] > temp) {
            r--;
        }
        a[l] = a[r];
        while (l < r && a[l] <= temp) {
            l++;
        }
        a[r] = a[l];
    }
    a[l] = temp;
    return l;
}

void quickSort(int l, int r) {
    if (l < r) {
        int pos = partition(l, r);
        quickSort(l, pos - 1);
        quickSort(pos + 1, r);
    }
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    quickSort(0, n - 1);
    for (int i = 0; i < n; i++) {
        printf("%d", a[i]);
        if (i < n - 1) {
            printf(" ");
        }
    }
    return 0;
}

4.7其他高效技巧与算法

#include <cstdio>

int main() {
    int n, x, numZero = 0;
    scanf("%d", &n);
    long long result = 0;
    for (int i = 0; i < n; i++) {
        scanf("%d", &x);
        if (x == 1) {
            result += numZero;
        } else {
            numZero++;
        }
    }
    printf("%lld", result);
    return 0;
}

#include <cstdio>
const int MAXN = 100000;
int n,k,a[MAXN];
int mergedNums[MAXN];

int partition(int l, int r) {
    int temp = a[l];
    while (l < r) {
        while (l < r && a[r] > temp) {
            r--;
        }
        a[l] = a[r];
        while (l < r && a[l] <= temp) {
            l++;
        }
        a[r] = a[l];
    }
    a[l] = temp;
    return l;
}

void quickSort(int l, int r) {
    if (l < r) {
        int pos = partition(l, r);
        quickSort(l, pos - 1);
        quickSort(pos + 1, r);
    }
}
int main() {
    scanf("%d %d", &n,&k);
    for(int i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    quickSort(0, n - 1);
    for(int i=0;i<n;i++)
    {
        if(i==k-1)
        printf("%d",a[i]);
    }
    return 0;
}

Polaris北极星少女
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【算法笔记自学】第 3 章 入门篇（1）——入门模拟
qq_62704693的博客
07-02 254
自己写的题解标答。
【算法笔记自学】第 5 章 入门篇（3）——数学问题
qq_62704693的博客
07-06 2068
【代码】【算法笔记自学】入门篇（3）——数学问题。
算法基础课——第一章 基础算法（二）
m0_62021646的博客
07-04 625
高精度问题其实只有使用 C++ 编程语言的同学需要关注，使用 java 或 python 编程语言的同学不需要太多关注。因为 java 有大整数类，python 自带的数据范围默认就是无限大，而 C++ 没有相对应的处理大整数运算的数据结构。高精度的考察主要分为四种：高精度{加法A+B减法A−B乘法A×a除法A÷a高精度\begin{cases}加法 \quad A+B \\ 减法 \quad A-B \\ 乘法 \quad A \times a \\ 除法 \quad A \div a\end{cases
算法入门(3)
yxLijun的博客
01-10 1083
在上一篇博客基础，我又写了一些算法小程序，同样这些程序来自《算法竞赛入门经典》这本书，强烈推荐这本书，对学习算法帮助很大。 得分问题 问题描述：给出一个由O和X组成的串（长度为1～80），统计得分。每个O的得分为目前连续出现 的O的个数，X的得分为0。例如，OOXXOXXOOO的得分为1+2+0+0+1+0+0+1+2+3。 #include<stdio.h> #include<iostream>
【秋招笔试】8.11大疆秋招(第二套)-测开岗
清隆学长的博客
08-12 874
> 🍒 本专栏已收集 70+套笔试题，`笔试真题` 会在第一时间跟新 > > 🍹 近期会进行一波价格调整，没订阅的朋友抓紧冲！！！
四十一、【人工智能】【机器学习】- Bayesian Logistic Regression算法模型
技术分享、程序员趣事、行业趋势等内容！
08-19 586
监督学习（Supervised Learning）是机器学习中的一种主要方法，其核心思想是通过已知的输入-输出对（即带有标签的数据集）来训练模型，从而使模型能够泛化到未见的新数据上，做出正确的预测或分类。在监督学习过程中，算法“学习”的依据是这些已标记的例子，目标是找到输入特征与预期输出之间的映射关系。Bayesian Logistic Regression是一种统计建模方法，它结合了Logistic回归的原理和贝叶斯统计的框架。
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 746
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
数据结构——排序（4）：归并排序+计数排序
2301_81888634的博客
08-16 1129
至此我们学习了顺序表、链表、栈、队列、二叉树、排序，初阶数据结构完结~撒花！我们C++见！！
【Python】生成二维迷宫的算法
HarryXYC的博客
08-16 289
基于Pygame和PIL的迷宫生成器
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 443
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
24/8/18算法笔记 目标导向强化学习
yyyy2711的博客
08-18 408
初始化DDPG模型data = {'over':[],#Data采样函数#采样结果sample = {'over':[],#采样N个数据#随机一局游戏#随机游戏中的一步，这里除了最后一步#提取数据#设置fake goal#随机选择step后面的某一步#以后面某个步的状态为一个伪的终点，也就是希望先走到这里再说#求二范数mod = [#再自己重新计算reward和over#以伪终点构建新的state#计算最后10个数据reward_sum的值。
算法之递归和迭代
qq_28576837的博客
08-16 350
斐波那契数列（Fibonacci sequence），又称黄金分割数列，这个数列最早是由印度数学家提出来的。如果是用迭代，那么就是用循环从前往后计算，前两个数是固定的，先根据前两个数可以计算出第三个数，然后把第三个数和第二个数再赋值给之前的变量，再相加即可。使用递归时，如果要计算第100个数，那么要先直到第99和第98个，要知道第99个和第98个，就要分别进行递归，直到最后一层，再返回递归回来进行计算。这个序列的前几项是这样的：0,1,1,2,3,5,8,13,21,34,⋯。自然，用递归函数最容易实现。
湖北师范大学-Python程序设计-3.1 中国古代数学问题(project)
最新发布
柠檬喝汽水的博客
08-19 438
唐朝时，一斗酒的斗所采用的度量是小斗，也就是4斤，当时一斤取值范围大约在500多到600克左右，换算一下可知唐朝一斗酒的重量取值范围在2000克到2400克左右。有一座八层宝塔，每一层都有一些琉璃灯，每一层的灯数都是上一层的二倍，已知共有 765 盏琉璃灯，计算并输出每层各有多少盏琉璃灯。输出不超过 n 且满足条件的物品个数 m，如果有多个解，则分行输出，每行一个解；第二行输出 2 个浮点数，依次为小鼠和大鼠打洞的距离，单位为尺，保留小数点后 1 位数字。一个浮点数 f，表示李白的酒壶原来有 f 斗酒。
二分查找5️⃣-山脉数组的封顶索引
2202_75331338的博客
08-15 317
对于山峰来说，我们会发现封顶的值是最大，对于封顶左边来说，后一个数比前一个数大；◦ 如果 mid 位置呈现上升趋势，说明我们接下来要在 [mid + 1, right] 区间继续搜索；◦ 如果 mid 位置呈现下降趋势，说明我们接下来要在 [left, mid - 1] 区间搜索；◦ 因此，我们可以遍历数组内的每一个元素，找到某一个元素比两边的元素大即可。本题的数组不是有序数组，但我们依然可以使用二分查找，原因是因为我们发现了。输入：arr = [0,2,1,0]◦ 峰顶的特点：比两侧的元素都要大。
算法笔记：空间填充曲线
qq_40206371的博客
08-17 257
六次迭代的希尔伯特曲线：
算法：DFS之记忆化搜索
一名还在努力学习技术的程序员的博客
08-18 558
本篇博客是关于 记忆化搜索 的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
算法刷题day35|动态规划：121. 买卖股票的最佳时机、122. 买卖股票的最佳时机 II、123. 买卖股票的最佳时机 III
qq_61936886的博客
08-15 506
同样dp[i][1]取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);那么dp[i][0]应该选所得现金最大的，所以dp[i][0] = max(dp[i - 1][0], -prices[i]);一定是选最大的，所以 dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);那么dp[i][1]究竟选 dp[i-1][0] - prices[i]，还是dp[i - 1][1]呢？
WebGoC题解(18) 630.电线杆(2019NHOI小乙)
2301_78151773的博客
08-15 196
小C在农场的附近看到有n颗电线杆排成一行，相邻之间距离为20。它们高度可能不一样，但高度相同的电线杆顶端有电线连接。如下面示意图中，电线杆用粗细为6的垂直直线画，电线用粗细为2的水平直线画。给定每个电线杆的高度，请用goc编程画出示意图。从当前的电线杆向后找，如果找到有和当前电线杆一样高的，把它们连线，并继续循环。第二行n个正整数，依次表示从左到右的电线杆的高度。第一行1个正整数n，2<=n<=15。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Polaris北极星少女

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值