算法——有向图的最短路径算法

最新推荐文章于 2024-02-23 10:00:00 发布
最新推荐文章于 2024-02-23 10:00:00 发布
阅读量3.3k 收藏 18
点赞数 2
分类专栏： 算法与数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45927758/article/details/106867393
版权

建议学习最短路径算法时，观看这个视频

https://www.bilibili.com/video/BV1q4411M7r9?from=search&seid=9662298119837732890 

Dijkstra算法

思路：

1.从一个单源节点开始计算，寻找当前节点周围没有遍历过并且可到达的邻接点，并且把当前单源节点设置为以访问状态；

2.如果从当前节点到这些邻接点的距离更短，那么更新这些邻接点的父节点数组为当前节点，距离数组为当前节点的距离数组+这些邻接点与当前节点之间弧的权重；

3.并且在遍历当前节点的邻接点的时候，要选出当前节点与这些邻接点之间弧权重最短的那个邻接点作为下一次的单源节点；

4.对下一次的单元节点的操作与上面操作类似；

5.以上操作需要借助队列来实现。

6.关于有向图还要注意i->j的弧，只能由i移动到j。

//有向图
#include<iostream>
#include<vector>
#include<queue>
#include<climits>
using namespace std;
//边表节点
typedef struct ArcNode
{
    int Adjvex;
    int wet;
    ArcNode*next=nullptr;
    ArcNode(int x,ArcNode*p,int y):Adjvex(x),next(p),wet(y) {}
} ArcNode;
//顶点表节点
typedef struct VerNode
{
    int Vervex;
    ArcNode*First_Edge;
    VerNode(int x,ArcNode*p):Vervex(x),First_Edge(p) {}
} VerNode;
class d_chart
{
private:
    vector<VerNode*>VerNode_List;
    vector<int>Visited_Mark;
    vector<int>Parent;//存储节点的上一个父亲节点
    vector<int>Distance;//存储源节点到每一个节点的最短距离
public:
    d_chart() {}
    void make(vector<int>data,int Road_Nums);
    void Print();
    void Reset();
    void Dijkstra(int u);
    ~d_chart();
};
void d_chart::make(vector<int>data,int Road_Nums)
{
    VerNode*Node_Pointer_temp;
    ArcNode*Arc_Pointer;
    int i,j,k,w;
    int Data_Len=data.size();
    for(i=0; i<Data_Len; i++)
    {
        Node_Pointer_temp=new VerNode(data[i],nullptr);
        VerNode_List.push_back(Node_Pointer_temp);
        Visited_Mark.push_back(0);
        Parent.push_back(-1);
        Distance.push_back(INT_MAX);
    }
    for(k=0; k<Road_Nums; k++)
    {
        cout<<"请输入有向图的路径i——>j,以及弧的权重"<<endl;
        cout<<"请输入i:  ";
        cin>>i;
        cout<<endl<<"请输入j:  ";
        cin>>j;
        cout<<endl<<"请输入i->j弧的权重";
        cin>>w;
        cout<<endl;
        Arc_Pointer=new ArcNode(j,VerNode_List[i]->First_Edge,w);
        VerNode_List[i]->First_Edge=Arc_Pointer;
    }
}
void d_chart::Print()
{
    ArcNode*s;
    int i;
    for(i=0; i<VerNode_List.size(); i++)
    {
        //cout<<VerNode_List[i]->Vervex;
        s=VerNode_List[i]->First_Edge;
        while(s!=nullptr)
        {
            cout<<" "<<VerNode_List[i]->Vervex<<"——>"<<s->Adjvex<<" ";
            s=s->next;
        }
        cout<<endl;
    }
}
d_chart::~d_chart()
{
    ArcNode*s;
    ArcNode*q;
    int i;
    for(i=0; i<VerNode_List.size(); i++)
    {
        s=VerNode_List[i]->First_Edge;
        delete VerNode_List[i];
        while(s!=nullptr)
        {
            q=s;
            s=s->next;
            delete q;
        }
    }
}
void d_chart::Reset()
{
    int i=0;
    for(i=0; i<Visited_Mark.size(); i++)
    {
        Visited_Mark[i]=0;
        Parent[i]=-1;
        Distance[i]=INT_MAX;
    }
}
void d_chart::Dijkstra(int u)
{
    int node=Parent.size();//节点数
    queue<VerNode*> s;

    s.push(VerNode_List[u]);
    Parent[u]=-1;
    Distance[u]=0;

    while(!s.empty())
    {
        int idx=s.front()->Vervex;
        //cout<<"当前节点——"<<idx<<endl;
        Visited_Mark[idx]=1;
        int last=-1;//记录最后要入队的那个节点的下标
        int last_wt=INT_MAX;
        for(ArcNode*p=VerNode_List[idx]->First_Edge;p!=nullptr;p=p->next)
        {
            int pls=p->Adjvex;
            if(Visited_Mark[pls]==0)//没有被访问过
            {
                //cout<<"可以选择的节点****"<<pls<<endl;
                if(((p->wet)+Distance[idx])<Distance[pls])
                {
                    Distance[pls]=((p->wet)+Distance[idx]);
                    Parent[pls]=idx;
                }
                if((p->wet)<last_wt)
                {
                    last=pls;
                    last_wt=(p->wet);
                }
            }
        }
        //cout<<"最终选择的节点++++"<<last<<endl<<endl;
        if(last!=-1)//如果最终选中的节点下标等于-1，那么说明没有与当前节点相连的节点了
        {
            s.push(VerNode_List[last]);
        }
        s.pop();
    }
    cout<<endl<<"当前的源节点是"<<u<<endl;
    //打印出各个数组存储的数据

    cout<<"Distance数组："<<endl;
    for(int i=0;i<node;i++)
    {
        cout<<Distance[i]<<" ";
    }
    cout<<endl<<"Parent数组："<<endl;
    for(int i=0;i<node;i++)
    {
        cout<<Parent[i]<<" ";
    }
}
int main()
{
    vector<int> p={0,1,2,3,4};
    d_chart cool;
    cool.make(p,10);
    cool.Print();
    cool.Dijkstra(0);
    return 0;
}

运行：

说实在的，有向图的Dijkstra算法和无向图的算法步骤大同小异，基本一样。

Floyd算法

思路：

1.使用两个n*n的矩阵Dist，Plain（n是节点的个数），Dist是i节点到j节点的最短距离，Plain存放的是i到j最短路径的节点遍历顺序，

比如Plain[i][j]=k,那么从i到j的最短路径就要经过k节点，那么就去Plain[k][j]查看Plain[k][j]的值是否为j，如果为，那么最短路径就是

i->k->j,否则就继续像之前那样寻找最短路径上的节点。

 

2.初始换Dist数组，其实就是把邻接表转换成邻接矩阵，从而更好操作，主对角线由于图中弧权重可为负数，所以主对角线上可以初始化为一个极大或者极小的值，然后不相通的两个节点的Dist不能直接设置为INT_MAX,在这上面我吃了大亏，他会整型越界,最好设置为INT_MAX-50。

 

3.初始化Plain数组，Plain[i][j]初始化为j，而当i==j的时候，初始化为-1，因为节点中没有-1为下标。

 

4.然后使用三层循环，最外层的k循环，是循环遍历中间节点，内两层循环更新距离数组，如果i先到k这个中间节点在到j节点比之前其他路径更短，那么同时更新路径数组，和顺序数组，很重要的一点在更新的时候，下标为k的行和列以及对角线不参与这种更新。

 

5.最后还有更加重要的一点就是如果i无法到达k的话，就不能更新，因为当k到j的弧的权重为负数的话就会发生非常不好的结果，我深有体会！

 

 

代码

//有向图
#include<iostream>
#include<vector>
#include<queue>
#include<climits>
using namespace std;
//边表节点
typedef struct ArcNode
{
    int Adjvex;
    int wet;
    ArcNode*next=nullptr;
    ArcNode(int x,ArcNode*p,int y):Adjvex(x),next(p),wet(y) {}
} ArcNode;
//顶点表节点
typedef struct VerNode
{
    int Vervex;
    ArcNode*First_Edge;
    VerNode(int x,ArcNode*p):Vervex(x),First_Edge(p) {}
} VerNode;
class d_chart
{
private:
    vector<VerNode*>VerNode_List;//节点
public:
    d_chart() {}
    void make(vector<int>data,int Road_Nums);
    void Print();
    void Floyd();
    ~d_chart();
};
void d_chart::make(vector<int>data,int Road_Nums)
{
    VerNode*Node_Pointer_temp;
    ArcNode*Arc_Pointer;
    int i,j,k,w;
    int Data_Len=data.size();
    for(i=0; i<Data_Len; i++)
    {
        Node_Pointer_temp=new VerNode(data[i],nullptr);
        VerNode_List.push_back(Node_Pointer_temp);
        Visited_Mark.push_back(0);
        Parent.push_back(-1);
        Distance.push_back(INT_MAX);
    }
    for(k=0; k<Road_Nums; k++)
    {
        cout<<"请输入有向图的路径i——>j,以及弧的权重"<<endl;
        cout<<"请输入i:  ";
        cin>>i;
        cout<<endl<<"请输入j:  ";
        cin>>j;
        cout<<endl<<"请输入i->j弧的权重";
        cin>>w;
        cout<<endl;
        Arc_Pointer=new ArcNode(j,VerNode_List[i]->First_Edge,w);
        VerNode_List[i]->First_Edge=Arc_Pointer;
    }
}
void d_chart::Print()
{
    ArcNode*s;
    int i;
    for(i=0; i<VerNode_List.size(); i++)
    {
        //cout<<VerNode_List[i]->Vervex;
        s=VerNode_List[i]->First_Edge;
        while(s!=nullptr)
        {
            cout<<" "<<VerNode_List[i]->Vervex<<"——>"<<s->Adjvex<<" ";
            s=s->next;
        }
        cout<<endl;
    }
}
d_chart::~d_chart()
{
    ArcNode*s;
    ArcNode*q;
    int i;
    for(i=0; i<VerNode_List.size(); i++)
    {
        s=VerNode_List[i]->First_Edge;
        delete VerNode_List[i];
        while(s!=nullptr)
        {
            q=s;
            s=s->next;
            delete q;
        }
    }
}
void d_chart::Floyd()
{
    int node=Parent.size();
    //Floyd算法所需数组
    vector<vector<int>>Dist(node,vector<int>(node,INT_MAX-50));//距离数组
    vector<vector<int>>Plain(node,vector<int>(node));//顺序数组

    //初始化顺序数组
    for(int i=0; i<node; i++)
        for(int j=0; j<node; j++)
        {
            if(i==j)
            {
                Plain[i][j]=-1;
            }
            else
            {
                Plain[i][j]=j;
            }
        }

    /*先打印初始化的顺序数组*/
    cout<<"——初始化的顺序数组——"<<endl;
    for(int i=0; i<node; i++)
    {
        for(int j=0; j<node; j++)
            cout<<Plain[i][j]<<"  ";
        cout<<endl;
    }
    //初始化距离数组
    for(int i=0; i<node; i++)
    {
        int x=VerNode_List[i]->Vervex;
        for(ArcNode*p=VerNode_List[i]->First_Edge; p!=nullptr; p=p->next)
        {
            int y=p->Adjvex;
            Dist[x][y]=p->wet;
        }
    }


    //距离数组对角线
    for(int i=0; i<node; i++)
        for(int j=0; j<node; j++)
        {
            if(i==j)
                Dist[i][j]=0;
        }
    /*打印初始化的距离数组*/
    cout<<"——初始化的距离数组——"<<endl;
    for(int i=0; i<node; i++)
    {
        for(int j=0; j<node; j++)
        {
            if(i==j)
            {
                cout<<"-  ";
                continue;
            }
            if(Dist[i][j]==(INT_MAX-50))//
                cout<<"∞"<<"  ";
            else
                cout<<Dist[i][j]<<"  ";
        }
        cout<<endl;
    }

    //三层循环
    for(int k=0; k<node; k++)
    {
        for(int i=0; i<node; i++)
        {
            if(i==k)
                continue;
            for(int j=0; j<node; j++)
            {
                if(j==k)
                    continue;
                if(i==j)
                    continue;

                /*cout<<"Dist["<<i<<"]["<<k<<"]: ";
                if(Dist[i][k]==INT_MAX-50)
                    cout<<"∞"<<"  ";
                else
                    cout<<Dist[i][k]<<"  ";
                cout<<"Dist["<<k<<"]["<<j<<"]:  ";
                if(Dist[k][j]==INT_MAX-50)
                    cout<<"∞"<<"  ";
                else
                    cout<<Dist[k][j]<<"  ";
                cout<<"Dist["<<i<<"]["<<j<<"]:  ";
                if(Dist[i][j]==INT_MAX-50)
                    cout<<"∞"<<"  ";
                else
                    cout<<Dist[i][j]<<"  ";
                    cout<<endl;*/



                if((Dist[i][k]+Dist[k][j])<Dist[i][j]&&(Dist[i][k]!=(INT_MAX-50)&&Dist[k][j]!=(INT_MAX-50)))//
                {
                    Dist[i][j]=(Dist[i][k]+Dist[k][j]);
                    Plain[i][j]=Plain[i][k];
                }
            }
        }
        cout<<"——中间节点为"<<k<<"之后距离矩阵的更新——"<<endl;
        for(int i=0; i<node; i++)
        {
            for(int j=0; j<node; j++)
            {
                if(i==j)
                {
                    cout<<"-  ";
                    continue;
                }
                if(Dist[i][j]==INT_MAX-50)
                    cout<<"∞"<<"  ";
                else
                    cout<<Dist[i][j]<<"  ";
            }
            cout<<endl;
        }

    }

    //打印距离数组
    cout<<"——距离数组——"<<endl;
    for(int i=0; i<node; i++)
    {
        for(int j=0; j<node; j++)
        {
            if(i==j)
            {
                cout<<"-  ";
                continue;
            }
            if(Dist[i][j]==INT_MAX-50)
                cout<<"∞"<<"  ";
            else
                cout<<Dist[i][j]<<"  ";
        }
        cout<<endl;
    }


    //打印顺序数组
    cout<<"——顺序数组——"<<endl;
    for(int i=0; i<node; i++)
    {
        for(int j=0; j<node; j++)
            cout<<Plain[i][j]<<"  ";
        cout<<endl;
    }
}
int main()
{
    vector<int> p= {0,1,2,3,4};
    d_chart cool;
    cool.make(p,9);
    cool.Print();
    cool.Floyd();
    return 0;
}

 

基本公式：

测试用图：


 

 

 

 

程序运行：

 

 

 

秃头的毛睿
关注
  • 2
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
试给出有向图中所有简单回路的算法_从入门角度深入理解——有关最短路的常见算法#1 最短路问题介绍...
weixin_39933508的博客
12-17 1656
最短路问题介绍这里的最短路问题，指的是单源最短路。单源最短路，意如其名，只有一个原点，走到其他点的最短路径。即求一个点到其余点的最短路径。图的简单概述：要了解最短路，首先要简单理解一下什么是图。书上概述如下(可以跳过不读)：图G=(V,E)是一个二元组(V,E)使得E⊆[V]的平方，所以E的元素是V的2-元子集。为了避免符号上的混淆，我们总是默认V∩B=Ø。集合V中的元素称为图G的顶点(或节点、点...
有向图的最短路径算法(Dijkstra+BellmanFord+Floyd)
cj1561435010的博客
03-13 7795
一、最短路径简介        所谓最短路径问题是指：如果从图中某一顶点（源点）到达另一顶点（终点）的路径可能不止一条，如何找到一条路径使得沿此路径上各边的权值总和（称为路径长度）达到最小。        路径规划就是最短路径的典型应用。 二、Dijk...
2023-04-09 有向图及相关算法
lsgwr的博客
04-09 1994
定义：在一个有向图中，对所有的节点进行排序，要求没有一个节点指向它前面的节点，最终的排序结果就是拓扑排序价值：当现实中存在图状约束时，要你给出一个约束下可行的图遍历方便，这个时候拓扑排序就用上了~比如选课、选旅游路线等floodfill最小生成树桥和割点二分图检测。
【数据结构】图——最短路径
最新发布
努力进大厂的小码娄
02-23 2736
迪杰斯特拉算法是基于贪心算法设计，解决非负数权值的路径问题。贝尔曼福特算法是暴力求解，能求解出带负权值的路径，能判断负权环路。是一个时间复杂度为o(N^3)的算法。要进行K次松弛调整。费洛伊徳算法是动态规划的思想，将路径分为i->k k->j的思想。同样要进行K轮次的更新。复杂度为0(N^3)。能够求解任意俩顶点的最短路径。
图算法——求最短路径（Dijkstra算法）
热门推荐
在夜里行走的博客
11-22 8万+
图解Dijkstra算法，让你了解Dijkstra算法的每一步是怎么进行的
贪心算法——最短路径算法.rar
05-02
以标题中的“最短路径算法”为例，我们可以联想到著名的Dijkstra算法。Dijkstra算法是由荷兰计算机科学家艾兹格·迪科斯彻提出的，用于寻找图中两点间的最短路径。在有向图或无向图中，该算法能找出从起点到其余所有...
多段图的最短路径问题 动态规划法——C++代码
05-24
此外，动态规划通常假设图是无向的，对于有向图可能需要额外的处理。 总结来说，本问题探讨了如何使用动态规划法解决多段图的最短路径问题，这是一种重要的算法，可以帮助我们高效地找到复杂网络中的最优路径。通过...
最短路径算法——Dijkstra算法参照.pdf
11-07
该算法主要用于解决非负权有向图中从一个特定顶点（源点）到其他所有顶点的最短路径问题。在实际应用中，这个问题可以出现在诸如道路网络规划、网络路由优化、资源分配等多个领域。 Dijkstra算法的基本思想是采用...
美国硅谷城镇地图——最短路径问题
03-13
最短路径问题可以被定义为：在带权无向图或有向图中寻找两个特定节点间路径的最小代价。在这个硅谷城镇地图问题中，我们可以假设图是有向的，因为通常交通网络都是单向的。权值可能代表距离、行驶时间或者其它相关的...
有向最短哈密尔顿路问题的DNA算法
01-01
有向最短哈密尔顿路问题的DNA算法是一份整理发布的食品资料文档，只为你能够轻松获取有向最短...该文档为有向最短哈密尔顿路问题的DNA算法，是一份很不错的参考资料，具有较高参考价值，感兴趣的可以下载看看
有向图的Dijkstra算法实现
04-23
有向图的Dijkstra算法实现，C++语言实现
有向图最短路径（空间分析、数据结构）
05-31
自己写的一个关于有向图最短路径的程序，是在看完了谭浩强的《c++面向对象程序设计》后用面向对象方法写的。
最短路径(加权有向图)
一名小白的博客
08-28 4552
最短路径 1. 最短路径定义以及性质 定义： 在一副加权有向图中，从顶点s到顶点t的最短路径是所有从顶点s到顶点t的路径中总权重最小的那条路径。 性质： 路径具有方向性。 权重不一定等于距离。权重可以是距离、时间、花费等内容，权重最小指的是成本最低。 只考虑连通图。一副图中并不是所有的顶点都是可达的，如果s和t不可达，那么它们之间也就不存在最短路径，所以只考虑连通图。 最短路径不一定是唯一的。从一个顶点到达另外一个顶点的权重最小的路径可能会有很多条，所以只需要找出一条即可。 最短路径树： 给定一副加权
＜原创＞ Leetcode:有向图中的最短路径解法（注释详细）
weixin_40137369的博客
08-11 1358
题目： 朴素的Dijksta算法（On^2）适合稠密图。 class Solution { public: int networkDelayTime(vector<vector<int>>& times, int N, int K) { if(N==1) return 0; int inf = 10000; vector<vector<int>> g(N+1, vector<int&gt
四种不同单源最短路径算法性能比较
lcw_2015的博客
10-22 1万+
四种不同单源最短路径算法性能比较   一、最短路径问题描述 单源最短路径描述：给定带权有向图G=(V,E),其中每条边的权是非负实数。另外，还给定V中的一个顶点，称之为源。现在要计算从源到其他各顶点的最短路径的长度。这里的路径长度指的是到达路径各边权值之和。 二、算法 1  Dijkstra算法介绍 Dijkstra算法是解决单源最短路径问题的贪心算法。Dijkstra算法的基本思想是
有向图最短路径算法（dijkstra）
祥哥
04-16 1311
package com.ids.globalPath.logic; import com.alibaba.fastjson.JSONObject; import lombok.Getter; import lombok.Setter; import java.util.*; /** * 有向图 */ public class Graph { @Getter @Setter private List<Vertex> vertexList; //图的顶点集...
图表算法—有向图
01-24 629
1. 有向图（Directed Graphs） 　　有向图与无向图是很像的，如果对无向图不熟悉，建议先看一下无向图。 　　在讨论有向图的算法前，先讨论如何构建有向图。 　　构建有向图的方法基本与无向图的方法一模一样。　　 　　首先，有向图是长这样的： 　　 　　 　　也是有两个关键点： 　　a. 这个有向图有哪些点 　　b. 哪些点可以通往哪些点（箭头代表可通往的...
Floyd（弗洛伊德算法） 求最短路径 有向图
yjyxw的博客
04-24 3409
暑假，小哼准备去一些城市旅游。有些城市之间有公路，有些城市之间则没有，如下图。为了节省经费以及方便计划旅程，小哼希望在出发之前知道任意两个城市之前的最短路程。 上图中有4个城市8条公路，公路上的数字表示这条公路的长短...
最短路径算法---Dijkstra---邻接矩阵
一直很安静Dcindy的博客
04-19 1万+
先放出原作者的链接：http://blog.51cto.com/ahalei/1387799以下仅是我的学习过程，以便用时方便查找。Dijkstra为“单源最短路径算法” 对应的邻接矩阵是----&gt;以1为起始地点，用Dijstra算法最终可以得到是到其他各点（2,3,4,5,6）的最短路径.e[6][6]：表示矩阵的大小 dis[6]：表示1到其他各点的距离，如：dis[3]:1到3的距离 ...
有向图最短路径 java,数据结构——带权有向图（最短路径算法Dijkstra算法）
05-26
Dijkstra算法可以用来求带权有向图上的最短路径，下面是Java实现： ```java import java.util.*; public class DijkstraAlgorithm { private static final int MAX = Integer.MAX_VALUE; // 定义无穷大 public static void dijkstra(int[][] graph, int start) { int n = graph.length; // 图的大小 int[] dist = new int[n]; // 存储起点到各个点的最短距离 boolean[] visited = new boolean[n]; // 标记各个结点是否已经访问过 int[] prev = new int[n]; // 存储到达各个结点的前驱结点 // 初始化 for (int i = 0; i < n; i++) { dist[i] = MAX; visited[i] = false; prev[i] = -1; } dist[start] = 0; // 循环n-1次，每次确定一个顶点的最短路径 for (int i = 0; i < n - 1; i++) { int minDist = MAX; int u = -1; // 找到当前未访问的结点中距离起点最近的结点 for (int j = 0; j < n; j++) { if (!visited[j] && dist[j] < minDist) { minDist = dist[j]; u = j; } } if (u == -1) { break; } visited[u] = true; // 更新与u相邻的结点的最短距离 for (int j = 0; j < n; j++) { if (!visited[j] && graph[u][j] != MAX) { int newDist = dist[u] + graph[u][j]; if (newDist < dist[j]) { dist[j] = newDist; prev[j] = u; } } } } // 输出结果 System.out.println("起点为" + start + "的最短路径如下："); for (int i = 0; i < n; i++) { if (i != start && dist[i] != MAX) { System.out.print("从" + start + "到" + i + "的最短路径为：" + start); int j = i; while (j != start) { System.out.print(" -> " + j); j = prev[j]; } System.out.println("，路径长度为：" + dist[i]); } } } public static void main(String[] args) { int[][] graph = { {0, 1, 12, MAX, MAX}, {MAX, 0, 9, 3, MAX}, {MAX, MAX, 0, MAX, 5}, {MAX, MAX, 4, 0, 13}, {MAX, MAX, MAX, MAX, 0} }; dijkstra(graph, 0); } } ``` 运行结果： ``` 起点为0的最短路径如下： 从0到1的最短路径为：0 -> 1，路径长度为：1 从0到2的最短路径为：0 -> 1 -> 3 -> 2，路径长度为：12 从0到3的最短路径为：0 -> 1 -> 3，路径长度为：4 从0到4的最短路径为：0 -> 1 -> 3 -> 2 -> 4，路径长度为：17 ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值