最短路（SPFA、Dijkstra、Floyd、Bellman-Ford）

最新推荐文章于 2022-07-06 21:26:33 发布
最新推荐文章于 2022-07-06 21:26:33 发布
阅读量739 收藏
点赞数
分类专栏： 经典算法 ACM-ICPC 2016暑期特训1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XerxesSimon/article/details/51862966
版权

题目链接：   最短路


Dijkstra(迪杰斯特拉)算法 
解决无负权边的带权有向图或无向图的单源最短路问题

用邻接表，不优化，时间复杂度O(V2+E) 
Dijkstra+堆的时间复杂度 o(ElgV) 
用斐波那契堆可以做到O(VlogV+E)  

若要输出路径，则设置prev数组记录每个节点的前趋点，在d[i] 更新时更新prev[i]

#include<bits/stdc++.h>
using namespace std;
const int N=1e3;
const int inf=0x3f3f3f3f;
struct node{
    int to,val;
    node(){}
    node(int a,int b){to=a;val=b;}
    bool operator<(const node &xx)const{
        return xx.val<val;
    }
};
vector<node> mp[N];
int n,m;
int dis[N];
void dijkstra(int s)
{
    memset(dis,inf,sizeof dis);
    priority_queue<node> q;
    q.push(node(s,0));dis[s]=0;
    while(!q.empty())
    {
        int from=q.top().to;  q.pop();
        for(int i=0;i<mp[from].size();i++)
        {
            int to=mp[from][i].to;
            int val=mp[from][i].val;
            if(dis[to]>dis[from]+val)
                q.push(node(to,dis[to]=dis[from]+val));
        }
    }
    printf("%d\n",dis[n]);
}
int main()
{
    int i,j,t,tt=0;
    while(~scanf("%d%d",&n,&m),n|m)
    {
        memset(mp,0,sizeof mp);
        while(m--)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            mp[a].push_back(node(b,c));
            mp[b].push_back(node(a,c));
        }
        dijkstra(1);
    }
}

经典例题：poj 3159


Bellman-Ford(贝尔曼-福特)算法 
解决含负权边的带权有向图的单源最短路径问题  
不能处理带负权边的无向图(因可以来回走一条负权边)  
限制条件：  要求图中不能包含权值总和为负值回路(负权值回路

假设图的顶点个数为n，边的个数为e  
使用邻接表存储图，复杂度O(n*e)  
使用邻接矩阵存储图，复杂度为O(n3)； 

Bellman-Ford算法不一定要循环n-1次，n为顶点个数  
只要在某次循环过程中，考虑每条边后，源点到所有顶点的最短路径 长度都没有变，那么Bellman-Ford算法就可以提前结束了 
第n次可以判断是否有负权值回路

（本题是把边扩展成2*e个，变成”有向图”求解） 

#include <cstdio>
const int max_v = 110;
const int max_e = 10010;
const int INF = 1000000000;
int e,v;
struct edge {
    int from,to,cost;
};
int d[max_v];
edge eg[max_e*2];
int main()
{
    while(scanf("%d%d",&v,&e) && v) {
        //边扩展到1-2e范围
        for(int i = 0 ; i < max_v ; i ++) d[i] = INF;
        for(int i = 1 ; i <= e ; i ++) {
            scanf("%d%d%d",&eg[i].from,&eg[i].to,&eg[i].cost);
            eg[i+e].from = eg[i].to;
            eg[i+e].to = eg[i].from;
            eg[i+e].cost = eg[i].cost;
        }
        d[1] = 0;
        while(true) {
            bool flag = false;
            for(int i = 1 ; i <= 2*e ; i ++) {
                if(d[eg[i].from] != INF && d[eg[i].from]+eg[i].cost < d[eg[i].to]) {
                    d[eg[i].to] = d[eg[i].from]+eg[i].cost;
                    flag = true;
                }
            }
            if(!flag) break;
        }
        printf("%d\n",d[v]);
    }
    return 0;
}

经典例题：poj 1860 3259 2240

SPFA(队列优化))算法
快速求解含负权边的带权有向图的单源最短路径问题 
是Bellman-Ford算法的改进版，利用队列动态更新dist[]

在平均情况下，SPFA算法的期望时间复杂度为O(E) 

#include<bits/stdc++.h>
#include<stdlib.h>
#include<stdio.h>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
const int N=1e3;
const int inf=0x3f3f3f3f;
struct node{
    int to,val;
    node(){}
    node(int a,int b){to=a;val=b;}
};
vector<node> mp[N];
int n,m;
int dis[N];
bool used[N];
bool spfa(int s)
{
    memset(dis,inf,sizeof dis);
    memset(used,0,sizeof used);
    queue<int> q;
    q.push(s);dis[s]=0;used[s]=1;
    while(!q.empty())
    {
        int from=q.front();q.pop();
        used[from]=0;
        for(int i=0;i<mp[from].size();i++)
        {
            int to=mp[from][i].to;
            int val=mp[from][i].val;
            if(dis[to]>dis[from]+val)
            {
                dis[to]=dis[from]+val;
                if(!used[to])
                    used[to]=1,q.push(to);
            }
        }
    }
    return 0;
}
int main()
{
    int i,j,t,tt=0;
    while(~scanf("%d%d",&n,&m),n|m)
    {
        memset(mp,0,sizeof mp);
        while(m--)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            mp[a].push_back(node(b,c));
            mp[b].push_back(node(a,c));
        }
        spfa(1);
        printf("%d\n",dis[n]);
    }
}

经典例题：poj 2387 3256

http://poj.org/problem?id=3259

//#include<bits/stdc++.h>
#include<stdlib.h>
#include<stdio.h>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
const int N=500+7;
const int inf=0x3f3f3f3f;
int mp[N][N];
int n,m,k;
int dis[N];
bool used[N];
int in[N];
bool spfa(int s)
{
    memset(dis,inf,sizeof dis);
    memset(used,0,sizeof used);
    memset(in,0,sizeof in);
    queue<int> q;
    q.push(s);
    dis[s]=0;used[s]=1;in[s]=1;
    while(!q.empty())
    {
        int from=q.front();q.pop();
        used[from]=0;
        for(int i=1;i<=n;i++)
        {
            int to=i;
            int val=mp[from][i];
            if(dis[to]>dis[from]+val)
            {
                dis[to]=dis[from]+val;
                if(!used[to])
                {
                    in[to]++;
                    if(in[to]==n) return 1;//存在一点入队次数大于总顶点数
                    used[to]=1,q.push(to);
                }
            }
        }
        if(dis[s]<0) return 1;//优化
    }
    return 0;
}
int main()
{
    int i,j,t,tt=0;
    scanf("%d",&t);
    while(t--)
    {
        memset(mp,inf,sizeof mp);
        scanf("%d%d%d",&n,&m,&k);
        int a,b,c;
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&c);
            mp[a][b]=mp[b][a]=min(mp[a][b],c);
        }
        while(k--)
        {
            scanf("%d%d%d",&a,&b,&c);
            mp[a][b]=min(mp[a][b],-c);
        }
        if(spfa(1)) printf("YES\n");
        else        printf("NO\n");
    }
}


Floyd(弗洛伊德)算法
用于求每一对顶点之间的最短路径。有向图，无向图均可，也可以有负权边 
时间复杂度O(n3)
空间复杂度O(n2) 

#include<bits/stdc++.h>
using namespace std;
const int N=1e2+7;
const int inf=0x7fffffff;
int f[N][N];
int main()
{
    int i,j,k,m,n,t,tt=0;
    while(scanf("%d%d",&n,&m),n|m)
    {
        int a,b,c;
        memset(f,0x3f3f3f3f,sizeof(f));
        for(i=0;i<m;i++) cin>>a>>b>>c,f[a][b]=c,f[b][a]=c;

        for(k=1;k<=n;k++)
        for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            f[i][j]=min(f[i][j],f[i][k]+f[k][j]);
        cout<<f[1][n]<<endl;
    }
    return 0;
}

经典例题：poj 1125


http://lx.lanqiao.cn/problem.page?gpid=T22

解题报告：http://blog.csdn.net/yyii1111/article/details/18905125

spfa

#include<bits/stdc++.h>
using namespace std;
const int N=25000+10;
const int inf=0x3f3f3f3f;
typedef pair<int,int> pall;
vector<pall> mp[N];
int dis[N];
bool vis[N];
void spfa(int s)
{
    memset(dis,inf,sizeof dis);dis[s]=0;
    memset(vis,0,sizeof vis);  vis[s]=1;
    queue<int> q;              q.push(s);
    while(!q.empty())
    {
        s=q.front();q.pop();
        vis[s]=0;
        for(int i=0;i<mp[s].size();i++)
        {
            int e=mp[s][i].first;
            int val=mp[s][i].second;
            if(dis[e]>dis[s]+val)
            {
                dis[e]=dis[s]+val;
                if(!vis[e]) vis[e]=1,q.push(e);
            }
        }
    }
}
int main()
{
    int i,j,t,tt=0,s,x,y,n,m;
    int a,b,c;
    while(~scanf("%d%d%d%d",&n,&x,&y,&s))
    {
        memset(mp,0,sizeof mp);
        while(x--)
        {
            scanf("%d%d%d",&a,&b,&c);
            mp[a].push_back(make_pair(b,c));
            mp[b].push_back(make_pair(a,c));
        }
        while(y--)
        {
            scanf("%d%d%d",&a,&b,&c);
            mp[a].push_back(make_pair(b,c));
        }
        spfa(s);
        for(int i=1;i<=n;i++) if(dis[i]!=inf) printf("%d\n",dis[i]);
        else printf("NO PATH\n");
    }

spfa优化 

#include<bits/stdc++.h>
using namespace std;
const int N=25000+10;
const int inf=0x3f3f3f3f;
typedef pair<int,int> pall;
vector<pall> mp[N];
int dis[N];
bool vis[N];
void spfa(int s)
{
    memset(dis,inf,sizeof dis);dis[s]=0;
    memset(vis,0,sizeof vis);  vis[s]=1;
    deque<int> q;              q.push_back(s);
    while(!q.empty())
    {
        s=q.front();q.pop_front();
        vis[s]=0;
        for(int i=0;i<mp[s].size();i++)
        {
            int e=mp[s][i].first;
            int val=mp[s][i].second;
            if(dis[e]>dis[s]+val)
            {
                dis[e]=dis[s]+val;
                if(!vis[e])
                {
                    vis[e]=1;
                    if(!q.empty())
                    {
                        if(dis[e]>dis[q.front()])
                            q.push_back(e);
                        else q.push_front(e);
                    }
                    else q.push_back(e);
                }
            }
        }
    }
}
int main()
{
    int i,j,t,tt=0,s,x,y,n,m;
    int a,b,c;
    while(~scanf("%d%d%d%d",&n,&x,&y,&s))
    {
        memset(mp,0,sizeof mp);
        while(x--)
        {
            scanf("%d%d%d",&a,&b,&c);
            mp[a].push_back(make_pair(b,c));
            mp[b].push_back(make_pair(a,c));
        }
        while(y--)
        {
            scanf("%d%d%d",&a,&b,&c);
            mp[a].push_back(make_pair(b,c));
        }
        spfa(s);
        for(int i=1;i<=n;i++) if(dis[i]!=inf) printf("%d\n",dis[i]);
        else printf("NO PATH\n");
    }
}


dijkstra

#include<bits/stdc++.h>
using namespace std;
const int N=25000+10;
const int inf=0x3f3f3f3f;
struct node{
    int to,val;
    node(){}
    node(int a,int b){to=a;val=b;}
    bool operator<(const node &xx)const{
        return xx.val<val;
    }
};
vector<node> mp[N];
int dis[N];
void dijkstra(int s)
{
    memset(dis,inf,sizeof dis);dis[s]=0;
    priority_queue<node> q;q.push(node(s,0));
    while(!q.empty())
    {
        s=q.top().to;  q.pop();
        for(int i=0;i<mp[s].size();i++)
        {
            int e=mp[s][i].to;
            int val=mp[s][i].val;
            if(dis[e]>dis[s]+val)
                q.push(node(e,dis[e]=dis[s]+val));
        }
    }
}
int main()
{
    int i,j,t,tt=0,s,x,y,n,m;
    int a,b,c;
    while(~scanf("%d%d%d%d",&n,&x,&y,&s))
    {
        memset(mp,0,sizeof mp);
        while(x--)
        {
            scanf("%d%d%d",&a,&b,&c);
            mp[a].push_back(node(b,c));
            mp[b].push_back(node(a,c));
        }
        while(y--)
        {
            scanf("%d%d%d",&a,&b,&c);
            mp[a].push_back(node(b,c));
        }
        dijkstra(s);
        for(int i=1;i<=n;i++)
            if(dis[i]!=inf) printf("%d\n",dis[i]);
        else printf("NO PATH\n");
    }
}
有问题 
#include<bits/stdc++.h>
using namespace std;
const int N=25000+10;
const int inf=0x3f3f3f3f;
typedef pair<int,int> pall;
vector<pall> mp[N];
int dis[N];
void dijkstra(int s)
{
    memset(dis,inf,sizeof dis);dis[s]=0;
    priority_queue<pall> q;    q.push(make_pair(s,0));
    while(!q.empty())
    {
        s=q.top().first;  q.pop();
        for(int i=0;i<mp[s].size();i++)
        {
            int e=mp[s][i].first;
            int val=mp[s][i].second;
            if(dis[e]>dis[s]+val)
                q.push(make_pair(e,dis[e]=dis[s]+val));
        }
    }
}
int main()
{
    int i,j,t,tt=0,s,x,y,n,m;
    int a,b,c;
    while(~scanf("%d%d%d%d",&n,&x,&y,&s))
    {
        memset(mp,0,sizeof mp);
        while(x--)
        {
            scanf("%d%d%d",&a,&b,&c);
            mp[a].push_back(make_pair(b,c));
            mp[b].push_back(make_pair(a,c));
        }
        while(y--)
        {
            scanf("%d%d%d",&a,&b,&c);
            mp[a].push_back(make_pair(b,c));
        }
        dijkstra(s);
        for(int i=1;i<=n;i++) if(dis[i]!=inf) printf("%d\n",dis[i]);
        else printf("NO PATH\n");
    }


XerxesSimon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
单源最短路径问题之Dijkstra算法详解
nxiangbo的专栏
12-30 2479
单源最短路径问题之Dijkstra算法详解单源最短路径：给定一个图G=(V,E)G=(V,E),找到从给定源结点s∈Vs \in V到每个结点v∈Vv \in V的最短路径。Dijkstra算法目标：是解决带权重的有向图的单源最短路径问题。 前提：假设对于所有的边(u,v)∈E(u,v) \in E,都有w(u,v)≥0w(u,v) \geq 0。 该算法会在运行过程中维护一个结点集合SS。符号
最短路径---迪杰斯特拉算法[图中一个顶点到其他顶点的最短距离]
dingdunzeng9939的博客
06-14 2792
转自大神：https://www.cnblogs.com/skywang12345/p/3711512.html 是真的牛逼 看大神的吧 舒服点 我注释了点最后代码的部分 迪杰斯特拉算法介绍 迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。 基本思...
POJ 1062.昂贵的聘礼
Alex
01-31 398
Description 年轻的探险家来到了一个印第安部落里。在那里他和酋长的女儿相爱了，于是便向酋长去求亲。酋长要他用10000个金币作为聘礼才答应把女儿嫁给他。探险家拿不出这么多金币，便请求酋长降低要求。酋长说："嗯，如果你能够替我弄到大祭司的皮袄，我可以只要8000金币。如果你能够弄来他的水晶球，那么只要5000金币就行了。“探险家就跑到大祭司那里，向他要求皮袄或水晶球，大祭司要他用金币来换，或者替他弄来其他的东西，他可以降低价格。探险家于是又跑到其他地方，其他人也提出了类似的要求，或者直接用金币换，或
迪杰斯特拉(Dijkstra)算法
热门推荐
xiaoxi_hahaha的博客
11-29 7万+
一 算法介绍 迪杰斯特拉算法是由荷兰计算机科学家在1956年发现的算法，此算法使用类似广度优先搜索的方法解决了带权图的单源最短路径问题。它是一个贪心算法。 二 核心思想 1. 选定一个点，这个点满足两个条件：1.未被选过，2.距离最短 2. 对于这个点的所有邻近点去尝试松弛 三 算法步骤 首先，可以设置两个集合分别是A和B，A用来存放已经求出最短路径的点，B用来存放还未计算出最短路径的点，接下来就可以开始做题啦！！！ 我们从图中任选一点来解题，假设我们将源点source选择..
信息学奥赛一本通 1382：最短路(Spfa)
君义NOIP的博客
03-07 1184
【题目链接】 ybt 1382：最短路(Spfa) 【题目考点】 1. 图论 单源最短路径 图中有V个顶点E条边，单源最短路径算法时间复杂度： 朴素Dijkstra算法：O(V2)O(V^2)O(V2) Dijkstra堆优化算法：O(ElogE)O(ElogE)O(ElogE) SPFA算法：一般情况下O(kE)O(kE)O(kE)，k为顶点度（出度）的平均值，最坏情况下O(VE)O(VE)O(VE) 空间复杂度： 邻接矩阵：O(V2)O(V^2)O(V2) 邻接表：O(V+E)O(V+E)O(V+E)
leetcode2-LeetcodeNotes:LeetCode解决方案和一切
06-29
Bellman-Ford, SPFA, Floyd : 染色法、匈牙利算法 数学知识 其他 LeetCode分类复习清单 Greedy Assignments: , Intervals: [452 Disjoint Interval], DFS / Backtracing [22 Parentheses], [46 Permutation], , [77 ...
leetcode中国-Learn-Algorithms:学习算法
06-29
leetcode中国 #The file is in Chinese 算法虐我千百遍，我待算法如初恋 这里的内容是我学习算法过程的一些记录，希望能一直坚持下去。...Floyd,Dijkstra,bellman-ford,spfa 排序算法 交换排序算法 冒泡排序 插入
leetcode中国-algorithm:算法
06-29
leetcode中国 #The file is in Chinese 算法虐我千百遍，我待算法如初恋 这里的内容是我学习算法过程的一些记录，希望能一直坚持下去。...Floyd,Dijkstra,bellman-ford,spfa 排序算法 交换排序算法 冒泡排序 插入
leetcode和oj-Algorithms:算法
06-30
leetcode 和 oj 算法虐我千百遍，我待算法如...Floyd,Dijkstra,bellman-ford,spfa 排序算法 交换排序算法 冒泡排序 插入排序 选择排序 希尔排序 快排 归并排序 堆排序 线性排序算法 桶排序 查找算法 顺序表查找：顺序
狄克斯特拉(Dijkstra)算法详解
Wopelo的博客
06-26 3万+
最近在看《算法图解》，其中第七章狄克斯特拉算法个人感觉并没有讲的清楚，比如看完7.1节给人的感觉是狄克斯特拉算法会遍历图中的每一条边，后续狄克斯特拉不适用负权边的说法就站不住脚了。后续在查阅诸多资料之后，总结文章一篇，尽可能以通俗易懂且思路清晰的方式来讲解狄克斯特拉算法。...
Dijkstra 算法介绍
实践求真知
07-06 3193
在现实生活中，很多问题都可以转化为图来解决问题。例如，计算地图中两点之间的最短距离、网络最小成本布线，以及工程进度控制，等等。这些问题都涉及最小路径的求解。给定有向带权图 G=(V,E),其中每条边的权值都是非负实数。此外，给定 V 中的一个节点，称之为源点。求解从源点到其他各个节点的最短路径，路径长度指路上各边权之和。可以使用 Dijkstra 算法对最短路径进行求解。Dijkstra 算法是解决单源最短路径的贪心算法，它先求出长度最短的一条路径，再参照该路径求出长度次短的一条路径，直到求出从源点到其他各
Bellman算法和SPFA算法
qq_36684096的博客
03-08 283
Dijkstra算法比较快速，但是如果遇到负边就无能为力了，而Bellman算法可以解决负边问题，只要不是负环。 这个算法数据结构没有讲过，他主要是每次对所以边进行松弛操作，进行n-1次得到最短路径。 其原理如下所述： 首先指出，图的任意一条最短路径既不能包含负权回路，也不会包含正权回路，因此它最多包含|n-1条边。 其次，从源点s可达的所有顶点如果存在最短路径，则这些最短路径构成一个以s为根的最...
Dijkstra算法图文详解
YiYeZhiNian的博客
12-31 4万+
Dijkstra算法算是贪心思想实现的，首先把起点到所有点的距离存下来找个最短的，然后松弛一次再找出最短的，所谓的松弛操作就是，遍历一遍看通过刚刚找到的距离最短的点作为中转站会不会更近，如果更近了就更新距离，这样把所有的点找遍之后就存下了起点到其他所有点的最短距离。 迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。 这样一个有权图，Dijkstra算法可以计算任意节点到其他节点的最短
最短路(floyd\dijkstra\Bellman-Ford\SPFA)
莉莉莉的博客
06-07 1023
转自师哥博客 嘻嘻嘻 1.介绍 　　floyd算法只有五行代码，代码简单，三个for循环就可以解决问题，所以它的时间复杂度为O(n^3)，可以求多源最短路问题。 2.思想： 　　Floyd算法的基本思想如下：从任意节点A到任意节点B的最短路径不外乎2种可能，1是直接从A到B，2是从A经过若干个节点X到B。所以，我们假设Dis(AB)为节点A到节点B的最短路径的距离，对于每一个节点X，我们...
memset函数初始化和最短路中的最大值
Mr_Treeeee的博客
04-23 1258
在最短路中最大值： 最好把最大值设置为0x3f3f3f3f，而非0x7fffffff 理由如下。 #include #include #define MAX1 0x7fffffff #define MAX2 0x3f3f3f3f int a[3]; int main() { memset(a,0x3f,sizeof(a)); printf("%d
SPFA(bellman-ford的队列优化)
STILLxjy
07-15 838
SPFA算法思想： bellman-ford算法的时间复杂度较高，O(n^3)或者O(nm)，原因在于算法要递推n次，且每次递推要扫描所有的边，并且在这个过程中很多遍是多余的.SPFA就是利用队列减少不必要的冗余判断。 SPFA的大致流程就是用一个队列来维护。开始时只有源点在队列里，从队列里取出一个顶点，并对与他相邻的所有顶点进行松弛，松弛成功则入队列。知道队列为空。 关于上面松弛成功，就代表
深入理解Bellman-Ford（SPFA）算法
石旭先森的博客
06-03 799
深入理解Bellman-Ford（SPFA）算法 推荐阅读原文：https://blog.csdn.net/u011893609/article/details/81232124 #include <iostream> #include <queue> #include <cstring> #define inf 0x3f3f3f using namesp...
前缀和入门
m0_68005200的博客
04-12 229
题目描述 有100000个口袋，这些口袋都编了号，编号为1、2、3…….100000,每天会在其中部分连续的口袋中各放一个硬币，n天后BOSS会去看其中m个口袋的硬币数量，当然硬币太多了数起来会很麻烦，你的任务是编程帮他完成数硬币这个工作。 输入 测试数据，第一行为2个整数n,m（1<=n,m<=10000）,n为天数，n天后要去看的口袋数量，接下来n行，每行2个整数a,b(1<=a<=b<=100000),表示当天会从编号a口袋开始到编号b口袋，依次每个...
SPFA 算法和Bellman-Ford 算法与Dijkstra 算法、Floyd 算法有什么异同以及创新性改进或应用
最新发布
06-03
SPFA算法和Bellman-Ford算法与Dijkstra算法、Floyd算法有以下异同和创新性改进或应用： 异同点： 1. Dijkstra算法、Floyd算法和Bellman-Ford算法均不能处理负权边，而SPFA算法可以。 2. Dijkstra算法适用于处理正权...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值