[NWPU2018]国庆训练赛第七场 2018-10-07

最新推荐文章于 2023-03-24 10:17:38 发布
最新推荐文章于 2023-03-24 10:17:38 发布
阅读量150 收藏
点赞数
文章标签： NWPU
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/int_lyy/article/details/82968483
版权

B - The E-pang Palace
这个题是队友写的，但WA了。检查了一下她的代码，她没有考虑完全包含的情况
因为点的个数很少，直接暴力枚举。先记录下所有矩形，然后挨个检查是否符合情况。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cstdlib>

using namespace std;

int n,cor[100][2],cnt;

struct node
{
	long long area;
	int weizhi[5][2];
}juxing[500000];

int main()
{
	scanf("%d",&n);
	while(n)
	{
		cnt=0;
		memset(juxing,0,sizeof(0));
		memset(cor,0,sizeof(0));
		for(int i=1;i<=n;i++)scanf("%d%d",&cor[i][0],&cor[i][1]);
		if(n<8)
		{
			    printf("imp\n");
		    	scanf("%d",&n);
		    	continue;
		}
		for(int i=1;i<=n;i++)
			for(int j=i+1;j<=n;j++)
		        for(int k=j+1;k<=n;k++)
		            for(int g=k+1;g<=n;g++)
		            {
			                 if(cor[i][0]==cor[j][0])
			                 {
			                 	if((cor[i][1]==cor[k][1])&&(cor[g][1]==cor[j][1])&&(cor[g][0]==cor[k][0]))
			                 	{
			                 		cnt++;
			                 		juxing[cnt].area=(cor[i][1]-cor[j][1])*(cor[i][0]-cor[k][0]);
			                 		juxing[cnt].weizhi[1][1]=cor[i][1];juxing[cnt].weizhi[1][0]=cor[i][0];
			                 		juxing[cnt].weizhi[2][1]=cor[k][1];juxing[cnt].weizhi[2][0]=cor[k][0];
			                 		juxing[cnt].weizhi[3][1]=cor[j][1];juxing[cnt].weizhi[3][0]=cor[j][0];
			                 		juxing[cnt].weizhi[4][1]=cor[g][1];juxing[cnt].weizhi[4][0]=cor[g][0];
			                 	}
			                 	if((cor[i][1]==cor[g][1])&&(cor[k][0]==cor[g][0])&&(cor[k][1]==cor[j][1]))
			                 	{
			                 		cnt++;
			                 		juxing[cnt].area=(cor[i][1]-cor[j][1])*(cor[i][0]-cor[g][0]);
			                 		juxing[cnt].weizhi[1][1]=cor[i][1];juxing[cnt].weizhi[1][0]=cor[i][0];
			                 		juxing[cnt].weizhi[2][1]=cor[g][1];juxing[cnt].weizhi[2][0]=cor[g][0];
			                 		juxing[cnt].weizhi[3][1]=cor[j][1];juxing[cnt].weizhi[3][0]=cor[j][0];
			                 		juxing[cnt].weizhi[4][1]=cor[k][1];juxing[cnt].weizhi[4][0]=cor[k][0];
			                 	}
			                 }
			                 if(cor[i][0]==cor[k][0])
			                 {
			                 	if((cor[i][1]==cor[j][1])&&(cor[g][1]==cor[k][1])&&(cor[g][0]==cor[j][0]))
			                 	{
			                 		cnt++;
			                 		juxing[cnt].area=(cor[i][1]-cor[k][1])*(cor[i][0]-cor[j][0]);
			                 		juxing[cnt].weizhi[1][1]=cor[i][1];juxing[cnt].weizhi[1][0]=cor[i][0];
			                 		juxing[cnt].weizhi[2][1]=cor[j][1];juxing[cnt].weizhi[2][0]=cor[j][0];
			                 		juxing[cnt].weizhi[3][1]=cor[k][1];juxing[cnt].weizhi[3][0]=cor[k][0];
			                 		juxing[cnt].weizhi[4][1]=cor[g][1];juxing[cnt].weizhi[4][0]=cor[g][0];
			                 	}
			                 	if((cor[i][1]==cor[g][1])&&(cor[j][1]==cor[k][1])&&(cor[j][0]==cor[g][0]))
			                 	{
			                 		cnt++;
			                 		juxing[cnt].area=(cor[i][1]-cor[k][1])*(cor[i][0]-cor[g][0]);
			                 		juxing[cnt].weizhi[1][1]=cor[i][1];juxing[cnt].weizhi[1][0]=cor[i][0];
			                 		juxing[cnt].weizhi[2][1]=cor[g][1];juxing[cnt].weizhi[2][0]=cor[g][0];
			                 		juxing[cnt].weizhi[3][1]=cor[k][1];juxing[cnt].weizhi[3][0]=cor[k][0];
			                 		juxing[cnt].weizhi[4][1]=cor[j][1];juxing[cnt].weizhi[4][0]=cor[j][0];
			                 	}
			                 }
			                 if(cor[i][0]==cor[g][0])
			                 {
			                 	if((cor[i][1]==cor[j][1])&&(cor[k][1]==cor[g][1])&&(cor[k][0]==cor[j][0]))
			                 	{
			                 		cnt++;
			                 		juxing[cnt].area=(cor[i][1]-cor[j][1])*(cor[i][0]-cor[k][0]);
			                 		juxing[cnt].weizhi[1][1]=cor[i][1];juxing[cnt].weizhi[1][0]=cor[i][0];
			                 		juxing[cnt].weizhi[2][1]=cor[j][1];juxing[cnt].weizhi[2][0]=cor[j][0];
			                 		juxing[cnt].weizhi[3][1]=cor[g][1];juxing[cnt].weizhi[3][0]=cor[g][0];
			                 		juxing[cnt].weizhi[4][1]=cor[k][1];juxing[cnt].weizhi[4][0]=cor[k][0];
			                 	}
			                 	if((cor[i][1]==cor[k][1])&&(cor[j][1]==cor[g][1])&&(cor[j][0]==cor[k][0]))
			                 	{
			                 		cnt++;
			                 		juxing[cnt].area=(cor[i][1]-cor[j][1])*(cor[i][0]-cor[k][0]);
			                 		juxing[cnt].weizhi[1][1]=cor[i][1];juxing[cnt].weizhi[1][0]=cor[i][0];
			                 		juxing[cnt].weizhi[2][1]=cor[k][1];juxing[cnt].weizhi[2][0]=cor[k][0];
			                 		juxing[cnt].weizhi[3][1]=cor[g][1];juxing[cnt].weizhi[3][0]=cor[g][0];
			                 		juxing[cnt].weizhi[4][1]=cor[j][1];juxing[cnt].weizhi[4][0]=cor[j][0];
			                 	}
			                 }
			         }
		    if(cnt<=1)
		    {
		    	printf("imp\n");
		    	scanf("%d",&n);
		    	continue;
		    }
			long long ans=0;
			for(int i=1;i<=cnt;i++)
			    for(int j=i+1;j<=cnt;j++) 
				{
					int ximax=max(juxing[i].weizhi[1][0],juxing[i].weizhi[2][0]);
					int ximin=min(juxing[i].weizhi[1][0],juxing[i].weizhi[2][0]);
					int yimax=max(juxing[i].weizhi[1][1],juxing[i].weizhi[3][1]);
					int yimin=min(juxing[i].weizhi[1][1],juxing[i].weizhi[3][1]);
					int xjmax=max(juxing[j].weizhi[1][0],juxing[j].weizhi[2][0]);
					int xjmin=min(juxing[j].weizhi[1][0],juxing[j].weizhi[2][0]);
					int yjmax=max(juxing[j].weizhi[1][1],juxing[j].weizhi[3][1]);
					int yjmin=min(juxing[j].weizhi[1][1],juxing[j].weizhi[3][1]);
					if((ximin>xjmax)||(xjmin>ximax)||(yimin>yjmax)||(yjmin>yimax))
					{
						if(ans<juxing[i].area+juxing[j].area)ans=juxing[i].area+juxing[j].area;
					}
					if((ximin>xjmin)&&(ximax<xjmax)&&(yimin>yjmin)&&(yimax<yjmax))
					{
						if(ans<juxing[j].area)ans=juxing[j].area;
					}
					if((ximin<xjmin)&&(ximax>xjmax)&&(yimin<yjmin)&&(yimax>yjmax))
					{
						if(ans<juxing[i].area)ans=juxing[i].area;
					}
				}
		    if(ans==0)
		    {
		    	printf("imp\n");
		    	scanf("%d",&n);
		    	continue;
		    }
		    printf("%I64d\n",ans);  
		    scanf("%d",&n);
	}
	return 0;
}

E - Song Jiang’s rank list
模拟，用结构体+自定义sort

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=300;
struct hero
{
	string name;
	int kill;
	int mar;
	int mir;
	bool operator <(const hero& b) const {
	if(kill==b.kill) return name<b.name;
	return kill>b.kill;
	}
};
hero h[maxn];
int n;
int main()
{
	while(1)
	{	
		
		scanf("%d",&n);
		if(!n) break;
		for(int i=1;i<=n;i++)
			{
				cin>>h[i].name>>h[i].kill;
				h[i].mir=1;
			}
		sort(h+1,h+1+n);
		h[0].kill=2147483647;
		for(int i=1;i<=n;i++)
		{
			cout<<h[i].name<<' '<<h[i].kill<<endl;
			if(h[i].kill==h[i-1].kill)  h[i].mir=h[i-1].mir+1; 
		//	printf("h   %d  %d\n",i,h[i].mir);
		}
		int q;
		scanf("%d",&q);
		for(int i=1;i<=q;i++)
		{	
			string s;
			cin>>s;
			for(int j=1;j<=n;j++)
				if(h[j].name==s)
				{	
					if(h[j].mir==1)
					printf("%d\n",j);
					else
					printf("%d %d\n",j-h[j].mir+1,h[j].mir);
				}
		}
	}
	return 0;
}

*I - Little Zu Chongzhi’s Triangles
此题队友用的是状态压缩DP，%%%
我的想法是根据海伦公式(S = sqrt(p * (p - a) * (p - b) * (p - c))),贪心求解

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cstdlib>
#include<cmath>

using namespace std;

const int M=(1<<12);

struct node
{
	double area;
	int stick;
	node()
	{
		area=0;
		stick=0;
	}
}tri[300];
int n,sti[20],trn;
double f[222][M];

int change(int i,int j,int k)
{
	i--;j--;k--;
	return (1<<i)+(1<<j)+(1<<k);
}

double check(int i,int j,int k)
{
	double ret=0;
/*	double p=i+j+k;
	p/=2;
	ret=sqrt(p*(p-i)*(p-j)*(p-k));*/
	double angle=i*i+j*j-k*k;
	double aa=i*j;
	angle=angle/(2*aa);
	angle=sqrt(1-angle*angle);
	ret=0.5*aa*angle;
	return ret;
}

double maxx(double a,double b)
{
	if(a>b)return a;
    else return b;
}

int main()
{
	scanf("%d",&n);
	while(n)
	{
		memset(sti,0,sizeof(sti));
		memset(tri,0,sizeof(tri));
		for(int i=1;i<=n;i++)scanf("%d",&sti[i]);
		trn=0;
		for(int i=1;i<=n;i++)
		    for(int j=i+1;j<=n;j++)
		         for(int k=j+1;k<=n;k++)
		         {
		         	if(i!=j&&j!=k&&i!=k)
		         	{
		         		if((sti[i]+sti[j]>sti[k])&&(sti[i]+sti[k]>sti[j])&&(sti[k]+sti[j]>sti[i]))
		         		{
		         			trn++;
		         			tri[trn].stick=change(i,j,k);
		         			tri[trn].area=check(sti[i],sti[j],sti[k]);
		         		}
		         	}
		         }
		if(trn==0)
		{
			printf("0.00\n");
			scanf("%d",&n);
			continue;
		}
		if(trn==1)
		{
			printf("%.2lf\n",tri[1].area);
			scanf("%d",&n);
			continue;
		}
		memset(f,0,sizeof(f));
		int tem=(1<<n)-1;
		for(int i=1;i<=trn;i++)
		{
			for(int j=0;j<tem;j++)
			{
				f[i][j]=f[i-1][j];
				if(!(j&tri[i].stick))
				{
					f[i][j]=maxx(f[i-1][j],f[i-1][j^tri[i].stick]+tri[i].area);
				}
			}
		}
		double ans=0;
		for(int i=0;i<tem;i++)
		{
			ans=maxx(ans,f[trn][i]);
		}
		printf("%.2lf\n",ans);
		scanf("%d",&n);
	}
	return 0;
}

K - How Many Maos Does the Guanxi Worth
久违的图论
n最大才30，随便搞…
枚举每个点（1和n除外），删除该点求最短路径，求出这n-2个最短路径的值的最大值
最短路用迪杰斯特拉

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int ans;
const int maxm=2000;
const int maxn=50;
struct edges
{
	int w;
	int f; int t;
	int nx;
};
edges e[maxm];
int head[maxn];
bool vis[maxn];
long long dp[maxn];
int n,m;
long long dfs(int x,int y,int f)
{
	
	if(y==n) {
				return 0;
			}	
	vis[y]=1;
	for(int i=head[y];~i;i=e[i].nx)
	{	
		
		if(e[i].t!=f&&e[i].t!=x)
		{
			if(vis[e[i].t]) dp[y]=min(dp[y],dp[e[i].t]+e[i].w);
			else
			dp[y]=min(dp[y],e[i].w+dfs(x,e[i].t,y));	
		}		
	}
	return dp[y];
}
int main()
{
	while(cin>>n)
	{		
			
			int tot=0;
			memset(head,-1,sizeof(head));
			scanf("%d",&m);
			if(n==0&&m==0) break;
 			for(int i=1;i<=m;i++)
			{
				int a,b,c;
				scanf("%d%d%d",&a,&b,&c);
				tot++;
				e[tot].f=a; e[tot].t=b; e[tot].w=c;
				e[tot].nx=head[a]; head[a]=tot;
				tot++;
				e[tot].f=b; e[tot].t=a; e[tot].w=c;
				e[tot].nx=head[b]; head[b]=tot;			
			}
			long long ANS=0;
			for(int i=2;i<n;i++)
				 {	for(int j=1;j<=n;j++)
				 	dp[j]=2147483647;
				 	dp[n]=0;
				 	memset(vis,0,sizeof(vis));	
				 	dfs(i,1,-1);
					ANS=max(ANS,dp[1]);
				 }
			if(ANS>=2147483647) printf("Inf\n");
			else
			printf("%I64d\n",ANS);
	}
	return 0;
}

A - Dogs’ Candies
这个题有点坑…其实就是暴力，但一开始没注意时间，不敢下手。比赛期间没有做出来。后来发现时间是30s不是3s…论审题的重要性

int_lyy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
20190402训练赛
curry___的博客
04-04 351
Problem A Patches 1 s, 256 MB 【Description】Carlos is very concerned with the environment. Whenever possible, he tries to use less polluting means of transport. He recently got a job close to home a...
[NWPU2018]国庆训练赛第六场 2018-10-06
int_lyy的博客
10-07 122
逐渐进入状态… A - A Curious Matt 模拟冒泡排序 #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;cmath&gt; #include&lt;algorithm&gt; using namespace std; struct node { int t,x; }a[10005]; int T,n; int...
[NWPU2018]国庆训练赛第五场 2018-10-05
int_lyy的博客
10-05 179
[NWPU2018]国庆训练赛第五场 2018-10-05 A Relic Discovery 签到题，就是又没队友写的快，卜开心 #include &amp;amp;lt;iostream&amp;amp;gt; using namespace std; int main() { int t,n; cin&amp;amp;gt;&amp;amp;gt;t; while(t--) { cin&amp;
[NWPU2018]国庆训练赛第三场 2018-10-03
int_lyy的博客
10-07 106
A - Thickest Burger 模拟 ，理解题意即可 #include&lt;iostream&gt; #include&lt;cstdio&gt; using namespace std; int t; int a,b; int main() { scanf("%d",&amp;t); for(int i=1;i&lt;=t;i++) { scanf("%d%d",&amp;a...
[NWPU2018]国庆训练赛第一场 2018-10-01
int_lyy的博客
10-07 134
先总结一下：这场比赛，大家基本上都在火车上，效率相对较低。G是在最后半小时内写过的，算是一个提醒吧。不到最后一刻不要放弃！ G - Dancing Stars on Me 求出这个多边形的重心，然后计算该点到每个顶点的距离是否相等。求重心就是把各个点坐标求平均值。 #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cmath&g...
使用NWPU VHR-10数据集训练Faster R-CNN模型
大彤小忆的博客
12-06 4209
一、所需文件下载链接   使用Faster R-CNN算法在NWPU VHR-10数据集上实现目标检测。   使用Faster R-CNN算法在VOC2007数据集上实现目标检测的详细步骤→Windows10+Faster-RCNN-TensorFlow-Python3-master+VOC2007数据集。 一、所需文件下载链接 Faster R-CNN源码及操作步骤Github链接→Faster-RCNN-TensorFlow-Python3。 Faster-RCNN-TensorFlow-Pytho.
使用Faster R-CNN训练自己的数据_NWPU_VHR-10数据集
蚂蚁搬家
12-18 4207
本文转自：初沏的茶 http://blog.csdn.net/chuqidecha/article/details/58148611  1. 主要步骤 VOC2007格式数据集制作 训练集均值文件计算 网络选择 faster r-cnn源码修改 运行  2. VOC2007格式数据集制作 1. 修改VOCinit.m (1) 数据集名称 第12行VOC2007改为自己的文件夹名...
基于yolov5的遥感图像目标检测（NWPU VHR-10）
weixin_51467037的博客
03-24 8410
最近在做毕设，感觉网上信息不是很全，把自己的训练过程写下来供做这个方向的友友学习。
使用YOLOV2训练NWPUVHR-10dataset数据集
斌的博客
05-20 3813
1.将positive所有数据送入训练 import xml.etree.ElementTree as ET import pickle import os from os import listdir, getcwd from os.path import join from PIL import Image import re import random def convert(s
【创新发文无忧】Matlab实现阿基米德优化算法AOA-DELM的故障诊断算法研究.rar
08-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
财务报表执行目录.xlsx
08-09
工资表，财务报表，对账表，付款申请，财务报告，费用支出表 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
基于Simulink仿真探讨TCSC对系统暂态稳定性影响
08-09
晶闸管的可控串联补偿装置（TCSC）是近年来串联补偿新技术的代表，是FACTS系统的主要组成部分。由于采用晶闸管代替传统串联补偿装置的机械开关，是TCSC可以快速、连续地改变所补偿输电线路的等值电抗，因而在一定的运行范围内，可以将此线路的输送功率控制为期望的常数。在暂态过程中，通过快速改变线路等值电抗，从而提高系统的稳定性。 从负载电压和功率波形中可以看出，没有安装TCSC时，发生三相故障，故障切除后，系统的功率发生较大振动，负载电压也包含很大的谐波分量，系统发生了功率震荡，不能符合电力系统的运行要求。若在系统中安装TCSC，当系统在0.2s发生故障时，电压和功率急剧减小，故障切除后，系统电压、有功功率和无功功率很快稳定下来。（请使用R2020及以上版本）
C#上位机与PLC通讯源码 C#与三菱PLC通讯MC协议
08-09
C#上位机与PLC通讯源码 C#与三菱PLC通讯MC协议
【BP预测】基于和声搜索算法优化BP神经网络实现风速数据预测附matlab代码.rar
08-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
假山叠水CAD合集及水池施工图.rar
08-09
假山叠水CAD合集及水池施工图
Linux操作实验－Linux初步了解+命令格式+命令操作
最新发布
08-09
1. 初步了解 Linux 的命令格式； 2. 学习如何连接 Linux 系统； 3. 实习几个文件维护命令； 4. 学会如何得到帮助信息； 5. 练习 echo、 whoami、 whatis、 hostname、 whereis、 set、 uptime、 alias、 cat 等几个常用的 Linux 命令。 6. 练习用 vi 编辑器编辑文本文件；
机器学习面试知识点总结
08-09
该文档总结了机器学习面试所需要的知识点以及常见问题和对应的答案分析
python热门面试题文档.docx
08-09
Python作为当今最流行的编程语言之一，其面试题涵盖了广泛的主题，从基础知识到高级概念，再到实际项目应用。一个全面的Python面试准备资源概述应当包括以下几个方面： 首先，基础语法与数据类型是任何Python面试的基石。这包括变量定义、数据类型（如整数、浮点数、字符串、列表、元组、字典、集合等）的理解与操作、条件语句、循环结构以及函数定义与调用。面试者需要熟练掌握这些基础知识，并能灵活应用于解决实际问题。 其次，面向对象编程（OOP）概念在Python面试中占据重要地位。理解类与对象、继承、封装、多态等OOP原则，以及如何在Python中实现这些概念，是面试成功的关键。此外，对于异常处理、模块与包的使用、文件操作等进阶知识，面试者也应有一定的掌握。 随着Python在数据分析、机器学习、Web开发等领域的广泛应用，面试中也可能涉及这些领域的特定问题。例如，在数据分析方面，可能会问到Pandas、NumPy等库的使用；在机器学习方面，则可能涉及scikit-learn、TensorFlow等框架的基础知识和应用；而在Web开发领域，Django、Flask等框架的了解也是加分项
nwpu vhr-10 yaml
01-21
NWPU VHR-10 是西北工业大学研发的一种用于高分辨率遥感图像处理的数据集。该数据集采用YAML（YAML Ain't Markup Language）格式进行描述和存储。 YAML 是一种可读性高、表达能力强的数据序列化格式，常用于将数据以一种简洁、人类可读的方式表示。YAML 不仅可以表示简单的键值对数据，还可以嵌套多个键值对以形成复杂的数据结构。在 NWPU VHR-10 数据集中，YAML 可以用于描述每张图像的元数据、标注信息和其他相关属性。 数据集的YAML文件可以包含图像的路径、尺寸、通道数等基本信息，还可以包含标注框的位置、类别、置信度等详细信息。通过使用YAML格式，研究人员和开发者可以方便地读取和解析数据集的相关信息，从而为高分辨率遥感图像处理的任务提供更好的支持。 NWPU VHR-10 数据集作为一个广泛应用于目标检测、图像分类、语义分割等领域的数据集，使用YAML格式来描述数据集的属性和标注信息，使得数据集的使用者可以方便地获取图像和标注的相关信息，并且支持各种图像处理和机器学习算法的研究和开发。 总之，NWPU VHR-10数据集使用YAML格式的文件来描述和存储图像的属性和标注信息，方便数据集的使用者获取数据集的相关信息并进行相关的研究和开发工作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值