【算法笔记】【排序】ICPC训练联盟2021寒假冬令营（4、5）笔记

最新推荐文章于 2023-03-27 15:35:53 发布
最新推荐文章于 2023-03-27 15:35:53 发布
阅读量317 收藏 1
点赞数 1
分类专栏： 算法竞赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43502713/article/details/112963987
版权

PPT：第五章 排序

三个基础排序
两数交换
void swap(int* x, int* y) {
	int temp;
	temp = *x;
	*x = *y;
	*y = temp;
}
冒泡排序
//冒泡排序 每次遍历两两比较，将最大元素互换到最后一个位置
void bubble_sort(int arr[], int len) {
	for (int i = 0; i < len-1; i++) {
		for (int j = 0; j < len - 1 - i; j++) {//第一轮换由于是两两比较，一定会吧最大的元素换到最后面，则下一轮可不与最后一个元素比较
			if (arr[j] > arr[j + 1])
				swap(&arr[j], &arr[j + 1]);
		}
	}
}
插入排序
//直接插入排序 每次遍历将未排序数组第一个数插入到已排序数组中
void insertion_sort(int arr[], int len)
{
	for (int i = 1; i < len; i++) {//从下标为1的元素开始选择合适的位置插入
		int key = arr[i];//key为本轮要插入的数据
		int j = i - 1;//比较区间为[0,i-1]的数据，即已排列好的递增序列
		while (j >= 0 && key < arr[j]) {//从已经排序的序列最右边的开始比较，找到比其小的数（key应插入在第一个比key小的数的后面）。
		//当key>=arr[j]或j<0时跳出，因为与key比较的是递增序列，我们只需找到比key小的第一个数
			arr[j + 1] = arr[j];//将比key大的数(arr[j])逐次往后移，给key让空
			j--;
		}
		arr[j + 1] = key;//将key插入到比key小的数的后一个位置。
	}
}
选择排序
//选择排序 每次遍历找到最小元素，把他放到已排序数组的最后一个位置
void selection_sort(int arr[], int len) {
	int i, j;
	for (i = 0; i < len - 1; i++) {
		int min = i;
		for (j = i + 1; j < len; j++) {//找到最小的元素下标
			if (arr[j] < arr[min])
				min = j;
		}
		swap(&arr[min], &arr[i]);//把最小的元素与第i个位置互换
	}
}

总。

#include<algorithm>
#include<iostream>
using namespace std;
void swap(int* x, int* y) {
	int temp;
	temp = *x;
	*x = *y;
	*y = temp;
}
//直接插入排序 每次遍历将未排序数组第一个数插入到已排序数组中
void insertion_sort(int arr[], int len)
{
	for (int i = 1; i < len; i++) {//从下标为1的元素开始选择合适的位置插入
		int key = arr[i];//key为本轮要插入的数据
		int j = i - 1;//比较区间为[0,i-1]的数据，即已排列好的递增序列
		while (j >= 0 && key < arr[j]) {//从已经排序的序列最右边的开始比较，找到比其小的数（key应插入在第一个比key小的数的后面）。
		//当key>=arr[j]或j<0时跳出，因为与key比较的是递增序列，我们只需找到比key小的第一个数
			arr[j + 1] = arr[j];//将比key大的数(arr[j])逐次往后移，给key让空
			j--;
		}
		arr[j + 1] = key;//将key插入到比key小的数的后一个位置。
	}
}
//冒泡排序 每次遍历两两比较，将最大元素互换到最后一个位置
void bubble_sort(int arr[], int len) {
	for (int i = 0; i < len-1; i++) {
		for (int j = 0; j < len - 1 - i; j++) {//第一轮换由于是两两比较，一定会吧最大的元素换到最后面，则下一轮可不与最后一个元素比较
			if (arr[j] > arr[j + 1])
				swap(&arr[j], &arr[j + 1]);
		}
	}
}
//选择排序 每次遍历找到最小元素，把他放到已排序数组的最后一个位置
void selection_sort(int arr[], int len) {
	int i, j;
	for (i = 0; i < len - 1; i++) {
		int min = i;
		for (j = i + 1; j < len; j++) {//找到最小的元素下标
			if (arr[j] < arr[min])
				min = j;
		}
		swap(&arr[min], &arr[i]);//把最小的元素与第i个位置互换
	}
}
int main() {
	int n = 10;
	int arr[10] = { 2,67,34,56,3,45,60,86,32,5 };
	//insertion_sort(arr, n);
	//bubble_sort(arr, n);
	selection_sort(arr, n);
	for (int i = 0; i < n; i++)
		cout << arr[i] << " ";
	cout << endl;
	return 0;
}
例题
4.G POJ 2388 Who’s in the Middle 排个序就行了
4.H UVA 299 Train Swapping 冒泡排序记一下交换次数
#include <iostream>
using namespace std;
#define N  10007 
int sort(int arr[], int n) {
	int num = 0;
	for (int i = 0; i < n - 1; i++) {
		for (int j = 0; j < n - 1 - i; j++) {
			if (arr[j] > arr[j + 1]) {
				num++;
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	return num;
}
int main() {
	int arr[N];
	int num = 0;
	int n;
	cin >> n;
	while (n--) {
		cin >> num;
		for (int i = 0; i < num; i++)
			cin >> arr[i];
		cout << "Optimal train swapping takes " << sort(arr, num) << " swaps." << endl;
	}
	return 0;
}
4.I POJ 1007 DNA Sorting 冒泡找一下有多少逆序对，再根据逆序对数排一下序即可

##做题一定要细心！！！！！！！！！！m和n又搞混了。。。。。

#include <iostream>
#include<string>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;
#define N  107 


string s[N];
void insertion_sort(int arr[], int len){
	for(int i=1;i<len;i++){
		int key=arr[i];
		string keys;
		keys=s[i];
		int j=i-1;
		while(j>=0&&key<arr[j]){
			arr[j+1]=arr[j];
		    s[j+1]=s[j];
			j--;
		}
		arr[j+1]=key;
		s[j+1]=keys;
	}
}
int main(){
	int n,m;
	int nixu[N];
	cin>>n>>m;
	getchar();
	for(int k=0;k<m;k++){
		cin>>s[k];
		int ans=0;
    	for(int i=0;i<n-1;i++){
			for(int j=i+1;j<n;j++){
				if(s[k][i]>s[k][j])
					ans++;
			}
		}
		nixu[k]=ans;
	}
	insertion_sort(nixu,m);
	for(int i=0;i<m;i++){
		cout<<s[i]<<endl;
	}
	return 0;
}
更新
归并排序

在这里插入图片描述
在这里插入图片描述

参考代码

 void Merge(int r[],int temp[],int s,int m,int t){
//将数组r的两个连续的有序序列：第s到第m个元素，第m+1到第t个元素，合并产生一个有序序列：第s到第t个元素的有序序列	
	int i=s;
	int j=m+1;//i,j是两个连续的有序序列的开始位置 
	int k=i;//k 临时数组temp的下标
	while(i<=m&&j<=t){
		if(r[i]<=r[j])//谁小就先把谁放进去 
			temp[k++]=r[i++];
		else
			temp[k++]=r[j++];
	}	
		while(i<=m)//剩余部分依次放入临时数组（俩while只会执行一个） 
			temp[k++]=r[i++];
		while(j<=t)
			temp[k++]=r[j++];
		for(i=s;i<=t;i++)//将临时数组中的内容拷贝回原数组中 
			r[i]=temp[i];				
}
void MergeSort(int r[],int temp[],int s,int t){//分解：把 n 个元素组成的序列r分解为n 个长度为1的有序子表；
if(s==t)//分解为长度为1的有序子表 
	return;
else
{
	int m=(s+t)/2;
	MergeSort(r,temp,s,m) ;//对左边序列进行递归
	MergeSort(r,temp,m+1,t);//对右边序列进行递归
	Merge(r,temp,s,m,t);//合并  即r[s]~r[m]合并成有序数列 
 } 
	
}
例题例题
5.A POJ1084 Brainman

利用归并排序求出逆序对即可。
最近脑子不太好使，老是看错输入输出，自认为第二行前面的10是数组的第一个元素，还寻思了半天为啥 10 1 2 3 4 5 6 7 8 9逆序对是0。。。。。。
还有Dev函数没有返回值的话不会报错，，提交的时候一直显示语法错误，一直以为是头文件的事情，没看到代码里有个毫无关系的函数还没有返回值。。。。

题解题解

在这里插入图片描述

#include<iostream>
#include<cstdio>
using namespace std;
#define N  1007 
int num = 0;
int arr[N];
int temp[N];
void Merge(int a[], int temp[], int l, int m, int r) {
	int i = l;
	int j = m + 1;
	int k = l;
	while (i <= m && j <= r) {
		if (a[i] <= a[j]) {
			temp[k++] = a[i++];
		}
		else {
			temp[k++] = a[j++];
			num += m - i + 1;
		}
	}
	while (i <= m)
		temp[k++] = a[i++];
	while (j <= r)
		temp[k++] = a[j++];
	for (i = l; i <= r; i++)
		a[i] = temp[i];
}
void MergeSort(int a[], int temp[], int l, int r) {
	if (l == r)
		return;
	else {
		int m = (l + r) / 2;
		MergeSort(a, temp, l, m);
		MergeSort(a, temp, m + 1, r);
		Merge(a, temp, l, m, r);//合并 
	}
}

int main() {
	int T;
	cin >> T;
	for (int t = 1; t <= T; t++) {
	
		num = 0;
		int len = 0;
		cin>>len;
		for(int i=0;i<len;i++)
			cin>>arr[i];
		MergeSort(arr, temp, 0, len - 1);
		cout << "Scenario #" << t << ":" << endl;
		cout << num << endl << endl;

	}

	return 0;
}
5.B POJ 2299，ZOJ 2386，UVA 10810 Ultra-QuickSort

同上题，求出逆序对即可
注意取值范围，结果要设为longlong

#include<iostream>
#include<cstdio>
using namespace std;
#define N  500007 
//int num = 0;
long long num = 0;
int arr[N];
int temp[N];
void Merge(int a[], int temp[], int l, int m, int r) {
	int i = l;
	int j = m + 1;
	int k = l;
	while (i <= m && j <= r) {
		if (a[i] <= a[j]) {
			temp[k++] = a[i++];
		}
		else {
			temp[k++] = a[j++];
			num += m - i + 1;
		}
	}
	while (i <= m)
		temp[k++] = a[i++];
	while (j <= r)
		temp[k++] = a[j++];
	for (i = l; i <= r; i++)
		a[i] = temp[i];
}
void MergeSort(int a[], int temp[], int l, int r) {
	if (l == r)
		return;
	else {
		int m = (l + r) / 2;
		MergeSort(a, temp, l, m);
		MergeSort(a, temp, m + 1, r);
		Merge(a, temp, l, m, r);//合并 
	}
}

int main() {
	int len = 0;
	while(scanf("%d",&len)!=EOF&&len!=0) {
		num = 0;
		for(int i=0;i<len;i++)
			cin>>arr[i];
		MergeSort(arr, temp, 0, len - 1);
		cout << num << endl;
	}
	return 0;
}
快速排序

在这里插入图片描述

又对比初始数组和最终数组，我们可以看出初始将a[0]作为pivot,从右向左找第一个比pivot小的数,a[high]，赋值给a[0],再从左向右找第一个比pivot大的数,a[low],赋值到a[high]的位置上,最后再将pivot,既原始a[0]处的值赋值到a[low]的位置上。最后返回新的low的下标作为下一次的基准值。在这里插入图片描述
参考代码

Parition(int a[],int low,int high){
	int pivot=a[low];//设下标low为“基准” 
	while(low<high){
		while(low<high&&a[high]>=pivot){//从右向左找比pivot小的值
			high--;	 
		} 
		a[low]=a[high];
		while(low<high&&a[low]<=pivot){//从左向右找比pivot大的第一个值 
			low++;
		}
		a[high]=a[low]; 
	}
	a[low]=pivot;//
	return low;//返回新 low 的位置，作为分界 
}
void QuickSort(int a[],int low,int high){
	if(low<high){
		int pivot=Parition(a,low,high);
		QuickSort(a,low,pivot-1);
		QuickSort(a,pivot+1,high);
	}
}

俩O(nlog2n)的排序 总。

#include <iostream>
#include<string>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;
#define N  10 
void Merge(int r[],int temp[],int s,int m,int t){
//将数组r的两个连续的有序序列：第s到第m个元素，第m+1到第t个元素，合并产生一个有序序列：第s到第t个元素的有序序列	
	int i=s;
	int j=m+1;//i,j是两个连续的有序序列的开始位置 
	int k=i;//k 临时数组temp的下标
	while(i<=m&&j<=t){
		if(r[i]<=r[j])//谁小就先把谁放进去 
			temp[k++]=r[i++];
		else
			temp[k++]=r[j++];
	}	
		while(i<=m)//剩余部分依次放入临时数组（俩while只会执行一个） 
			temp[k++]=r[i++];
		while(j<=t)
			temp[k++]=r[j++];
		for(i=s;i<=t;i++)//将临时数组中的内容拷贝回原数组中 
			r[i]=temp[i];				
}
void MergeSort(int r[],int temp[],int s,int t){//分解：把 n 个元素组成的序列r分解为n 个长度为1的有序子表；
if(s==t)//分解为长度为1的有序子表 
	return;
else
{
	int m=(s+t)/2;
	MergeSort(r,temp,s,m) ;//对左边序列进行递归
	MergeSort(r,temp,m+1,t);//对右边序列进行递归
	Merge(r,temp,s,m,t);//合并  即r[s]~r[m]合并成有序数列 
 } 	
}
Parition(int a[],int low,int high){
	int pivot=a[low];//设下标low为“基准” 
	while(low<high){
		while(low<high&&a[high]>=pivot){//从右向左找比pivot小的值
			high--;	 
		} 
		a[low]=a[high];
		while(low<high&&a[low]<=pivot){//从左向右找比pivot大的第一个值 
			low++;
		}
		a[high]=a[low]; 
	}
	a[low]=pivot;//
	return low;//返回新 low 的位置，作为分界 
}
void QuickSort(int a[],int low,int high){
	if(low<high){
		int pivot=Parition(a,low,high);
		QuickSort(a,low,pivot-1);
		QuickSort(a,pivot+1,high);
	}
}
int main() {
	int arr[N]={5,64,36,343,6,24,1,4,8,29};
	int temp[N]={0};
	//MergeSort(arr,temp,0,9);
	QuickSort(arr,0,9); 
	for(int i=0;i<10;i++)
		cout<<arr[i]<<" ";
	return 0;
}
例题例题
5.C Who’s in the Middle

//这次要用快速排序做一下，输出中间数即可

#include<iostream>
#include<cstdio>
using namespace std;
#define N  500007 
int a[N];
int partition(int l, int r) {
	int pivot = a[l];
	while (l < r) {
		while (l < r && pivot <= a[r])
			r--;
		a[l] = a[r];
		while (l < r && pivot >= a[l])
			l++;
		a[r] = a[l];
	}
	a[l] = pivot;
	return l;
}
void quick_sort(int l, int r) {
	if (l < r) {
		int m = partition(l, r);
		quick_sort(l, m);
		quick_sort(m + 1, r);
	}
}
int main() {
	int n;
	while (~scanf("%d", &n)) {
		for (int i = 0; i < n; i++)
			scanf("%d", &a[i]);
		quick_sort(0, n - 1);

		cout << a[n / 2] << endl;
	}
	return 0;
}
利用sort函数排序

例题
5.D sort 给你n个整数，请按从大到小的顺序输出其中前m大的数。

#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
#define N 1000007 
int a[N];
bool cmp(int a,int b){
	return a>b;

}
int main() {
	int n,m;
	while(cin>>n>>m){
		for(int i=0;i<n;i++)
			scanf("%d",&a[i]);
		sort(a,a+n,cmp);
		for(int i=0;i<m-1;i++)
			cout<<a[i]<<" ";
		cout<<a[m-1]<<endl;	
	}
	return 0;
}
__0077
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
冒泡排序与快速排序比较
weixin_46102896的博客
12-31 9389
1.简单描述冒泡排序 1.1什么是冒泡排序？ 冒泡排序是一种简单的排序方法，它的基本思想是：通过相邻两个元素之间的比较和交换，使较大的元素逐渐从前面移向后面（升序），就像水底下的气泡一样逐渐向上冒泡，所以被称为“冒泡”排序。 1.2逻辑图表示 1.3算法逻辑实现 2.简单描述快速排序 2.1什么是快速排序？ 快速排序(Quick Sort) 是对冒泡排序的一种改进方法，在冒泡排序中，进行元素的...
5.java数组
qq_25830587的博客
12-19 417
6. 数组、排序和查找 1. 名词解释 数组：数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。 2. 数组的使用 2.1 动态初始化 数据类型 数组名[] = new 数据类型[大小]; 例子： //第一种动态分配方式 double score[] = new double[5]; //第二种动态分配方式，先声明数组，再new分配空间 double score[]; score = new double[4]; 2.2 静态初始化 数据类型 数组名[] = {元素值，元素值…}; 例子：
交换排序—冒泡排序和快速排序
weixin_60718941的博客
08-02 2098
本文主要讲解冒泡排序和归并排序。
排序系列--冒泡排序和快排
m0_52347974的博客
02-01 772
冒泡排序和快排
冒泡排序与快速排序
kjl167的博客
07-28 1180
冒泡排序与快速排序
胡凡的算法笔记和上机训练两本书
02-27
胡凡的算法笔记和上机训练两本书是深入学习算法的重要资源，对于计算机科学与技术、软件工程等领域的学生和从业者来说，具有很高的参考价值。这两本书分别详细讲解了算法的基础理论以及实践应用，旨在提升读者的算法...
Algorithm_Lecture_Note:这些是来自ICPC Sinchon 2021冬季算法训练营高级课程的讲义。
05-21
这些是在ICPC Sinchon 2021冬季算法训练营高级班中举办的讲座的讲座材料。 作为一名讲师，我总共进行了六个主题。 解决问题快速傅立叶变换 凸壳技巧 分而治之优化 质心分解 持久段树 八卦树 Lecture_Note以针对...
算法笔记-胡凡
09-26
算法是解决问题的关键，书中涵盖了排序算法（如冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序）、搜索算法（如线性搜索和二分搜索）以及图论中的经典算法（如深度优先搜索和广度优先搜索）。这些算法...
算法.ACM ICPC中的数学.ppt
05-26
算法.ACM ICPC中的数学.ppt
AlgorithmNote:《算法笔记》
03-16
《算法笔记》是一本深入探讨计算机算法的书籍，主要针对C++编程语言进行阐述。算法在计算机科学中占据着核心地位，是解决复杂问题的有效工具。C++是一种强大的、通用的编程语言，以其高效性和灵活性著称，尤其适合...
常用排序:冒泡排序与快速排序详解，看完这篇就够了！风马博客
Renfr的博客
07-01 1874
常用排序:冒泡排序与快速排序详解。 在排序算法中，冒泡排序和快速排序可以算是排序算法入门必会的两种排序了，今天和大家来分析一下如何快速理解并掌握这两种排序。首先冒泡排序是初学者最常用的排序，所以我们先来详解下冒泡排序。 1.冒泡排序 冒泡排序，看字面意义就是有大泡泡和小泡泡在水中同时上浮，而大的泡泡就上升的快，小的泡泡就上升的相对较慢，从而产生了一定的速度差，这就产生了大的泡泡在小的泡泡上面，也就是按从一定的大小顺序排好了顺序。当然，这里的比喻和冒泡排序有点不同，冒泡排序是针对数值排序，且算法是有稍微
［数据结构］冒泡排序、快速排序
最新发布
weixin_53027918的博客
03-27 1196
通过我们的分析，就算快速排序在理想情况下，每次都取到中间值作为key值，每次往下递归也必须开辟上一层递归层数的两倍的函数栈帧，而栈的空间是有限的，如果遇到数据比较大的序列，有可能会导致栈溢出，所以这也是快速排序可以优化的一个点。：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。经过一次单趟排序，最终使得key左边的数据全部都小于key，key右边的数据全部都大于key。
【数据结构的排序算法3】冒泡排序与快速排序详解
m0_62332997的博客
02-05 473
冒泡排序与快速排序的讲解以及代码演示，非常详细，需要学习的可以当作参考
算法之简单排序(冒泡排序，选择排序，插入排序)
weixin_40523463的博客
04-04 312
一，冒泡排序BubbleSort 算法思想 冒泡排序是一种比较简单的排序算法，在每一次循环中，依次比较相邻的两个元素的大小，每次循环把最大的值交换到右边，最终完成排序。 排序过程 无序数组：2，3，9，5，4，1 第一趟排序：2，3，9，5，1，4（第一次循环开始） 第二趟排序：2，3，9，1，5，4 第三趟排序：2，3，1，9，5，4 第四趟排序：2，1，3，9，5，4 第五趟排序：1，2，...
七大排序之：冒泡排序和快速排序
m0_64761752的博客
10-29 337
七大排序之：冒泡排序和快速排序
排序问题
57
07-04 2430
目录 冒泡排序 插入排序 归并排序 快速排序 堆排序 性能分析 总结 衡量一个排序算法的优劣，主要会从以下 3 个角度进行分析： 1．时间复杂度，具体包括，最好时间复杂度、最坏时间复杂度以及平均时间复杂度。 2．空间复杂度，如果空间复杂度为 1，也叫作原地排序。 3．稳定性，排序的稳定性是指相等的数据对象，在排序之后，顺序是否能保证不变。 冒泡排序 从第一个数据开始，依次比较相邻元素的大小。如果前者大于后者，则进行交换操作，把大的元素往后交换。通过多轮迭代，直到没有交换操作
排序算法之冒泡，选择，插入,快排
David的博客
08-12 690
例如：待排序序列     5,4,3,7,2,7,（目的是升序排列）  1.冒泡排序： 排n趟，每趟只是将原序列变得相对有序，随着趟数的增加，有序性也得到提升，最终完全有序  5,4,3,7,2,7 第一趟，5&gt;4,交换---》   4,5,3,7,2,7                5&gt;3 ,交换---》 4,3,5,7,2,7                5&lt;...
五种排序方法（选择、冒泡、快排、插入、希尔）
weixin_33995481的博客
07-29 190
*/ * Copyright (c) 2016，烟台大学计算机与控制工程学院 * All rights reserved. * 文件名：text.cpp * 作者：常轩 * 微信公众号：Worldhello * 完成日期：2016年7月29日 * 版本号：V1.0 * 内容：C语言排序方法 */ 一.选择排序： 基本原理： 一次选定数组中的每一个数，记下当前位置并...
详解冒泡排序和快速排序
吴纯玲的博客
06-12 1233
冒泡排序 算法思想：通过两两比较相邻值，如果反序则交换位置，这样较小的元素会冒泡到前面，较大的元素会沉淀至尾部 实现思路： （1）设置一个哨兵，默认值为数组长度-1； *（2）通过i++循环两两比较相邻值，反序则交换位置，这样较小的元素会冒泡到前面，较大的元素会沉淀至尾部；一次循环过后，最大的元素会沉淀到尾部，哨兵位置-1 *（3）继续i++循环直到哨兵位置为0 ...
ACM-ICPC算法模板1
08-04
ACM-ICPC算法模板1是一份针对计算机科学竞赛，尤其是国际大学生程序设计竞赛（ACM-ICPC）的通用算法模板。这份模板涵盖了广泛的IT基础知识，包括但不限于： 1. **图论**：算法中经常用到图的表示（邻接矩阵、邻接表...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值