A*算法 和 IDA*算法

最新推荐文章于 2024-06-04 09:06:47 发布
最新推荐文章于 2024-06-04 09:06:47 发布
阅读量1.1w 收藏 42
点赞数 9
分类专栏： 数据结构与算法 ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013009575/article/details/17140915
版权
A*算法概述：
     采用广度优先搜索策略，在搜索过程中使用启发函数，即有大致方向的向前进虽然目标有时候不是很明确。
A*算法核心：
     A*算法的关键在于启发函数，启发函数的优劣直接影响A*算法的效率。
          f(n)=g(n)+h(n); 
     这个式子中：f(n)表示从初始状态到目标状态的估测代价。
                         g(n)表示从初始状态到当前状态的代价（已经确定）。
                         h(n)表示从当前状态到目标状态的估测代价(预测）。
                 其中：h(n)的好坏直接影响评估函数的好坏。
                 一个好的f(n)总能明确指引算法前进的方向，可以迅速的到达目标状态。
            f*(n)=g*(n)+h*(n); 我们假设的从初始状态到目标状态的实际最小代价。
      这个式子中：f(n)表示从初始状态到目标状态的实际代价。
                         g*(n)表示从初始状态到当前状态的代价（已经确定）g*(n)和g(n)是相等的。
                         h*(n)表示从当前状态到目标状态的实际代价。
                若h(n)<=h*(n),则总能找到最优解。（当h(n)<h*(n)的时候，不可能找到一条从初始状态到达目标状态的路径。在搜索过程中使得h(n)逐渐接近h*(n)，最终找到最优路径。
          
优点：
      与广度优先搜索策略和深度优先搜索策略相比，A*算法不是盲目搜索，而是有提示的搜索。
缺点：
     该算法一般要使用大量的空间用于存储已搜索过的中间状态，防止重复搜索。
用途：
     从初始状态出发  =>经过一系列中间状态 =>最终到达目标状态（或者无法到达）。
     该算法用于经过中间状态时候的行进策略（其中的中间状态或者由题目给出，或者在前边已经推导得出）。


IDA*算法：
     迭代加深搜索算法，在搜索过程中采用估值函数，以减少不必要的搜索。
IDA*算法核心：
     设置每次可达的最大深度depth，若没有到达目标状态则加深最大深度。
     采用估值函数，剪掉f(n)大于depth的路径。
优点：
     使用回溯方法，不用保存中间状态，大大节省了空间。
缺点：
     重复搜索：回溯过程中每次depth变大都要再次从头搜索。
用途：
     和A*算法大致相同。
     


实际上，估测函数f(n)也是剪枝的一种。



acm应用A*和IDA*算法的实例：

 
 
 

hdu : 1043 ( Eight )  采用IDA*算法
      这里我在回溯过程中计算最大深度的时候不是每次加一而是有策略的进行增大（详见代码），如果是每次+1则687可见这个改进还是挺有效果的。
      在编程时候官方给的数据都通过了，但是总是不能ac，发愁了半天。灵机一动，我自己编写了一个自动生成测试数据代码，找到bug居然是sweap函数，就是两个数据进行交换，一定要先自我判重，即是不是自己和自己交换。 


#include <iostream>
#include <time.h> 
using namespace std;

struct ED_Node{
    int arr[9];
    int blankPos;
}ed_node;

ED_Node tag_node = {1,2,3,4,5,6,7,8,0,8};
bool isMove[][4]= {{0,1,0,1},{0,1,1,1}, {0,1,1,0},
                    {1,1,0,1},{1,1,1,1}, {1,1,1,0}, 
                    {1,0,0,1}, {1,0,1,1},{1,0,1,0}};

int move_distance[] = {-3,3,-1,1};
int ED_weight[]={0,1,2,6,24,120,720,5040,40320}; //康托展开式中各项权重
int str[400000]; //记录路径（存储direction的下标）
char direction[] ="udlr";
int direc[]={-1,1,2,-2};//防止向回走

int currStep;//记录已走步数，其对应的方向存放在str中
int Max_deepth; //最大深度，不断递增
int Min_Distance;


int get_h(const ED_Node& node)
{
    int current_x,current_y;
    int tag_x,tag_y;
    int sum_distance = 0;
    for ( int i=0; i<9; ++i ){
        if ( node.arr[i] != 0 ){
            tag_x = (node.arr[i]-1)/3;
            tag_y = (node.arr[i]-1)%3;
            current_x = i/3;
            current_y = i%3;
            sum_distance += abs(tag_x-current_x)+abs(tag_y-current_y);
        }
    }
    return sum_distance;
}

bool isSloved (const ED_Node& src,const ED_Node& tag)
{
    int countSrcNX = 0;
    int countTagNX = 0;
    for ( int i=0; i<9; ++ i ){
        for ( int j=0; j<i; ++j ){
            if ( src .arr[i]>0 ){
                countSrcNX = src .arr[j]>src.arr[i] ?
                    ( countSrcNX+1) :countSrcNX ;
            } 
            if ( tag .arr[i]>0 ){
                countTagNX = tag.arr[j]>tag.arr[i] ?
                   ( countTagNX+1) :countTagNX ;
            } 
        } 
    } 
    return (countSrcNX &1) == (countTagNX&1);
}

void sweap(int& a,int &b)
{
    if ( a!=b ){ //切记自我检测
        a = a+b;
        b = a-b;
        a = a-b;
    }
}

bool DFS()
{
    int temp_distance = get_h(ed_node);
    if (  temp_distance == 0 ){
        return true;
    }
    int estimateDistance = temp_distance+currStep;
    //cout<<"estimateDistance::"<<estimateDistance<<endl;
     Min_Distance = Max_deepth>estimateDistance ? Min_Distance :
                (Min_Distance<estimateDistance ? estimateDistance:Min_Distance);
    if ( estimateDistance>Max_deepth ){
        return false;
    }
    for ( int i=0; i<4; ++i ){
        
        if ( !isMove[ed_node.blankPos][i] || !(direc[str[currStep]] +direc[i]) ){
            continue;
        }       
        str[++currStep] = i;
        sweap(ed_node.arr[ed_node.blankPos],ed_node.arr[ed_node.blankPos+move_distance[i]]);
        ed_node.blankPos = ed_node.blankPos+move_distance[i];
        if ( DFS() ){
            return true;
        }
        --currStep;
        ed_node.blankPos = ed_node.blankPos-move_distance[i];
        sweap(ed_node.arr[ed_node.blankPos],ed_node.arr[ed_node.blankPos+move_distance[i]]);
    }
    return false;
}

void IDAstar()
{
    if ( !isSloved(ed_node,tag_node) ){
        cout<<"unsolvable"<<endl;
        return ;
    }
    currStep = 0;
    Max_deepth = get_h(ed_node);
    Min_Distance = Max_deepth;
    while ( !DFS() ){
        //Max_deepth++;
        Max_deepth = Min_Distance>Max_deepth ? Min_Distance : (Max_deepth+1);
    }
    for (int i=1; i<=currStep; ++i) {
        cout<<direction[str[i]];
    }
    cout<<endl;
}

int main()
{
    char str [100];

     //自动生成数据测试
    //srand((unsigned)time(NULL));
    //int a[9];
    //int pos ;
    //while ( true ){

    //for ( int i=0; i<9 ; ++i ){
    //a[i]=i;
    //}
    //for ( int i=9; i>1 ; --i ){
    //pos = rand()%i;
    cout<<pos<<" "<<i-1<<endl;
    //sweap(a[pos],a[i-1]);
    //}
    //for ( int i=0; i<9 ; ++i ){
    //cout<<a[i];
    //}
    //cout<<endl;

    //for ( int i=0; i<9 ; ++i ){
    //    ed_node.arr [i] = a[i];
    //    if ( a[i] == 0 ){
    //        ed_node.blankPos = i;
    //    }
    //}

    while ( gets (str)!=NULL ){
        int k =0;
        for ( int i=0; i<9; ++ i,k ++ ){ 
            if ( str [k] == 'x' ){
                ed_node.arr [i] = 0;
                ed_node.blankPos = i;
            } else if ( str[k]>= '1' &&  str [k]<= '9'){
                ed_node.arr [i] = str[k]-'0';
            } else {
                -- i;
            }
        }
        IDAstar();
    }            


}



 
使用A*算法：可见在空间上和时间上都有明显优势（其实优势最明显的在空间，我的A*算法比较垃圾，效率不高所以时间比较长）。 

#include <iostream>
#include <queue>
 
using namespace std;

static const int MAX_ED_SIZE      = 9;
static const int MAX_ED_HASH_SIZE = 400000;

struct ED_Hash {  //ED:eight diagital
                 int fatherHashPos ;
                 char direction ;  //父节点到当前节点的移动方向
} ed_hash[ MAX_ED_HASH_SIZE ];

struct ED_Node {
    int arr [9];
    int hashPos ;
    int blankPos ;
    int h , g;  //g:already cost h:estimate cost
    bool operator < (const ED_Node& node )const {
        //return h !=node.h ? h>node.h : g>node.g;
        return (h+g)==(node.h+node.g)? g<node.g :(h+g)>(node.h+node.g);
    }
                
}ed_keep, ed_temp;

int ED_weight [ MAX_ED_SIZE]={0,1,2,6,24,120,720,5040,40320}; //康托展开式中各项权重

char direction [4]={ 'l', 'r', 'u', 'd'};

int way [4][2]={{0,1},{0,-1},{1,0},{-1,0}};


bool isSloved ( const ED_Node& src ,const ED_Node& tag )
{
    int countSrcNX = 0;
    int countTagNX = 0;
    for ( int i=0; i< MAX_ED_SIZE; ++ i ){
        for ( int j=0; j< i; ++ j ){
            if ( src . arr[ i]>0 ){
                countSrcNX = src . arr[ j]> src. arr [ i] ?
                    ( countSrcNX +1) :countSrcNX ;
            } // end if
            if ( tag . arr[ i]>0 ){
                countTagNX = tag . arr[ j]> tag. arr [ i] ?
                    ( countTagNX +1) :countTagNX ;
            } //end if
        } //end for
    } //end for
    return (countSrcNX &1) == (countTagNX&1);
                
}

int getHashValue ( const ED_Node& node ) //利用康托展开式，计算hash值
{
    int HashValue =0;
    for ( int i=1; i< 9; ++ i ){
        int countNX = 0;
        for ( int j=0; j< i; ++ j ){
            countNX = node . arr[ j]> node. arr [ i] ?
                ( countNX +1) :countNX ;
        }
        HashValue += countNX * ED_weight[ i ];
    }
    return HashValue ;
                
}

int get_H ( const ED_Node& node ) // 获取曼哈顿距离，即估测代价
{
    int currentRow , currentCol;
    int tagRow , tagCol, temp;
    int sumCost = 0;
    for ( int i =0; i< 9; ++ i ){
        //if ( node .arr[i] ){
            temp = (node .arr[i]-1)%9;
            currentRow = i /3;
            currentCol = i %3;
            tagRow      = temp /3;
            tagCol      = temp %3;
            sumCost += abs ( tagRow - currentRow ) + abs ( tagCol - currentCol );
        //}    
    }
    return sumCost ;
                 
}


inline void swap( int& a ,int & b)
{
                 a ^=b ;
                 b ^=a ;
                 a ^=b ;
}


inline bool isOk (const int& x,const int& y)
{
    return x >=0 && y>=0 && x<3 && y <3;
}

void ED_Astar ( ED_Node node ,const ED_Node& tag )
{
    const int tagHashPos = getHashValue (tag );
    int fatherHashPos ,blankPos , numberPos;
    priority_queue <ED_Node > que;
    que .push ( node);
    while ( !que . empty() ){
        ed_keep = que .top();
        que .pop ();
        fatherHashPos = ed_keep .hashPos;
        blankPos = ed_keep .blankPos;
        for ( int i=0; i<4; ++ i ){
            int x = blankPos/3;
            int y = blankPos%3;
            x -= way [i][0];
            y -= way [i][1];

            if ( isOk (x,y) ){
                numberPos = x *3 +y;
                ed_temp = ed_keep ;
                swap(ed_temp .arr[blankPos], ed_temp.arr [numberPos]);
                ed_temp.hashPos = getHashValue( ed_temp);
                if ( ed_hash [ed_temp. hashPos].direction == 0 ){

                    ed_hash[ed_temp .hashPos]. direction     = direction [i] ;
                    ed_hash[ed_temp .hashPos]. fatherHashPos = fatherHashPos ;

                    ed_temp.blankPos = numberPos;
                    ed_temp.g ++;
                    ed_temp.h = get_H(ed_temp);
                    que.push (ed_temp);
                }
                if ( ed_temp .hashPos == tagHashPos ){
                    return  ;
                }

            }
        }

    }                                               
                               

}

void reserveStr (char* str,const int nSize)
{
    for ( int i=0; i<nSize/2; ++ i ){
        char temp = str[i];
        str[i ] = str[nSize-1- i];
        str[nSize -1-i] = temp;
    }
                
               
}

void getWay ( const ED_Node& node )
{
    int hashPos = getHashValue( node );
    char strRout [10000];
    int i =0;
    for ( ; i <10000 && hashPos!=-1; ++ i ){
         strRout [i ] = ed_hash[ hashPos ].direction ;
         hashPos = ed_hash [ hashPos]. fatherHashPos ;
         //cout<<strRout [i];
    }
    //strRout [--i ] = '\0';
    /*reserveStr(strRout ,i);
    cout <<strRout << endl;*/
    for( i -=2;i>=0; i--) 
        putchar(strRout [i]);
    puts("");                                
            
}

void main ()
{
    ED_Node src , tag;

    //初始化tag
    for ( int i=0; i< MAX_ED_SIZE-1; ++ i ){
        tag.arr [ i] = i+1;
    }
    tag.arr [ MAX_ED_SIZE-1] = 0;
    tag.hashPos = getHashValue ( tag );

    //初始化src
    char str [100];

    while ( gets (str)!=NULL ){
        int k =0;
        for ( int i=0; i<9; ++ i,k ++ ){ //初始化src
            if ( str [k] == 'x' ){
                src.arr [i] = 0;
                src.blankPos = i;
            } else if ( str[k]>= '1' &&  str [k]<= '9'){
                src.arr [i] = str[k]-'0';
            } else {
                -- i;
            }
        }
        src .g = 0;
        src .h = get_H( src);
        src.hashPos = getHashValue ( src );

        //判断初始值
        if ( !isSloved ( src, tag) ){
            cout<<"unsolvable\n";
            //printf("unsolvable\n" ); 
            continue;
        } else if ( src.hashPos == tag.hashPos ){
            cout<<endl;
            //puts("");
            continue;
        }
        memset (ed_hash ,0, sizeof( ED_Hash )*MAX_ED_HASH_SIZE );
        ed_hash [src .hashPos ]. direction     = 1 ;
        ed_hash [src .hashPos ]. fatherHashPos = -1 ;

        //使用A*算法
        ED_Astar(src ,tag);
        getWay(tag );
    }            
}
随心而动随意而行
关注
  • 9
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于 A* 和 IDA* 的讨论（先讨论一下A*，剩下留着慢慢写）
Where amazing happens
08-08 660
A*算法百度百科 IDA*算法百度百科 （上面两个觉得不够通俗易懂，可以看下面的） A*算法，点我点我！ IDA*算法，点我点我！ 最后，附上一个非常的经典的题目题解，觉得蛮屌了，先mark一下，以后慢慢学习学习！ 八数码的八境界，点我点我！
IDA* 算法
glorious_dream的博客
02-18 4726
IDA*算法是在A*算法的迭代加深 A*算法主要用在bfs中，IDA*算法主要用在dfs中 先来看一道IDA*的例题 前置知识1：迭代加深 定义： 每次限定一个maxdep最大深度，使搜索树的深度不超过maxdep for(int maxdep=1;maxdep<=题目中给的最大步数;maxdep++){ dfs(0,maxdep);//0为出入函数中当前步数，maxdep为传入的最大深度。 if(success)break;//如果搜索成功则会在dfs函数中将succes..
提升A*算法效率：剔除冗余节点、光滑转折点，路径优化前后对比，优化A*算法：节点剔除与路径优化，实现光滑转折点的改进比较
最新发布
FnlOARHjae的博客
06-04 194
首先，我们提出了一种节点剔除策略，通过对已生成的路径进行分析，识别出其中的冗余节点。我们通过判断节点间的连续性和路径的代价来识别冗余节点，并将其从路径中剔除。综上所述，我们提出了一种改进的A*算法，通过剔除冗余节点和光滑转折点来优化路径规划。针对这些问题，我们提出了一种改进的A*算法，目标是删除冗余节点和光滑路径。算法的关键点在于剔除冗余节点和光滑转折点，从而优化路径。最后，我们对比了优化前后的路径，通过实验验证了改进算法的有效性。算法相比，改进算法生成的路径更加简洁、平滑，能够更好地满足实际应用的需求。
搜索算法——IDA*
Psychosocial的博客
09-15 1442
搜索算法——IDA∗IDA*IDA∗ 算法介绍 IDA∗IDA*IDA∗是基于深度优先搜索进行优化的一种算法，又被称作为迭代加深搜索，是一种启发式搜索算法。 什么叫做迭代加深呢？实际上深搜会搜索很多层，几乎是呈指数级增长的，但是实际上可以通过限制搜索深度来优化。在深度没有上限的情况下，先预先估计一个较小的深度kkk,首先搜索KKK层，如果没有找到解，深度加111，从头开始搜索到k+1k+1k+1...
C语言经典算法之介绍IDA*算法
weixin_56154577的博客
03-25 2412
IDA*（Iterative Deepening A*）算法是一种结合了A算法和深度优先搜索（DFS）思想的启发式搜索算法。它解决了A算法在面对深而窄的搜索空间时，可能因为需要存储大量节点而导致内存溢出的问题。IDA*通过迭代加深的方式逐步扩大搜索深度，每次只探索到当前设定的最大深度，没有找到解时就增加最大深度，继续搜索。
IDA* Algorithm 用四道例题教会你IDA*算法
Wizzy_Ang的博客
02-15 1400
用四道例题教会你IDA*
A* 算法讲解
weixin_30826761的博客
12-04 395
在看下面这篇文章之前，先介绍几个理论知识，有助于理解A*算法。 启发式搜索：启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。这样可以省略大量无畏的搜索路径，提到了效率。在启发式搜索中，对位置的估价是十分重要的。采用了不同的估价可以有不同的效果。 估价函数：从当前节点移动到目标节点的预估费用；这个估计就是启发式的。在寻路问题和迷...
A*与IDA*算法
私は Mocha!!
08-08 841
A* 　　A*算法是基础的启发式算法，常使用“估价函数”减少选择来用于优化搜索的速度。对于当前的状态，我们知道当前已经用了的代价，那么我们可以设计一个估价函数fff来估计未来的状态，当前代价+未来代价作为这个状态的预估总代价。 　　那么这个估价函数值fff需要满足f(now)≤g(now)f(now)≤g(now)f(now)\leq g(now)，其中now表示当前状态，g()表示实际需要花...
A* 算法
ZhuRanCheng的博客
03-13 1034
A* 算法总结
通过alpha-belta剪枝的极大极小值算法实现简单的五子棋+A*算法与IDA*算法解决走迷宫问题
07-05
本文将探讨如何利用α-β剪枝的极大极小值算法实现简单的五子棋游戏，以及A*算法和IDA*算法在解决迷宫问题中的应用。 首先，五子棋是一个典型的二人对弈游戏，适合使用基于搜索的决策方法。α-β剪枝极大极小值算法...
A*算法的matlab程序
03-25
- 优化启发式函数，提高搜索效率，例如使用A*算法的变体如IDA*或Dijkstra的增量版本。 总之，A*算法的MATLAB程序是学习和研究路径规划问题的重要工具，通过实践可以加深对算法的理解，同时也能为科研和工程应用...
15 puzzle C语言IDA* 求解算法
10-23
IDA*（Iterative Deepening A*）是一种基于深度优先搜索的启发式搜索算法，结合了深度优先搜索的效率和A*算法的优化特性。A*算法通过使用一个评估函数f(n) = g(n) + h(n)，其中g(n)是从初始状态到节点n的实际代价，h...
A*以及迭代加深的A*算法（IDA*）
10-05
A*算法是路径搜索领域的一种高效启发式搜索方法，它结合了Dijkstra算法的全局最优性和最佳优先搜索的效率。A*算法的核心在于其代价函数，通常表示为f(n) = g(n) + h(n)，其中g(n)是从初始节点到当前节点的实际代价，...
人工智能-IDA*算法解决15-puzzle问题（能优化的都优化了）
04-08
本项目专注于使用IDA*（Iterative Deepening A*）算法来解决经典的15-puzzle问题。15-puzzle是一个滑动拼图游戏，通常由一个4x4的网格组成，其中15个数字（1到15）被随机放置，目标是通过最少的移动次数将它们重新...
IDA*算法
qq_51699436的博客
02-17 1351
IDA*算法是迭代加深的A*算法，设计一个估价函数f(state)<=真实步数
IDA*算法 启发式搜索
十一.的博客
06-27 176
迭代加深的A*算法
【C++】IDA*算法
cout0
12-08 1279
算法简介 IDA*(ID A*)算法是一种启发式搜索算法，他是采取了迭代加深的A∗A^*A∗算法，使用了深度优先搜索的方式（根据百度百科的说法，IDA*不是基于迭代加深的A∗A^*A∗算法，是迭代加深与全局最优性剪枝的A∗A^*A∗算法）。 相对于A∗A^*A∗算法，IDA*算法主要解决了： A∗A^*A∗算法需要判重，对优先级排序的问题。 A∗A^*A∗算法使用堆，需要大量空间存储的问题。 算法思想 IDA*算法的基本思想是设置一个搜索深度，这个搜索深度从0开始依次递增。使用深度优先搜索在这个深度内搜
搜索算法：IDA*算法
热门推荐
如果这是你所爱的，要坚持，并踏实。
09-01 2万+
今天学习了IDA*算法，在这里总结一下：IDA*算法是A*算法和迭代加深算法的结合。迭代加深算法是在dfs搜索算法的基础上逐步加深搜索的深度，它避免了广度优先搜索占用搜索空间太大的缺点，也减少了深度优先搜索的盲目性。它主要是在递归搜索函数的开头判断当前搜索的深度是否大于预定义的最大搜索深度，如果大于，就退出这一层的搜索，如果不大于，就继续进行搜索。这样最终获得的解必然是最优解。而在A*算法中，我们通过使用合理的估价函数，然后在获得的子节点中选择fCost最小的节点进行扩展，以此完成搜索最优解的目的。但是A*
聪明的探险家是如何探险的——IDA*算法
霜-哀的博客
04-07 823
对IDA*算法的图解和C++代码，帮助初学者快速上手IDA*
A*算法和IDA*算法有什么区别？
05-15
A*算法和IDA*算法都是启发式搜索算法，它们都是用于解决最短路径问题的常用算法。其中，A*算法在搜索时利用了启发式函数来估计从当前节点到目标节点的距离，从而选择最优的节点进行搜索。而IDA*算法则是在A*算法基础上做出的改进，其主要区别是不使用任何额外的内存空间，而是将估价函数的值作为深度限制，直到找到目标节点或者超过深度限制为止。 具体来说，A*算法维护一个open列表和一个closed列表。open列表中保存了待搜索的节点，closed列表中保存已经被搜索过的节点。每次从open列表中选择一个f值最小的节点进行扩展，并将其加入closed列表中。扩展时，对于当前节点的每个子节点计算估价函数值f(n)=g(n)+h(n)，其中g(n)是从起点到当前节点的实际代价，h(n)是从当前节点到目标节点的估计代价。这样，每次选择f值最小的节点进行扩展时，就能够尽可能地朝着目标节点前进。 IDA*算法则是将A*算法中的open列表替换成一个栈，在搜索时将当前搜索深度作为阈值，不断更新阈值来限制搜索深度。具体来说，每次从起点开始，将阈值设置为起点到目标节点的估价函数值，然后进行深度优先搜索。如果搜索到某个节点的f(n)>threshold，则将其返回，并将阈值更新为f(n)。这样，IDA*算法通过不断增加深度限制来逐步逼近最短路径，直到找到目标节点或者搜索到达最大深度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值