算法思想（七）—— 图论基础

最新推荐文章于 2023-08-09 18:20:39 发布
最新推荐文章于 2023-08-09 18:20:39 发布
阅读量322 收藏
点赞数
分类专栏： 算法思想
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_38368658/article/details/90411340
版权

7.1 图论基础

节点
边
应用:交通运输，社交网络，互联网，工作安排，脑区活动，程序状态执行

  • 图的分类：有向图，无向图
    后文讲解以无向图为主
    无向图是一种特殊的有向图（两个节点相互指向），有向图由于其不对称型，演变出更多复杂的问题和专门针对有向图的算法（暂不涉及）

  • 图的分类：无权图，有权图

  • 图的连通性

  • 简单图：自环边，平行边。

7.2 图的表示

  • 邻接矩阵：适合表示稠密图（Dense Graph），例如完全图
#ifndef DENSEGRAPH_H_INCLUDED
#define DENSEGRAPH_H_INCLUDED

#include<iostream>
#include<vector>
#include<cassert>

using namespace std;

//稠密图 -- 邻接矩阵
class DenseGraph{

private:
    int n,m;
    bool directed;
    vector<vector<bool>> g;

public:
    DenseGraph(int n,bool directed)
    {
        this->n=n;
        this->m=0;
        this->directed=directed;
        for(int i=0;i<n;i++)
            g.push_back(vector<bool>(n,false));
    }

    ~DenseGraph()
    {

    }

    int V()
    {
        return n;
    }

    int E()
    {
        return m;
    }

    void addEdge(int v,int w)
    {
        //严谨一些，先考虑v和w都不能越界
        assert(v>=0 && v<n);
        assert(w>=0 && w<n);

        if(hasEdge(v,w))
            return;

        g[v][w]=true;
        if(!directed)
            g[w][v]=true;

        m++;
    }

    bool hasEdge(int v,int w)
    {
        assert(v>=0 && v<n);
        assert(w>=0 && w<n);
        return g[v][w];
    }
};


#endif // DENSEGRAPH_H_INCLUDED
  • 邻接表：适合表示稀疏图（Sparse Graph）
#ifndef SPARSEGRAPH_H_INCLUDED
#define SPARSEGRAPH_H_INCLUDED

#include<iostream>
#include<vector>
#include<cassert>

using namespace std;

//稀疏图 —— 邻接表
class SparseGraph{

private:
    int n,m;
    bool directed;
    vector<vector<int>> g;

public:
    SparseGraph(int n,bool directed)
    {
        this->n=n;
        this->m=0;
        this->directed=directed;
        for(int i=0;i<n;i++)
            g.push_back(vector<int>());
    }

    ~SparseGraph()
    {

    }

    int V()
    {
        return n;
    }

    int E()
    {
        return m;
    }

    void addEdge(int v,int w)
    {
        //严谨一些，先考虑v和w都不能越界
        assert(v>=0 && v<n);
        assert(w>=0 && w<n);

        if(hasEdge(v,w))
            return;

        g[v].push_back(w);
        if(v!=w && !directed)//防止有自环边问题
            g[w].push_back(v)

        m++;
    }

    bool hasEdge(int v,int w)
    {
        assert(v>=0 && v<n);
        assert(w>=0 && w<n);
        for(int i=0;i<g[v].size();i++)
            if(g[v][i]==w)
                return true;
        return false;
    }
};

#endif // SPARSEGRAPH_H_INCLUDED

7.3 相邻点迭代器

在这里插入图片描述
使用上述的思路其实就是遍历class里的二维数组g就可以得到一个点相邻的点，但这的前提是要把vector<vector<bool>> g设为public，但其实，这样会让外部用户访问到g，有可能会泄露或修改数据，不够安全
如何在vector<vector<bool>> g保持为private的情况下遍历一个点的相临点？
答：使用迭代器，用户通过迭代器找到图中一个结点的相邻接点

稀疏图

#ifndef SPARSEGRAPH_H_INCLUDED
#define SPARSEGRAPH_H_INCLUDED

#include<iostream>
#include<vector>
#include<cassert>

using namespace std;

//稀疏图 —— 邻接表
class SparseGraph{

private:
    int n,m;
    bool directed;
    vector<vector<int> > g;

public:
    SparseGraph(int n,bool directed)
    {
        this->n=n;
        this->m=0;
        this->directed=directed;
        for(int i=0;i<n;i++)
            g.push_back(vector<int>());
    }

    ~SparseGraph()
    {

    }

    int V()
    {
        return n;
    }

    int E()
    {
        return m;
    }

    void addEdge(int v,int w)
    {
        //严谨一些，先考虑v和w都不能越界
        assert(v>=0 && v<n);
        assert(w>=0 && w<n);

        if(hasEdge(v,w))
            return;

        g[v].push_back(w);
        if(v!=w && !directed)//防止有自环边问题
            g[w].push_back(v);

        m++;
    }

    bool hasEdge(int v,int w)
    {
        assert(v>=0 && v<n);
        assert(w>=0 && w<n);
        for(int i=0;i<g[v].size();i++)
            if(g[v][i]==w)
                return true;
        return false;
    }

    class adjIterator{
    private:
        SparseGraph &G;
        int v;
        int index;
    public:
        adjIterator(SparseGraph &graph,int v):G(graph)
        {
            this->v=v;
            this->index=0;
        }

        int begin()
        {
            index = 0;
            if(G.g[v].size())
                return G.g[v][index];
            return -1;
        }

        int next()
        {
            index++;
            if(index<G.g[v].size())
                return G.g[v][index];
            return -1;
        }

        bool end()
        {
            return index>=G.g[v].size();
        }
    };
};

#endif // SPARSEGRAPH_H_INCLUDED

稠密图

#ifndef DENSEGRAPH_H_INCLUDED
#define DENSEGRAPH_H_INCLUDED

#include<iostream>
#include<vector>
#include<cassert>

using namespace std;

//稠密图 -- 邻接矩阵
class DenseGraph{

private:
    int n,m;
    bool directed;
    vector<vector<bool> > g;

public:
    DenseGraph(int n,bool directed)
    {
        this->n=n;
        this->m=0;
        this->directed=directed;
        for(int i=0;i<n;i++)
            g.push_back(vector<bool>(n,false));
    }

    ~DenseGraph()
    {

    }

    int V()
    {
        return n;
    }

    int E()
    {
        return m;
    }

    void addEdge(int v,int w)
    {
        //严谨一些，先考虑v和w都不能越界
        assert(v>=0 && v<n);
        assert(w>=0 && w<n);

        if(hasEdge(v,w))
            return;

        g[v][w]=true;
        if(!directed)
            g[w][v]=true;

        m++;
    }

    bool hasEdge(int v,int w)
    {
        assert(v>=0 && v<n);
        assert(w>=0 && w<n);
        return g[v][w];
    }

    class adjIterator{
    private:
        DenseGraph &G;
        int v;
        int index;
    public:
        adjIterator(DenseGraph &graph,int v):G(graph)
        {
            this->v= v;
            this->index = -1;
        }

        int begin()
        {
            index=-1;
            return next();
        }

        int next()
        {
            for(index+=1;index<G.V();index++)
                if(G.g[v][index])
                    return index;
            return -1;
        }

        bool end()
        {
            return index>=G.V();
        }
    };
};


#endif // DENSEGRAPH_H_INCLUDED

测试主函数

#include <iostream>
#include<stdlib.h>
#include<ctime>

#include"DenseGraph.h"
#include"SparseGraph.h"
using namespace std;

int main()
{
    //首先生成一个图
    int N =20;
    int M = 100;

    srand(time(NULL));

    cout<<" ---Sparse Graph----"<<endl;
    //Sparse Graph
    SparseGraph g1(N,false);

    for(int i=0;i<M;i++)
    {
        int a = rand()%N;
        int b = rand()%N;
        g1.addEdge(a,b);
    }

    //O(E)
    for(int v=0;v<N;v++)
    {
        cout<<v<<" : ";
        //对每个顶点生成寻找它相邻点的迭代器
        SparseGraph::adjIterator adj(g1,v);
        for(int w = adj.begin();!adj.end();w=adj.next())
            cout<<w<<" ";
        cout<<endl;
    }

    cout<<endl;

    cout<<" ---Dense Graph----"<<endl;
    DenseGraph g2(N,false);

    for(int i=0;i<M;i++)
    {
        int a = rand()%N;
        int b = rand()%N;
        g2.addEdge(a,b);
    }

    //O(v^2)
    for(int v=0;v<N;v++)
    {
        cout<<v<<" : ";
        //对每个顶点生成寻找它相邻点的迭代器
        DenseGraph::adjIterator adj(g2,v);
        for(int w = adj.begin();!adj.end();w=adj.next())
            cout<<w<<" ";
        cout<<endl;
    }

    cout<<endl;
    return 0;
}

在这里插入图片描述

可以看到对于稀疏图和稠密图的调用接口一样，可以任意传入稀疏图或者说稠密图图算法被封装，

7.4 图的算法框架

我们定义一个类readGraph读取txt文件里面的图
在这里插入图片描述

#ifndef READGRAPH_H_INCLUDED
#define READGRAPH_H_INCLUDED

#include<iostream>
#include<string>
#include<fstream>
#include<sstream>
#include<cassert>

using namespace std;

template<typename Graph>
class ReadGraph{

public:
    ReadGraph(Graph &graph,const string &filename)
    {
        ifstream file(filename.c_str());
        string line;
        int V,E;

        assert(file.is_open());

        assert(getline(file,line));
        stringstream ss(line);
        ss>>V>>E;

        assert(V==graph.V());

        for(int i=0;i<E;i++){

            assert(getline(file,line));
            stringstream ss(line);

            int a,b;
            ss>>a>>b;

            assert(a>=0 && a< V);
            assert(b>=0 && b< V);
            graph.addEdge(a,b);
        }
    }
};


#endif // READGRAPH_H_INCLUDED

在稀疏图和稠密图里分别加入一个供测试使用的打印函数
稀疏图中

    void show(){

        for( int i = 0 ; i < n ; i ++ ){
            cout<<"vertex "<<i<<":\t";
            for( int j = 0 ; j < g[i].size() ; j ++ )
                cout<<g[i][j]<<"\t";
            cout<<endl;
        }
    }

稠密图中:

void show(){

        for( int i = 0 ; i < n ; i ++ ){
            for( int j = 0 ; j < n ; j ++ )
                cout<<g[i][j]<<"\t";
            cout<<endl;
        }
    }

测试

#include<iostream>

#include"SparseGraph.h"
#include"DenseGraph.h"
#include"ReadGraph.h"

using namespace std;

int main()
{
    //打印稀疏图的邻接表
    string filename = "testG1.txt";

    SparseGraph g1(13,false);
    ReadGraph<SparseGraph> readGraph1(g1,filename);
    g1.show();

    cout<<endl;

    //打印稠密图的邻接矩阵
    string filename2 = "testG2.txt";
    DenseGraph g2(6,false);
    ReadGraph<DenseGraph> readGraph2(g2,filename2);
    g2.show();
    return 0;
}

在这里插入图片描述

7.5 深度优先遍历和连通分量

在这里插入图片描述
在这里插入图片描述

#ifndef COMPONENT_H_INCLUDED
#define COMPONENT_H_INCLUDED

#include<iostream>
#include<cassert>

template <typename Graph>
class Component{
    Graph &G;
    bool *visited;
    int ccount;//记录有多少个连通分量
    int *id;

    void dfs(int v)
    {
        visited[v]=true;
        id[v]=ccount;

        typename Graph::adjIterator adj(G,v);
        for(int i=adj.begin();!adj.end();i=adj.next())
        {
            if(!visited[i])
                dfs(i);//递归的方式进行深度优先遍历
        }
    }

public:
    Component(Graph &graph):G(graph)
    {
        visited = new bool[G.V()];
        id = new int[G.V()];
        ccount = 0;
        for(int i=0;i<G.V();i++)
        {
            visited[i]=false;
            id[i]=-1;
        }

        for(int i=0;i<G.V();i++)
            if(!visited[i]){
                 dfs(i);
                 ccount++;
            }
    }

    ~Component()
    {
        delete []visited;
        delete []id;
    }

    int count()
    {
        return ccount;
    }

    bool isConnected(int v,int w)
    {
        assert(v>=0 && v<G.V());
        assert(w>=0 &&w <G.V());
        return id[v]==id[w];
    }
};


#endif // COMPONENT_H_INCLUDED

7.6 寻路

#ifndef PATH_H_INCLUDED
#define PATH_H_INCLUDED

#include<stack>
template<typename Graph>
class Path{

private:
    Graph &G;
    int s;
    bool* visited;
    int* from;

    void dfs(int v)
    {
        visited[v]=true;

        typename Graph::adjIterator adj(G,v);
        for(int i=adj.begin();!adj.end();i=adj.next())
        {
            if(!visited[i])
            {
                from[i]=v;
                dfs(i);//递归的方式进行深度优先遍历
            }

        }
    }

public:
    Path(Graph &graph,int s):G(graph)
    {
        //算法初始化
        assert(s>=0 && s<G.V());

        visited = new bool[G.V()];
        from = new int[G.V()];
        for(int i=0;i<G.V();i++)
        {
            visited[i]=false;
            from[i]=-1;
        }
        this->s=s;

        //寻路算法
        dfs(s);
    }

    ~Path()
    {
        delete[] visited;
        delete[] from;
    }

    bool hasPath(int w)
    {
        assert(w>=0 && w<G.V());
        return visited[w];
    }

    void path(int w,vector<int> &vec)
    {
        stack<int> s;

        int p = w;
        while(p!=-1)
        {
            s.push(p);
            p=from[p];
        }
        vec.clear();
        while(!s.empty()){
            vec.push_back(s.top());
            s.pop();
        }
    }


    void showPath(int w)
    {
        vector<int> vec;
        path(w,vec);
        for(int i=0;i<vec.size();i++)
        {
            cout<<vec[i];
            if(i==vec.size()-1)
                cout<<endl;
            else
                cout<<"==>";
        }
    }
};


#endif // PATH_H_INCLUDED



int main()
{
    string filename = "testG2.txt";
    SparseGraph g = SparseGraph(7,false);
    ReadGraph<SparseGraph> ReadGraph(g,filename);
    g.show();
    cout<<endl;

    Path<SparseGraph> dfs(g,0);
    cout<<"DFS:";
    dfs.showPath(6);

    return 0;
}

在这里插入图片描述
在这里插入图片描述

7.7 广度优先遍历和最短路径

广度优先遍历求出了无权图的最短路径

#ifndef INC_07_BFS_AND_SHORTEST_PATH_SHORTESTPATH_H
#define INC_07_BFS_AND_SHORTEST_PATH_SHORTESTPATH_H

#include <vector>
#include <queue>
#include <stack>
#include <iostream>
#include <cassert>

using namespace std;


// 寻找无权图的最短路径
template <typename Graph>
class ShortestPath{

private:
    Graph &G;       // 图的引用
    int s;          // 起始点
    bool *visited;  // 记录dfs的过程中节点是否被访问
    int *from;      // 记录路径, from[i]表示查找的路径上i的上一个节点
    int *ord;       // 记录路径中节点的次序。ord[i]表示i节点在路径中的次序。

public:
    // 构造函数, 寻找无权图graph从s点到其他点的最短路径
    ShortestPath(Graph &graph, int s):G(graph){

        // 算法初始化
        assert( s >= 0 && s < graph.V() );

        visited = new bool[graph.V()];
        from = new int[graph.V()];
        ord = new int[graph.V()];
        for( int i = 0 ; i < graph.V() ; i ++ ){
            visited[i] = false;
            from[i] = -1;
            ord[i] = -1;
        }
        this->s = s;

        // 无向图最短路径算法, 从s开始广度优先遍历整张图
        queue<int> q;

        q.push( s );
        visited[s] = true;
        ord[s] = 0;
        while( !q.empty() ){

            int v = q.front();
            q.pop();

            typename Graph::adjIterator adj(G, v);
            for( int i = adj.begin() ; !adj.end() ; i = adj.next() )
                if( !visited[i] ){
                    q.push(i);
                    visited[i] = true;
                    from[i] = v;
                    ord[i] = ord[v] + 1;
                }
        }

    }

    // 析构函数
    ~ShortestPath(){

        delete [] visited;
        delete [] from;
        delete [] ord;
    }

    // 查询从s点到w点是否有路径
    bool hasPath(int w){
        assert( w >= 0 && w < G.V() );
        return visited[w];
    }

    // 查询从s点到w点的路径, 存放在vec中
    void path(int w, vector<int> &vec){

        assert( w >= 0 && w < G.V() );

        stack<int> s;
        // 通过from数组逆向查找到从s到w的路径, 存放到栈中
        int p = w;
        while( p != -1 ){
            s.push(p);
            p = from[p];
        }

        // 从栈中依次取出元素, 获得顺序的从s到w的路径
        vec.clear();
        while( !s.empty() ){
            vec.push_back( s.top() );
            s.pop();
        }
    }

    // 打印出从s点到w点的路径
    void showPath(int w){

        assert( w >= 0 && w < G.V() );

        vector<int> vec;
        path(w, vec);
        for( int i = 0 ; i < vec.size() ; i ++ ){
            cout<<vec[i];
            if( i == vec.size()-1 )
                cout<<endl;
            else
                cout<<" -> ";
        }
    }

    // 查看从s点到w点的最短路径长度
    int length(int w){
        assert( w >= 0 && w < G.V() );
        return ord[w];
    }
};

#endif //INC_07_BFS_AND_SHORTEST_PATH_SHORTESTPATH_H

在这里插入图片描述
复杂度与深度优先相同

7.8 更多无权图的应用

Elylicery
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Tarjan及2-SAT讲课PPT
10-20
信息学竞赛，图论算法，Tarjan，缩点，2-SAT 寒假期间的集训讲课 PPT，主要详细讲解了 Tarjan 算法的思想及应用，同时对于 Tarjan 算法的一个扩展——2-SAT 问题进行了详细的讲解，是图论讲课非常好的课件和资料。
数据结构与算法 框架图
kxh166的博客
09-13 481
数据结构与算法 框架图【持续更新中】 使用百度脑图导出
L5 图论初步
qq_45958683的博客
07-31 171
图的概念 图的存储 图的遍历 图论问题 图论简介——图是什么 图：表示物与物之间关系的方法 图论：以图为研究对象，研究顶点和边组成的图形的数学理论和方法 一般是 n 个点，m 条边 边的方向： · 无向图：边双向连通（一种特殊的有向图，双向） · 有向图：单向通行 边权 度：与此点相连边的数量 · 入度：流入此点的边的数量 · 出度：流出此点的边的数量 · 出、入度一般都用于有向图 完全图、稠密图、稀疏图 图的存储 邻接矩阵 邻接矩阵：用二维数组的方式存储一个图 存储规则：若 a—&.
图数据结构及操作
qq_33596907的博客
10-07 296
图是一种比较重要的数据结构之一，主要应用于交通、通信等网络化的信息存贮中. 之前有被提问：如果想知道两个城市之间的距离适合采用哪种数据结构？ 回答：图（我发音：头：tou） 再被提问：什么头，头的，你说的是什么呀？ 回答：tewutu 图 图结构 又说道：说的什么，不知道你在说什么？ 我回答道：算了，听不懂就算了交流实在困难 此处省略一万个”X”........ 顶点：V Vertex 边： E Edge V集合表示包含哪些顶点 G集合表示顶点之间的连接关系. 无...
图论
weixin_30924087的博客
07-03 403
--------------------siwuxie095 图论 这里介绍图论（Graph Theory），图论是计算机科学中非常重要 的一部分内容，甚至可以单独划分成为一个领域 很多人第一次接触到图论这个词，就觉得图论是研究和图画相关的 内容 ...
蓝桥杯刷题022——发现环（拓扑排序、DFS/BFS）
荷叶田田的博客
02-09 762
道阻且长，行则将至！
欧拉回路的Fleury算法
06-26
图论——欧拉回路的Fleury算法 根据离散数学教材中思想 实现求欧拉回路。
IOI国家集训队论文集1999-2019
09-20
刘一鸣 -《一类搜索的优化思想——数据有序化》 陆可昱 -《长方体体积并》 饶向荣 -《病毒的DNA——剖析一道字符匹配问题解析过程》 邵烜程 -《数学思想助你一臂之力》 王知昆 -《浅谈用极大化思想解决最大子...
acm国家集训队2005年论文合集
03-27
任恺：《图论的基本思想及方法》 唐文斌：《正难则反——浅谈逆向思维在解题中的应用》 汪汀：《参数搜索的应用》 王俊：《浅析二分图匹配在信息学竞赛中的应用》 魏冉：《让算法的效率“跳起来”！——浅谈“跳跃表...
【算法】图的存储和遍历
指针不指南吗的博客
03-08 1566
一般来说，树和图有两种存储方式，树是无环连通图，树是特殊的图，这里只讲图。 图分成两种有向图和无向图 无向图：有向图建两条边，a->b , b->a 所以说，无向图是一种特殊的有向图 , 我们只讲 有向图的存储
算法-图的实现和迭代器(C++)
BLOG OF PETERMAOSX.
08-19 323
图这个数据结构主要有两个关键值(节点和边) 类似于这种 图也分为有向图和无向图 有向图类似于向量比如A->B 但是B->A不存在 无向图就是A->B 并且 B->A 无向图是一种特殊的有向图 图的自环边和平行边 对于图的表示方法，有两种常用的:邻接矩阵 和 邻接表 邻接矩阵是通过使用二维矩阵来标识各个节点的连接状态 邻接表是通过链表来存储各个节点存储的值 下面是代码...
数据结构-非线性结构-集合-树（一般树-二叉树）-图（有向图、无向图）
LXMXHJ的博客
08-06 1047
数据结构：非线性结构= 集合、树形结构（一般树、二叉树）、图形结构（有向图、无向图）；
基础算法模板题（七）—— 图论（部分）
JohnnyLin
03-16 199
图的存储 无向图是一种特殊的有向图，即双向 无向图的存储 static int N = 100010, M = 2 * N, idx; static int h[] = new int[N]; static int e[] = new int[M]; static int ne[] = new int[M]; public static void add(int a, int b){ e[idx] = b; ne[idx]
数据结构与算法基本框架图
敢于知道,
11-11 1139
C++实现图算法（一）
热门推荐
Ai
03-21 1万+
图算法（一） 对图的顶点和边进行了封装。
数据结构图论之如何优雅的用vector实现邻接表建图
最新发布
JDDJHY的博客
08-09 129
这是一个有向带权图：）
图解CNN十大算法架构
weixin_42010722的博客
08-20 3069
在深度学习应用中，算法主要分为三大类： 用于影像图像数据进行分析处理的卷积神经网络（CNN） 用于文本分析自然语言处理的递归神经网络（RNN） 用于数据生成或非监督学习应用的生成对抗网络（GAN） 随着技术的研究发展，基于这三大类传统算法，也不断衍生出不同的算法变体，其中基于CNN架构的变体有如下几种： CNN十大架构1. LeNet-52. AlexNet3. VGG-164. Inception-v15. Inception-v36. Inception-v47. ResNet-508. ResNe
数模常用算法——图论算法简介&代码实现
JiandaoStudio
06-19 9848
图与网络优化概述 目录 1. 求 两个指定顶点之间的最短路径（Dijkstra算法） 2. 求每对顶点之间的最短距离（Floyd算法） 3.最小代价生成树 3.1 prim算法模板，当前测试点下标从0开始，输出从1开始： 3.2 kruskal算法模板： 4. 网络流 4.1最大流算法（最简单的EK算法） 4.2 二分最大权匹配 KM算法模板 4.3 最小...
22种图分析算法介绍
清林情报分析师
05-26 2796
图分析算法，以图论为驱动，进行算法优化，结合应用工程，业务形态研究，不同领域场景模拟不同网络结构，通过自由刻画网络图形关系，验证结构合理性，如边的有向和无向及权重，从而辅助分析图形关系、图结构分析、网络结构分析等研究工作。
算法设计与分析图论桥深圳大学
05-23
图论中的“桥”指的是一条边，如果将这条边删除后，图就不再连通。在算法设计与分析中，通常需要考虑桥对图的影响以及如何寻找桥。 寻找桥的算法通常使用深度优先搜索（DFS）。具体来说，我们可以从任意一个点开始...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值