浅谈K短路算法（KSP）之一（A*算法求解）

最新推荐文章于 2024-07-19 13:59:11 发布
最新推荐文章于 2024-07-19 13:59:11 发布
阅读量2.9k 收藏 12
点赞数 3
分类专栏： K短路 文章标签： 算法 dijkstra 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/robator/article/details/111194469
版权

对于具有n个顶点和m条边且边的权值非负的简单图（无重边和环），K短路，是指的起点s到终点t的最短路径中第k个最小的。K短路分为有限制的K短路和无限制的K短路，有限制的K短路是指求得的路径中不含有回路（路径上任何一个节点的出现次数不大于1次），无限制的K短路则对求得的路径中没有要求，这篇博客先讨论前者，后讨论后者。

本篇博客中使用的无向图实例如下图所示

如上图所示，求解节点A至节点C的K短路。本篇博客主要使用经典的A*算法。

1 A*算法简介。

通用图搜索路径常用的启发式搜索

f(n)=g(n)+h(n)

其中f(x)称为评估函数，g(n)为从初始节点S到节点n的实际代价，h(n)是从节点n到目标节点T的最 优路径的评估代价，被称为启发式函数，它体现了问题的启发式信息。

由此引出A*算法：

定义评估函数：

f^{*}(n)=g^{*}(n)+h^{*}(n)

在上式中，g*(n)是从起始节点S到节点n的最短路径的代价，h*(n)是从节点n到目标节点T的最短路径的代价。shi因为有可能最短路径还没找到，所以一般情况下有g(n)>=g*(n)

  同时h(n)<=h*(n)，就是说h(n)是h*(n)的下界，这个限制确保A*算法可以找到最优解。对于一个问题，启发式函数h(n)的设计通常有多种，一般有如下关系

（1）h(n)=0，A*算法退化为dijkstra算法，可以找到最优解

（2）h(n)<=h*(n)，A*算法可以找到最优解，不过收敛速度较慢，h(n)越小，收敛速度越慢

（3）h(n)=h*(n)，A*算法可以找到最优解，收敛速度很快，扩展的节点全是最短路径上的点

（4）h(n)>h*(n)，A*算法不一定能找到最优解，但收敛速度很快。

2 求解过程

用A*算法求解K短路问题，可以概括为如下步骤。首先，定义评估函数

f(n)=g(n)+h(n)，其中g(n)是从起始节点S到达节点的n的实际代价，定义为从起始节点S到达节点n的路径上所经过边的权值之和，h(n)为从节点n到达目标节点的最短路径的代价，记为dis[]，实现的方法是构建反图，以终点T为起点对全图进行一次dijkstra算法得到（在这里，h(n)=h*(n)），以上图为例，从节点C到各个节点的dis值如下：

dis[C]=0,dis[B]=2,dis[A]=3,dis[D]=4

定义如下结构：queue[]为优先级队列，count[]为节点出现的次数。这样f(n)代表从起点节点到目标节点的最短路径的费用。刚开始，queue[]只有起始节点，算法步骤如下

（1）从优先级队列选取队头元素，如果fx值相同则选取gx较小的

（2）用队头元素去更新其子女节点的f(n)值，并将子女节点入队

（3）当取出的队头元素是终点时，计算其出现次数，若是K次，算法结束，否则将其子女入队。

对上图，求解节点A到节点C的K短路，具体的求解过程如下：

(b)queue[]={A}

g(1)=0,h(1)=dis[A]=3;

f(1)=g(1)+h(1)=0+3=3;

(b)节点A出队，其子女节点B、C、D入队，

 用f(1)更新其子女节点B、C、D的f值

g(2)=g(1)+w(A-B)=0+1=1(w(A-B)代表边A-B的权值)

h(2)=dis[B]=2；

f(2)=g(2)+h(2)=1+2=3；对应节点为B

g(3)=g(1)+w(A-C)=0+4=4;

h(3)=dis[C]=0;

f(3)=g(3)+h(3)=4+0=4；对应节点为C；

g(4)=g(1)+w(A-D)=0+1=1;

h(4)=dis[D]=4;

f(4)=g(4)+h(4)=1+4=5;对应节点为D

queue[]={2,3,4}

(c)节点2出队，B的子女节点A、C入队

g(5)=g(2)+w(B-A)=1+1=2;

h(5)=dis[A]=3;

f(5)=g(5)+h(5)=5; 对应节点为A

g(6)=g(2)+w(B-C)=1+2=3;

h(6)=dis[C]=0；

f(6)=g(6)+h(6)=3; 对应节点为C

queue[]={6,3,5,4}，

(d)节点6出队，节点C的子女A、B、D 入队

节点6对应的节点是C，即终点C，也是C的第一次出队，即第一短路，count[C]++

g(7)=g(6)+w(C-A)=3+4=7;

h(7)=dis[A]=3;

f(7)=g(7)+h(7)=10;

g(8)=g(6) +w(C-B)=3+2=5;

h(8)=dis[B]=2;

f(8)=g(8)+h(8)=5+2=7,对应节点为B

g(9)=g(6)+w(C-D)=3+6=9;

h(9)=dis[D]=4;

f(9)=g(9)+h(9)=9+4=13;

queue[]={3,5,4,8,7,9}

(e)节点3出队，节点3（节点C）的子女A、B、D入队

节点3对应的图中节点即是节点C，是终点，这是终点的第2次出队，代表第2短路，count[C]++

以此类推，求出最短路

当节点较多时,优先级队列的元素较多,所以优先级队列的容量尽量大些.

3 实现

用C++编写，g++编译，实现无出错处理，仅供参考

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <bits/stdc++.h>
using namespace std;
#define MAXNODE 64  //最大顶点数，顶点是字母，存储的是从大写字母A开始的64个字符
#define MAXEDGE 100 //最大边数
class EdgeNode{ //图用邻接表存储，这是邻接表中的边表节点，类中成员均为pulic,便于访问和修改
	public:
		EdgeNode(char to='Z',int weight=1):to(to),weight(weight){next=NULL;}
		EdgeNode(const EdgeNode &en){
			this->to=en.to;
			this->weight=en.weight;
			this->next=en.next;
			
		}
		EdgeNode & operator=(const EdgeNode &en)
		{
			this->to=en.to;
                        this->weight=en.weight;
                        this->next=en.next;
                        
		}
		~EdgeNode(){}
		char to;
		int weight;
		EdgeNode *next;
};
class VertexNode{ //邻接表中的顶点表节点，所有成员均为public
	public:
	VertexNode(char name='Z',EdgeNode *firstEdge=NULL):name(name),firstEdge(firstEdge) {}
	char name;
	EdgeNode *firstEdge;
	~VertexNode(){}

};
VertexNode vn[MAXNODE],vnr[MAXNODE];//正图、反图，用正向和反向的邻接表表示
int dis[MAXNODE];//每个节点的dis值
int createGraph(int n,int m,int flag){ //构造图
	char from,to;
	int weight;
for(int i=0;i<m;i++)
{
cin>>from>>to>>weight;
if(flag==0){ //构造无向图，无向图中正图和反图是一样的

	if(vn[from-65].name=='Z') vn[from-65].name=from;
	if(vn[to-65].name=='Z') vn[to-65].name=to;
	EdgeNode *edge_new=new EdgeNode(to,weight);
	EdgeNode *p=vn[from-65].firstEdge;
	if(vn[from-65].firstEdge==NULL){
		vn[from-65].firstEdge=edge_new;
	}
	else 
	{
		while(p->next!=NULL)
			p=p->next;
		 p->next=edge_new;//一个边有两个边表节点， 添加第一个边表节点

	}
	EdgeNode *edge_new2=new EdgeNode(from,weight);
	p=vn[to-65].firstEdge;
	if(vn[to-65].firstEdge==NULL)
                vn[to-65].firstEdge=edge_new2;
        else
        {
                while(p->next!=NULL)
                        p=p->next;
		 p->next=edge_new2;//一条边有两个边表节点，添加第二个边表节点

        }
}
else {                            //有向图

	if(vn[from-65].name=='Z') vn[from-65].name=from;
        if(vn[to-65].name=='Z') vn[to-65].name=to;//这个点没有出边，这个点保存在数组里

        EdgeNode *edge_new=new EdgeNode(to,weight);
        EdgeNode *p=vn[from-65].firstEdge;
        if(vn[from-65].firstEdge==NULL)
                vn[from-65].firstEdge=edge_new;
        else
        {
                while(p->next!=NULL)
                        p=p->next;
		p->next=edge_new;//添加正图中的边表节点
        }

if(vnr[to-65].name=='Z') vnr[to-65].name=to;
if(vnr[from-65].name=='Z') vnr[from-65].name=from; //这个点没有出边，这个点要保>存在数组里

EdgeNode *edge_new2=new EdgeNode(from,weight);
p=vnr[to-65].firstEdge;
        if(vnr[to-65].firstEdge==NULL)
                vnr[to-65].firstEdge=edge_new2;
        else
        {
                while(p->next!=NULL)
                        p=p->next;
		p->next=edge_new2;//添加反图中的边表节点
        }

}
}
if(flag==0)
for(int i=0;i<MAXNODE;i++) //无向图的复制
       vnr[i]=vn[i];

return 1;
}

bool dijkstra(char from,char to) //dijkstra 求解dis值
{
//V为顶点集，S为已求得最短距离的点的集合，T为余下点的集合，初始时，S={},T=V,T用带pair的vector实现，当T为空时，代表所有点均以到达集合S中，算法结束，当一个节点从集合T中迁移至S中时，这个顶点对应的距离值便是此节点到起点的最短距离值。

long max=1e8;
char parent[MAXNODE];//更新时记录每个节点的父节点，只有这个距离更新，此节点的父>节点才会更新
for(int i=0;i<MAXNODE;i++)
        parent[i]='Z';
vector<pair<int,char>>queue;//不是优先级队列,第一个代表距离，第二个代表节点
for(int i=0;i<MAXNODE;i++)
{
        if(vnr[i].name!='Z'){
                if(vnr[i].name==to)
                queue.push_back(make_pair(0,vnr[i].name));//起点的距离值为0
                else
                queue.push_back(make_pair(max,vnr[i].name));//初始化其他点的距离>为max
        }
}

vector<pair<int,char>>::iterator it=queue.begin();
while(!queue.empty())
{
        sort(queue.begin(),queue.end());//对剩余节点进行排序
        vector<pair<int,char>>::iterator tmp=queue.begin();
	if(dis[queue.begin()->second-65]>queue.begin()->first)
	dis[queue.begin()->second-65]=queue.begin()->first;//队首的距离值为最短的，而且要出队
        EdgeNode *p=vnr[tmp->second-65].firstEdge;
        int d=tmp->first;//存储此节点出队的距离值
        while(p!=NULL)
        {

                for(it=queue.begin()+1;it!=queue.end();it++)
                {
                        if(p->to==it->second)//在T中找到要更新的点
                        {
                                if(d+p->weight<it->first)
                                { //需要更新,相等的话则不再更新,相等代表距离一样，但经过的顶点更多
                                        it->first=d+p->weight;
                                        parent[it->second-65]=tmp->second; //更>新父节点
                                }

                                break;
                        }
                }
                p=p->next;
        }
        queue.erase(queue.begin());//删除起始节点
}
Edg
}
bool Astar(char from,char to,int k)//A star 求解K短路
{
	if(vn[from-65].name=='Z'){
		cout<<"node doesn't exist"<<endl;
		return 0;
	}
int count=0;//终点出现次数
int i=1,loc=1;    //步数
int fx[100],gx[100],hx[100];//A star中的函数值,即扩展的节点序列，暂定100
char node[100];             //存储节个序列中实际对应的每个节点
int parent[100];           //每个序列的父节点
for(int i=0;i<100;i++)
{
	fx[i]=0;
	gx[i]=0;
	hx[i]=0;
	node[i]='Z';
	parent[i]=0;
}
//添加父节点
priority_queue<pair<pair<int,int>,int>,vector<pair<pair<int,int>,int>>,greater<pair<pair<int,int>,int>>>q; //优先级队列，第一个int存储的是fx值，第二个存储的是gx值，第三个存储的是扩展的节点序列，满足当fx值相等时，则选择fx较小的
gx[1]=0;hx[1]=dis[from-65];node[1]=from;//先将起点入队
fx[1]=gx[1]+hx[1];
parent[0]=-1;  //便于沿着父节点数组一直找到起点
parent[1]=0;
q.push(make_pair(make_pair(fx[1],gx[1]),1));
while(!q.empty())
{
	pair<pair<int,int>,int>tmp=q.top();
	q.pop();
	if(node[tmp.second]==to){//找到终点
	vector<char>vec;//用vector存储此条路径
	int now=tmp.second;
	while(parent[now]!=-1)
	{
		vec.push_back(node[now]);//节点存入vector
		now=parent[now];//找到父节点
	}
		EdgeNode *p=vn[node[tmp.second]-65].firstEdge;
        while(p!=NULL) //将子女节点入队
        {
                ++loc;
                gx[loc]=gx[tmp.second]+p->weight;
                node[loc]=p->to;
		parent[loc]=tmp.second;
                hx[loc]=dis[p->to-65];
                fx[loc]=gx[loc]+hx[loc];
                q.push(make_pair(make_pair(fx[loc],gx[loc]),loc));
		p=p->next;

        }

		count++;
	        if(count==k){
			 vector<char>::iterator it=vec.end()-1;
	        	cout<<"k="<<k<<endl;
        		for(it;it>=vec.begin();it--)
                	cout<<*it<<"  ";//输出节点序列
        		cout<<fx[tmp.second]<<endl;//输出总的fx值
			break;//找到第K短路，退出
		}
		
	}
	else 
	{//将当前节点的子女节点入队
	EdgeNode *p=vn[node[tmp.second]-65].firstEdge;
	while(p!=NULL)
	{
		++loc;
		gx[loc]=gx[tmp.second]+p->weight;
		node[loc]=p->to;
		parent[loc]=tmp.second;
		hx[loc]=dis[p->to-65];
		fx[loc]=gx[loc]+hx[loc];
		q.push(make_pair(make_pair(fx[loc],gx[loc]),loc));
		p=p->next;
		
	}
	}

}
return 1;
}

int main(void)
{
	memset(dis,10000,sizeof(dis));
	int n,m;
	int flag=0; //0代表无向图，1代表有向图
	cin>>n>>m>>flag;//输入顶点数、边数、属性
	createGraph(n,m,flag);
	char from,to;
	int k;
	cin>>from>>to>>k;//输入起点、终点和K
	dijkstra(from,to);
	Astar(from,to,k);
	exit(0);
}

 

以上图为例，输入：

4 5 0   //边数、顶点数和是否有向
A B 1  //边
B C 2
A C 4
A D 1
D C 6
A C 3 //起点、终点和K值

输出如下：

k=3
  A  B  A  B  C  5


从输出看出，第3条短路确实有环，从A-B-A，所以这个算法是解决的无限制的K短路，在实际应用中，有环的K短路一般情况下没有意义。导致出现环路的原因是某一个路径一个节点的出现次数大于1次，如果我们在当前节点入队之前，将当前节点实际对应的节点与所有的父节点相比较，如果父节点中已经出现过此节点，则表明当前节点对应节点在路径的出现次数大于1次，当前节点不再入队，则得到的路径便是没有环路。因此在每个结点入队前，判断此节点路径上的所有父节点是否与当前节点的对应节点相同，是，则不再入队。这样一来，优先级队列容量相对于前者要小。将上面代码q.push(make_pair(make_pair(fx[loc],gx[loc]),loc));的内容修改为：

                int result=1; //先设定没有相同的
                int now=tmp.second;
                while(parent[now]!=-1)
                {
                        if(node[now]==p->to) //父节点中找到当前节点相同的
                        {
                                result=0;
                                break;
                        }
                        now=parent[now];
                }
                if(result)
                q.push(make_pair(make_pair(fx[loc],gx[loc]),loc));

因为在无环的K短路中，K值是有限制的，即一个图，无环短路的路径数量有个上线值，在Astar函数返回前添加如下代码：

if(count<k)
        cout<<"K max:"<<count<<endl;


代表大于k max值后的路径均找不到。

 

 

 

参考资料：

(1)https://zhuanlan.zhihu.com/p/34665151

(2)https://www.cnblogs.com/shuaihui520/p/9623597.html

 

 

 

   

robator
关注
  • 3
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
基于A*算法的KSP问题求解
xiaohejun
07-24 307
#include <bits/stdc++.h> using namespace std; constexpr int INF = 1e9; vector<int> H; // h(x) void LoadTopo(vector<vector<int>> &topo, int nodeNum) { topo.resize(nodeNum + 1); int u, v, w; // while (cin >>
java实现K条最短路（KSP）
11-03
Java实现K条最短路径（KSP）是图论中的一个重要问题，特别是在计算机科学和网络优化领域。KSP问题旨在找到图中任意两个节点之间的K条具有不同权重的最短路径，而不仅仅是单条最短路径。这在物流、交通规划、网络设计...
最短路问题——K短路问题 / 次短路问题
指北针_N的博客
04-30 608
最短路问题——K短路问题 / 次短路问题。​ 最短路问题中的非常著名的Dijkstra算法、Floyd-Warshall算法以及经典的练习题，大家可以去下面的链接看哈。 Dijkstra算法、Floyd-Warshall算法。A*算法 给定一个图，定义起点𝑠和终点𝑡，以及数字𝑘；求𝑠到𝑡的第𝑘短的路。允许环路。相同长度的不同路径，也被认为是完全不同的。 思路：用A*算法求解。把从𝑠到𝑡的路径分为两部分：从𝑠到中间某个
浅谈K短路算法（KSP）之二（YEN .J算法求解）
robator的专栏
01-16 4159
对于具有n个顶点和m条边且边的权值非负的简单图（无重边和环），K短路，是指的起点s到终点t的最短路径中第k个最小的。K短路分为有限制的K短路和无限制的K短路，有限制的K短路是指求得的路径中不含有回路（路径上任何一个节点的出现次数不大于1次），无限制的K短路则对求得的路径中没有要求，这篇博客讨论后者。 本篇博客使用的图例如下图所示： 如上图所示，图中有6个顶点，9条边；即n=6，m=9； 算法主要使用了偏离路径的思想， ...
行为树实例
04-02
游戏AI行为树的示例，可做参考
行为树（Behavior Tree）详细介绍
热门推荐
weixin_42313598的博客
03-08 3万+
源自： https://www.gamasutra.com/blogs/ChrisSimpson/20140717/221339/Behavior_trees_for_AI_How_they_work.php 行为树是控制AI实体决策流程的分层节点树。 在树的范围内，叶子是控制AI实体的实际命令，而形成分支的则是各种类型的效用节点，它们控制AI沿着树走，以达到最适合这种情况的命令序列。 这些树可能非常深，节点调用执行特定功能的子树，允许开发人员创建行为库，这些行为库可以链接在一起以提供非常令人信服的AI行为
行为树（Behavior Tree）介绍
ronnie88597的博客
06-28 4047
在这篇文章中，我将介绍行为树及其所有术语，将其与有限状态机进行对比，分享一些例子和软件库，并一如既往地给你留下一些资源，如果你想了解更多。
行为树 Behavior Tree 原理 一
lq
01-18 1万+
行为树 Behavior Tree 原理 行为树 树形结构图如下一棵倒置的树 行为树采用节点描述行为逻辑，主要有：选择节点、顺序节点、并行节点、修饰节点、随机节点、条件节点、行为节点。一棵行为树表示一个AI逻辑。要执行这个 AI 逻辑，需要从根节点开始遍历整棵树，遍历执行的过程中，父节点根据自身的类型，确定需要如何执行、执行哪些子节点并继续执行，子节点执行完毕后，会将执行结果反馈给父节点。...............
BehaviorTree 行为树详解 完整版 （参考官方文档）
WDHDNRYX的博客
11-22 1万+
行为树，学习纯英文官方文档所作记录，英文不好的学者可以借此学习,文末放了官方文档和官方代码链接。
KDUANLU.zip_K._KSP_K短路_单亲遗传算法
09-19
在优化问题的求解领域，K短路问题（KSP，K Shortest Path Problem）是一个经典的网络流问题，广泛应用于物流配送、交通规划以及计算机网络设计等多个领域。该问题旨在寻找网络图中具有最短总长度的K条独立路径，使得...
ksp.rar_KSP_K短路遗传算法_distance_k shortest path_单亲遗传算法
09-20
《KSP_K短路遗传算法_distance_k_shortest_path_单亲遗传算法》 在计算机科学领域，特别是图论和优化问题中，K短路问题（K Shortest Paths, KSP）是一个经典的问题。它旨在寻找网络中两个节点之间的K条最短路径。...
ksp.zip_KSP_KSP算法 matlab_K短路_k-短路_k条最短路
09-21
本篇文章将围绕"KSP算法"（K Shortest Paths）在MATLAB环境下的实现进行深入探讨，同时结合提供的代码资源，帮助读者理解并掌握这一算法。 KSP算法，全称为k-Shortest Paths算法，其目标是找出图中任意两个顶点间的...
最短路径算法实现 k-shortest-paths
06-02
k-Shortest Paths（k-最短路径）则是在这个基础上进一步扩展，不仅求解一条最短路径，而是找出前k条最短路径。 1. Dijkstra算法：Dijkstra算法是最基本的单源最短路径算法，由荷兰计算机科学家艾兹格·迪科斯彻提出...
行为树（Behavior Tree）
weixin_43735634的博客
01-15 2075
在行为树中，根节点是AI的起点，通过遍历子节点来决策AI的行为。前两个通知其父节点其操作是成功还是失败。下次树被选择时，该节点将再次被选择，此时它将再次有机会成功，失败或继续运行。行为树（Behavior Trees）是一种在游戏开发中广泛使用的AI设计模式，主要用于描述AI的行为和决策过程，实现更加智能和自然的游戏AI。它由多个节点组成，每个节点代表一个行为或决策，按照特定的方式连接在一起，形成一个树状结构。行为树通过模拟树状结构来描述AI的行为和决策过程，使得AI的行为更加灵活、自然和智能。
行为树（Behavior Tree）实践（2）– 进一步的讨论
12-06 5972
原文：http://www.aisharing.com/archives/99 上次提到了一些行为树的基本概念，包括行为节点，控制节点（选择，序列，并行），这次来更多，更深入的讨论行为树的一些东西，如果对行为树不是很了解，请参看这里。 一. 关于选择节点的讨论 我们说过选择节点的定义是通过判断子节点的前提条件来选择一个节点执行，这就牵涉到判断顺序的问题，是自左向右，还是随
JavaScript数据结构——树的学习总结
gggggayu的博客
09-25 294
JavaScript数据结构——树的学习，主要对树的常见操作进行了总结
行为树介绍
封楚寒的博客
12-29 1690
原文链接 概论 Behavior Tree 库 主要用于机器人和游戏AI，代替有限元状态机 特性： 可以执行异步动作 可以在运行时创建树 可以把自定义的树转换成插件链接，在运行时动态加载 包含日志/优化架构可以可视化，记录回放分析状态转移 什么是行为树？ 行为树(BT)是一种结构在不同自动化终端任务之间转换，比如机器人或者游戏的虚拟实体 BT相对于FSM的优点： 他们本质上是分层的 他们的图形表示语言意义 他们更具表现力 为什么需要行为树？ 用于Component Based Software En
MATLAB-K最短路径算法(KSP,K-shortest pathes)
乐观的阿锡的博客
10-16 1万+
MATLAB-K最短路径算法(KSP,K-shortest pathes) MATLAB代码封装成函数，直接使用。 参考： k最短路径算法之Yen’s Algorithm 基于网络流量的SDN最短路径转发应用 算法背景 K 最短路径问题是最短路径问题的扩展和变形。1959 年，霍夫曼(Hoffman) 和帕夫雷(Pavley)在论文中第一次提出k 最短路径问题。 k 最短路径问题通常包括两类：有限制的k 最短路问题和无限制的K 最短路问题。 前者要求最短路径集合不含有回路，而后者对所求得的最短路径集合无限制
【18】输出字符菱形
最新发布
2301_78786609的博客
07-19 366
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值