第七章-图-最短路

最新推荐文章于 2026-05-03 22:06:51 发布
原创 最新推荐文章于 2026-05-03 22:06:51 发布 · 1.1k 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

有权图的最短路径求法

Dijkstra算法：https://blog.csdn.net/qq_35644234/article/details/60870719?tdsourcetag=s_pcqq_aiomsg（与Prim过程相似，但是不同，可以按照Prim的思想，全部都求出，然后再做题）

假设想求从V1到各个点的最短路径

从dis数组选择最小值，则该值就是源点s到该值对应的顶点的最短路径，并且把该点加入到T中，OK，此时完成一个顶点， 
然后，我们需要看看新加入的顶点是否可以到达其他顶点并且看看通过该顶点到达其他点的路径长度是否比源点直接到达短，如果是，那么就替换这些顶点在dis中的值。 
然后，又从dis中找出最小值，重复上述动作，直到T中包含了图的所有顶点。
 

  • 先列出V1到各个点的权值，根据列出的值，就可以确定到其中一个顶点的最短路径，确定之后就不能再改变了，比如V1到V2
  • 然后看，确定这个点对应的列（比如V2）的这个点与邻接点之间的权值，比如V2与V3之间连通，V2与V4之间连通，就可以求出V1—V3，V1—V4，如果比原来位置上的数小的话，就替换成这个小的数，当所有与V2相邻的数都完成这一步之后
  • 求出此时的一个最小值，这个值就确定了，不能再修改，然后再像第二步一样进行代换，再确定最小值
  • .........................................
  • 直到除去V1点外其余的点都确定为止

Floyd算法：https://blog.csdn.net/qq_35644234/article/details/60875818（从i到j有好多的方法，可以有好多个中间点，在矩阵中，从i到k，从k到j，不断的一个个的试，最终最小的即为所求）

 

无权图最短路径求法

无权图的最短路径也就是要求两点之间最少几跳可达，那么我们可以这样，用广度遍历，从起点开始一层层遍历，如果第一次遍历到终点，那么肯定是最短路径。

一、判断题

1、

答案：T

解析：这个题明显要用Floyd算法，ba=12=bc+ca=2+x,所以x最小为10。

二、单选题

1、

答案：A

解析：航班不能一个个试，从dis数组选择最小值，则该值就是源点s到该值对应的顶点的最短路径，并且把该点加入到T中，OK，此时完成一个顶点， 
然后，我们需要看看新加入的顶点是否可以到达其他顶点并且看看通过该顶点到达其他点的路径长度是否比源点直接到达短，如果是，那么就替换这些顶点在dis中的值。 
然后，又从dis中找出最小值，重复上述动作，直到T中包含了图的所有顶点。

2、

答案：B

3、

答案：A

解析：

4、

答案：B

解析：

5、

答案：B

解析：

ba=10（最短）=bc+ca=3+ca，所以ca最短为7

                        =-bc+ca=-3+ca，所以最长为13

三、程序填空题

1、

  

 

2、

解析：

其实，这些题做完之后，还可以再手动算一下，自己所写的路径和求出的最小权值是否是相同的，相同则是正确的，因为很有可能数算对了，但是路径求错了

四、编程题

1、城市间紧急救援 （25 分）

作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。

输入格式:

输入第一行给出4个正整数N、M、S、D，其中N（2≤N≤500）是城市的个数，顺便假设城市的编号为0 ~ (N−1)；M是快速道路的条数；S是出发地的城市编号；D是目的地的城市编号。

第二行给出N个正整数，其中第i个数是第i个城市的救援队的数目，数字间以空格分隔。随后的M行中，每行给出一条快速道路的信息，分别是：城市1、城市2、快速道路的长度，中间用空格分开，数字均为整数且不超过500。输入保证救援可行且最优解唯一。

输出格式:

第一行输出最短路径的条数和能够召集的最多的救援队数量。第二行输出从S到D的路径中经过的城市编号。数字间以空格分隔，输出结尾不能有多余空格。

输入样例:

4 5 0 3
20 30 40 10
0 1 1
1 3 2
0 3 3
0 2 2
2 3 2

输出样例:

2 60
0 1 3

答案

 

#include <bits/stdc++.h>

using namespace std;

#define INF 99999999
#define MAX 100000

struct  MGraph
{
    int v;//顶点数
    int e;//边数
    int G[501][501];//存两者之间的权值
};

int oldteam[MAX];//原来的城市救援人数
int newteam[MAX];//现在新的城市救援人数
int d[MAX];//任意顶点到目的地的距离
int way[MAX];
int visited[MAX]={false};
int path[MAX];
int S,D;//出发地、目的地

void CreatGraph(MGraph &GR)
{
    int N,M;//城市个数、快速道路条数
    scanf("%d%d%d%d",&N,&M,&S,&D);
    GR.v=N;
    GR.e=M;
    for(int i=0;i<N;i++)
    {
        scanf("%d",&oldteam[i]);
    }
    for(int i=0;i<N;i++)
    {
        for(int j=0;j<N;j++)
        {
            GR.G[i][j]=INF;
        }
    }
    for(int i=0;i<M;i++)
    {
        int c1,c2,l;
        scanf("%d%d%d",&c1,&c2,&l);
        GR.G[c1][c2]=GR.G[c2][c1]=l;//无向图
    }
    for(int i=0;i<N;i++)
    {
        d[i]=INF;
    }
}

void Dijkstra(MGraph GR,int S)
{
    d[S]=0;
    newteam[S]=oldteam[S];
    way[S]=1;

    for(int i=0;i<GR.v;i++)//从S出发，到各个点的最短路径
    {
        int u=-1,MIN=INF;
        for(int j=0;j<GR.v;j++)
        {
            if(d[j]<MIN&&!visited[j])
            {
                u=j;
                MIN=d[j];
            }
        }
        visited[u]=true;//找出每一列对应数组中最小的数
        for(int i=0;i<GR.v;i++)
        {
            if(!visited[i]&&GR.G[u][i]!=INF)//找出最小列对应行有没有未访问的邻接点
            {
                if(d[u]+GR.G[u][i]==d[i])//相等这说明，同样短
                {
                    way[i]+=way[u];//到达的方式要两者结合
                    if(newteam[i]<newteam[u]+oldteam[i])//到达的方式要两者结合取最大值
                        newteam[i]=newteam[u]+oldteam[i];
                }
                else if(d[u]+GR.G[u][i]<d[i])
                {
                    d[i]=d[u]+GR.G[u][i];//更新数值
                    way[i]=way[u];
                    newteam[i]=newteam[u]+oldteam[i];
                }
            }
        }
    }
}
int main()
{
    MGraph GR;
    CreatGraph(GR);
    Dijkstra(GR,S);
    printf("%d %d\n",way[D],newteam[D]);
    int k=D;
    int cout=0;
    path[cout++]=D;
    while(k!=S)
    {
        for(int i=0;i<GR.v;i++)
        {
            if((d[k]==d[i]+GR.G[i][k])&&GR.G[i][k]!=INF&&i!=k&&(newteam[k]==newteam[i]+oldteam[k]))
            {
                path[cout++]=i;
                k=i;
                break;
            }
        }
    }
    for(int i=cout-1;i>=0;i--)
    {
        if(i==cout-1)
            printf("%d",path[i]);
        else
            printf(" %d",path[i]);
    }
    return 0;
}

2、天梯地图 （30 分）

本题要求你实现一个天梯赛专属在线地图，队员输入自己学校所在地和赛场地点后，该地图应该推荐两条路线：一条是最快到达路线；一条是最短距离的路线。题目保证对任意的查询请求，地图上都至少存在一条可达路线。

输入格式：

输入在第一行给出两个正整数N（2 ≤ N ≤ 500）和M，分别为地图中所有标记地点的个数和连接地点的道路条数。随后M行，每行按如下格式给出一条道路的信息：

V1 V2 one-way length time

其中V1和V2是道路的两个端点的编号（从0到N-1）；如果该道路是从V1到V2的单行线，则one-way为1，否则为0；length是道路的长度；time是通过该路所需要的时间。最后给出一对起点和终点的编号。

输出格式：

首先按下列格式输出最快到达的时间T和用节点编号表示的路线：

Time = T: 起点 => 节点1 => ... => 终点

然后在下一行按下列格式输出最短距离D和用节点编号表示的路线：

Distance = D: 起点 => 节点1 => ... => 终点

如果最快到达路线不唯一，则输出几条最快路线中最短的那条，题目保证这条路线是唯一的。而如果最短距离的路线不唯一，则输出途径节点数最少的那条，题目保证这条路线是唯一的。

如果这两条路线是完全一样的，则按下列格式输出：

Time = T; Distance = D: 起点 => 节点1 => ... => 终点

输入样例1：

10 15
0 1 0 1 1
8 0 0 1 1
4 8 1 1 1
5 4 0 2 3
5 9 1 1 4
0 6 0 1 1
7 3 1 1 2
8 3 1 1 2
2 5 0 2 2
2 1 1 1 1
1 5 0 1 3
1 4 0 1 1
9 7 1 1 3
3 1 0 2 5
6 3 1 2 1
5 3

输出样例1：

Time = 6: 5 => 4 => 8 => 3
Distance = 3: 5 => 1 => 3

输入样例2：

7 9
0 4 1 1 1
1 6 1 3 1
2 6 1 1 1
2 5 1 2 2
3 0 0 1 1
3 1 1 3 1
3 2 1 2 1
4 5 0 2 2
6 5 1 2 1
3 5

输出样例2：

Time = 3; Distance = 4: 3 => 2 => 5

 答案

//Dijkstra算法
#include<bits/stdc++.h>
using namespace std;
#define OK        1
#define ERROR     0
#define INF       0x3f3f3f3f
#define MAX       1000//最大顶点数
typedef int Status;
//邻接矩阵
int GD[MAX][MAX];
int GT[MAX][MAX];
int D[MAX];//初始点到每个点最短的距离
int T[MAX];//初始点到每个点的最短的是阿锦
int TD[MAX]= {0};
int DT[MAX]= {0};
int visited[MAX]= {false}; //标记顶点是否被访问过
int pathT[MAX]= {0};
int pathD[MAX]= {0};
int n,m,s,d;//顶点数和边数,起点和终点
Status CreateGraph()
{
    cin>>n>>m;
    int v1,v2,one_way,len,time;
    for(int i=0; i<n; ++i)
    {
        D[i]=INF;
        T[i]=INF;
    }
    for(int i=0; i<n; ++i)
        for(int j=0; j<n; ++j)
        {
            GD[i][j]=INF;
            GT[i][j]=INF;
        }
    for(int i=0; i<m; ++i)
    {
        cin>>v1>>v2>>one_way>>len>>time;
        if(!one_way)
        {
            GD[v1][v2]=len;
            GD[v2][v1]=len;
            GT[v1][v2]=time;
            GT[v2][v1]=time;
        }
        else
        {
            GD[v1][v2]=len;
            GD[v2][v1]=INF;
            GT[v1][v2]=time;
            GT[v2][v1]=INF;
        }
    }
    cin>>s>>d;
}
void DijkstraT()
{
    //求最快到达时间
    T[s]=0;
    D[s]=0;
    for(int i=0; i<n; ++i)
    {
        int u=-1,min=INF;
        for(int j=0; j<n; ++j)
            if(min>T[j]&&!visited[j])
            {
                u=j;
                min=T[j];
            }
        visited[u]=true;
        for(int v=0; v<n; ++v)
        {
            if(!visited[v]&&GT[u][v]!=INF)
            {
                if(GT[u][v]+T[u]<T[v])
                {
                    T[v]=GT[u][v]+T[u];
                    TD[v]=GD[u][v]+D[u];//距离
                }
                else if(GT[u][v]+T[u]==T[v])
                {
                    if(GD[u][v]+D[u]<TD[v])//若两条时间相等，则选择最短的路
                    {
                        TD[v]=GD[u][v]+D[u];
                    }
                }
            }
        }
    }
}
int sum[MAX]={0};
int pre[MAX]={0};
void DijkstraD()
{
    D[s]=T[s]=0;
    for(int i=0; i<n; ++i)
    {
        visited[i]=false;
        sum[i]=1;
    }
    //求最快的路径
    for(int i=0; i<n; ++i)
    {
        int u=-1,min=INF;
        for(int j=0; j<n; ++j)
            if(min>D[j]&&!visited[j])
            {
                u=j;
                min=D[j];
            }
        visited[u]=true;
        for(int v=0; v<n; ++v)
        {
            if(!visited[v]&&GD[u][v]!=INF)
            {
                if(GD[u][v]+D[u]<D[v])
                {
                    D[v]=GD[u][v]+D[u];
                    sum[v]=sum[u]+1;
                    pre[v]=u;
                }
                else if(GD[u][v]+D[u]==D[v])
                {
                    if(sum[v]>sum[u]+1)
                    {
                        sum[v]=sum[u]+1;
                        pre[v]=u;
                    }
                }
            }
        }
    }
}
int main()
{
    CreateGraph();
    DijkstraT();
    int k=d;
    int countT=0;
    pathT[countT++]=d;
    while(k!=s)
    {
        for(int i=0; i<n; ++i)
        {
            if((T[k]==T[i]+GT[i][k])&&(TD[k]==D[i]+GD[i][k])&&GT[i][k]!=INF&&i!=k)
            {
                pathT[countT++]=i;k=i;
                break;
            }
        }
    }
    DijkstraD();
    int countD=0;
    k=d;
    pathD[countD++]=d;
    while(k!=s)
    {
        k=pre[k];
        pathD[countD++]=k;
    }
    int flag=1;
    if(countT!=countD)
        flag=0;
    else
    {
        for(int i=0; i<countT; ++i)
        {
            if(pathD[i]!=pathT[i])
            {
                flag=0;
                break;
            }
        }
    }

    if(!flag)
    {
        cout<<"Time = "<<T[d]<<": ";
        for(int i=countT-1; i>=0; --i)
        {
            if(i==countT-1)
                cout<<pathT[i];
            else
                cout<<" => "<<pathT[i];
        }
        cout<<endl;
        cout<<"Distance = "<<D[d]<<": ";
        for(int i=countD-1; i>=0; --i)
        {
            if(i==countD-1)
                cout<<pathD[i];
            else
                cout<<" => "<<pathD[i];
        }
    }
    else
    {
        cout<<"Time = "<<T[d]<<"; "<<"Distance = "<<D[d]<<": ";
        for(int i=countD-1; i>=0; --i)
        {
            if(i==countD-1)
                cout<<pathD[i];
            else
                cout<<" => "<<pathD[i];
        }
    }

}

 

《数据结构》| 第七章 图 知识梳理
12 26 25 的博客
01-21 1万+
图  目录 1.了解图的基本概念（图的定义、有向图、无向图、完全图、带权图、邻接顶点、顶点的度、子图、路径、连通图等） 2.熟练掌握图的两种存储结构（邻接矩阵表示法、邻接表表示法）。 3.熟练掌握图的两种遍历算法（深度优先搜索遍历、广度优先搜索遍历）、能采用这两种遍历算法得到图的生成树。 4.熟练掌握图的两种最小生成树（MST）算法思想（Prim、Kruskal）。 5.掌握图的单源...
Dijkstra算法（一个节点到其他所有节点的最短路径）
越努力，越幸运！！！
11-09 1万+
Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运筹学等等。注意该算法要求图中不存在负权边。 问题描述：在无向图 G=(V,E) 中，假设每条边 E[i] 的长度为 w[i]，...
数据结构-Dijkstra最短路径算法
xinzhi1992的博客
08-27 1106
Dijkstra最短路径算法
最短路算法总结
最新发布
Matthew_zhu_的博客
05-03 981
本文总结了三种最短路算法及其适用场景：1. 单源无负权最短路：BFS（无边权）、Dijkstra（O(N^2)暴力或O(MlogM)优先队列优化）；2. 单源有负权最短路：Bellman-Ford（O(NM)）及其队列优化SPFA（可判负环）；3. 多源最短路：Floyd算法（O(N^3)，可处理负权但不判负环）。文中通过代码示例详细说明了Bellman-Ford和SPFA判断负环的实现逻辑，并指出Floyd的核心思想是通过中转点k更新最短路径。最后强调算法选择需根据具体场景（如是否存在负权、是否需要多源解
路由算法
ii0789789789的博客
12-16 4182
距离矢量路由算法（D-V） Distance vector routing:动态路由算法，最初应用于ARPANET，后来应用于因特网的RIP协议（路由信息协议) ，Cisco的IGRP和EIGRP路由协议也是采用DV这种路由算法的。 基本思想 每个结点通过测取与相邻结点的距离，再依据与其相邻结点交换的距离信息(度量可能采用跳数，时间延时等)，间接地求出路由表，邻居之间相互交换信息 1）各结...
最短路径—Dijkstra算法和Floyd算法
weixin_38166726的博客
03-13 302
看到好文章，忍不住就转了 最短路径—Dijkstra算法和Floyd算法 Dijkstra算法 1.定义概览 Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运...
【算法】dijkstra--最短路径
gogo小Sa的专栏
04-20 1662
【算法】dijkstra--最短路径    1.算法特点    2.算法思路    3.算法实例演示    4.代码实现 参考：Dijkstra算法详解https://blog.csdn.net/qq_35644234/article/details/60870719代码实现 https://blog.csdn.net/mimi9919/article/details/51219176  1.算法...
第七章-图-最短路-计算机17级（期末复习带详解版）
markconca的博客
11-22 2356
解析在下面：  p1-1： 如果c到a的最短路径小于10， 那么b到a的最短路径必定小于12， 与题意矛盾。  x2-3： x2-4： x2-5：要仔细 3,4是对的 填空题： 都没啥可说的，两个都用Dijstra模拟下，只不过一个有权，一个无权（权为1）。 后面就不用看啦!!!           1-1 在一个有权无向图中，若b到...
7-1 城市间紧急救援 （25 分）第七章-图-最短路-计算机17级
markconca的博客
11-29 1258
7-1 城市间紧急救援 （25 分） 作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。 输入格式: 输入第一行给出4个正整数N、M、S、D，其中N（2...
7-2 天梯地图 （30 分）第七章-图-最短路-计算机17级
markconca的博客
11-24 813
7-2 天梯地图 （30 分） 本题要求你实现一个天梯赛专属在线地图，队员输入自己学校所在地和赛场地点后，该地图应该推荐两条路线：一条是最快到达路线；一条是最短距离的路线。题目保证对任意的查询请求，地图上都至少存在一条可达路线。 输入格式： 输入在第一行给出两个正整数N（2 ≤ N ≤ 500）和M，分别为地图中所有标记地点的个数和连接地点的道路条数。随后M行，每行按如下格式给出一条道路的信...
D算法**-指定端到其他端的最短路径算法
weixin_45689929的博客
12-21 633
数据结构与算法 D算法-指定端到其他端的最短路径算法 /* D算法对有向图也适用 也可适用于端点有权的情况 D算法不适用于边的权有正有负的情况 2020-12-17 written by HL */ #include<bits/stdc++.h> using namespace std; #define MAX_VERTEX_NUM 100 //最大矩阵维度 typedef struct MGRAPH { int n;//图中顶点数目 int e;//图中边的数目 int vertex[
21、数据结构与算法 - 图 最短路径（一）Dijkstra算法
shengdaVolleyball的博客
06-07 1371
图 最短路径 图的最短路径是求图上两个点相连的话最短的路径不需要连接所有点 如下图，要从源点 v0 到 终点 v8 图的邻接矩阵存储 最终应求得的结果 Dijkstra算法 思路分析： 初始化3个数组， final数组： 用来标记顶点是否已经求得最短路径，求得标记为1，没有标记为0.求得过的，不再重复计算 D数组： 用来比较V0 到某个顶点的路径（例如V0->V3 = V0->V1+V1->V3,当然也会有多条路径的情况，进行比较如果比当前数...
迪杰斯特拉 (Dijkstra)算法求最短路径问题
专注Spring、SSM、数据结构与算法、蓝桥杯领域创作者
03-23 9667
<%-- Created by IntelliJ IDEA. User: lenovo Date: 2022/3/23 Time: 14:38 To change this template use File | Settings | File Templates. --%> <%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> .
利用Dijkstra算法求顶点v1到其他各顶点的最短路径Java实现
CSDN 精品推荐
11-22 3355
利用Dijkstra算法求顶点v1到其他各顶点的最短路径 以下代码仅供参考 以下代码仅供参考 以下代码仅供参考 /** *作者：魏宝航 *2020年11月23日,下午15:31 */ import java.io.IOException; import java.util.Scanner; public class MatrixUDG { private int mEdgNum; private char[] mVexs; private int[][] mMatrix; .
图中求最短路径的算法
wyqwilliam的博客
10-04 1001
在许多应用领域，带权图都被用来描述某个网络，比如通信网络、交通网络等。这种情况下，各边的权重就对应于两点之间通信的成本或交通费用。     此时，一类典型的问题就是：在任意指定的两点之间如果存在通路，那么最小的消耗是多少。这类问题实际上就是带权图中两点之间最短路径的问题。     问题：计算V1到V8的最短路径 最短路径1：段数最少的最短路径：换乘最少  使用广度优先遍历即可 类似问题：编写国...
最短路问题(Dijkstra/Floyd)
syzyaaa
03-31 1076
最短路问题就是求 【一个点到另一个点的最短路径】 分为单源最短路（一个点到各个点之间的距离）和多源最短路（任意两点之间的距离） 1.Dijkstra算法 使用广度优先搜索，解决【赋权有向图】或【无向图的单源最短路径】问题，不能出现负边 基于【贪心】思想 1.1 内容 // 用dis[]dis[]dis[]数组储存从顶点到其他点的路径，通过一步步遍历比较，不断更新（保留最小的，改变较大的），最后得到dis即为所求 求从v1到各个点的最短路： step1：初始化dis step2：找最小的，固定.
图及最短路径
Anna4的博客
05-16 2617
一、图 1、定义： 描述的是多对多的关系，图是一种网状数据结构，图是由非空的顶点集合和一个描述顶点之间关系(边)的集合组成。 2、分类： 3、图的存储 （1）邻接矩阵：二维数组 顺序存储结构 （2）邻接表：链表 链式存储结构 4、应用： 各种地图，地铁线路图等 二、图的遍历 1、概念 图的遍历就是从图中某个顶点出发，按某种方法对图中所有顶点访问且仅访问一次。 图的遍历算法是求解图的连通性...
利用Dijkstra算法在下图中求出从源点V1到其余各点的最短路 （第四题）
热门推荐
古影轩
11-10 2万+
利用Dijkstra算法在下图中求出从源点V1到其余各点的最短路.   1.V1   V1 V2 V3 V4 V5 V6 V1   40 30 20 10   2.过V5   V1
最短路径之迪杰斯特拉算法
Yummy
09-12 2424
本文将讲解图中最短路径的求解算法之迪杰斯特拉算法及其Java实现。
设计求源点v到其他顶点最短路径和最短路径长度的Dijkstra算法。
我要吃木耳的博客
12-11 2203
【问题描述】 假设一个带权有向图采用邻接表存储，设计求源点v到其他顶点最短路径的Dijkstra算法。 【输入形式】 第一行顶点个数n,边数，第二行到第n+1行是邻接矩阵 【输出形式】 从顶点0依次输出到其它每个顶点的最短路径序列 【样例输入】 7 12 0 4 6 6 327673276732767 32767 0 132767 73276732767 3276732767 032767 6 432767 3276732767 2 032767 532767 327...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值