算法导论 第二十二章 基本的图算法

最新推荐文章于 2021-12-16 23:51:24 发布
最新推荐文章于 2021-12-16 23:51:24 发布
阅读量569 收藏 2
点赞数 1
分类专栏： 算法笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pokeyode/article/details/53509895
版权

22.1图的表示

图结构G(V,E)由顶点V和边E的集合组成，主要有邻接链表表示和邻接矩阵表示，两者的差别如下所示：



若为节点添加属性则可以通过改变节点自身的值，或者为节点添加属性或在节点中增加新的指针的方式来实现。权重也是属性的一种。

22.2 广度优先搜索

对于给定一个图中的原点，从原点出发按照到原点的距离来遍历所有的连通节点称为广度优先搜索。连接链表的算法广度优先搜索算法如下：

def ENQUEUE(Q, s):
    Q.append(s)

def DEQUEUE(Q):
    r = Q.pop(0)
    return r

WHITE, GRAY, BLACK = (0, 1, 2)

class Vertex:
    def __init__(self, u):
        self.value = u
        self.color = WHITE
        self.d = float("inf")
        self.pi = None

class Edge:
    def __init__(self, u, v):
        self.fromV = u
        self.toV = v

class EdgeList:
    def __init__(self, v):
        self.vertex = v
        self.connectedV = []

class Graph:
    def __init__(self):
        self.vertexs = {}

def CONNECT(u, v):
    return Edge(u, v)

def INITGRAPH(G, edges):
    for e in edges:
        if not e.fromV.value in G.vertexs:
            G.vertexs[e.fromV.value] = EdgeList(e.fromV)
        if not e.toV.value in G.vertexs:
            G.vertexs[e.toV.value] = EdgeList(e.toV)

        G.vertexs[e.fromV.value].connectedV.append(e.toV)
        G.vertexs[e.toV.value].connectedV.append(e.fromV)

def PRINTLIST(el):
    print(el.vertex.value, ":")
    for v in el.connectedV:
        print(v.value)

def PRINTGRAPH(G):
    for v in G.vertexs:
        PRINTLIST(G.vertexs[v])
        print("-----")

def BFS(G, s):
    for v in G.vertexs:
        if v != s.value:
            G.vertexs[v].vertex.color = WHITE
            G.vertexs[v].vertex.d = float("inf")
            G.vertexs[v].vertex.pi = None

    s.color = GRAY
    s.d = 0
    s.pi = None

    Q = []
    ENQUEUE(Q, s)
    while len(Q) != 0:
        u = DEQUEUE(Q)
        for v in G.vertexs[u.value].connectedV:
            if v.color == WHITE:
                v.color = GRAY
                v.d = u.d + 1
                v.pi = u
                ENQUEUE(Q, v)
        u.color = BLACK
        print(u.value, u.d)

def PRINT_PATH(G, s, v):
    if v == s:
        print(s.value)
    elif v.pi == None:
        print("no path from ", s.value, " to ", v.value, "exists")
    else:
        PRINT_PATH(G, s, v.pi)
        print(v.value)


if __name__ == "__main__":
    r = Vertex('r')
    s = Vertex('s')
    t = Vertex('t')
    u = Vertex('u')
    v = Vertex('v')
    w = Vertex('w')
    x = Vertex('x')
    y = Vertex('y')

    edges = []
    edges.append(CONNECT(r, s))
    edges.append(CONNECT(r, v))
    edges.append(CONNECT(s, w))
    edges.append(CONNECT(w, t))
    edges.append(CONNECT(w, x))
    edges.append(CONNECT(t, x))
    edges.append(CONNECT(t, u))
    edges.append(CONNECT(x, u))
    edges.append(CONNECT(x, y))
    edges.append(CONNECT(u, y))

    G = Graph()
    INITGRAPH(G, edges)
    PRINTGRAPH(G)

    print("**************")
    BFS(G, s)
    print("++++++++++++++")
    PRINT_PATH(G, s, y)
我们采用循环不变式：queue中保存的节点到原点的距离为最短距离。采用书上的证明其正确性，概括如下：因为广度遍历的先将d小的加入queue中，当节点第一次被发现时其pi的距离+1即为最短距离。

22.3 深度优先搜索

类似与广度优先搜索，深度优先搜索算法沿着连接的边一路查找直到所有的连接点都已经发现在原路返回查找所有节点，实现如下：

def ENQUEUE(Q, s):
    Q.append(s)

def DEQUEUE(Q):
    r = Q.pop(0)
    return r

WHITE, GRAY, BLACK = (0, 1, 2)

class Vertex:
    def __init__(self, u):
        self.value = u
        self.color = WHITE
        self.d = float("inf")
        self.f = float("inf")
        self.pi = None

class Edge:
    def __init__(self, u, v):
        self.fromV = u
        self.toV = v

class EdgeList:
    def __init__(self, v):
        self.vertex = v
        self.connectedV = []

class Graph:
    def __init__(self):
        self.vertexs = {}

def CONNECT(u, v):
    return Edge(u, v)

def INITGRAPH(G, edges):
    for e in edges:
        if not e.fromV.value in G.vertexs:
            G.vertexs[e.fromV.value] = EdgeList(e.fromV)
        if not e.toV.value in G.vertexs:
            G.vertexs[e.toV.value] = EdgeList(e.toV)

        G.vertexs[e.fromV.value].connectedV.append(e.toV)
        #G.vertexs[e.toV.value].connectedV.append(e.fromV)

def PRINTLIST(el):
    print(el.vertex.value, ":")
    for v in el.connectedV:
        print(v.value)

def PRINTGRAPH(G):
    for v in G.vertexs:
        PRINTLIST(G.vertexs[v])
        print("-----")

global time
time = 0
def DFS(G):
    for u in sorted(G.vertexs.keys()):
        G.vertexs[u].vertex.color = WHITE
        G.vertexs[u].vertex.pi = None
    global time
    time = 0
    for u in sorted(G.vertexs.keys()):
        if G.vertexs[u].vertex.color == WHITE:
            DFS_VISIT(G, G.vertexs[u].vertex)

def DFS_VISIT(G, u):
    global time
    time = time + 1
    u.d = time
    u.color = GRAY
    for v in G.vertexs[u.value].connectedV:
        if v.color == WHITE:
            v.pi = u
            DFS_VISIT(G, v)
    u.color = BLACK
    time = time + 1
    u.f = time
    print(u.value, u.d, u.f)

if __name__ == "__main__":
    u = Vertex('u')
    v = Vertex('v')
    w = Vertex('w')
    x = Vertex('x')
    y = Vertex('y')
    z = Vertex('z')

    edges = []
    edges.append(CONNECT(u, v))
    edges.append(CONNECT(u, x))
    edges.append(CONNECT(v, y))
    edges.append(CONNECT(w, y))
    edges.append(CONNECT(w, z))
    edges.append(CONNECT(x, v))
    edges.append(CONNECT(y, x))
    edges.append(CONNECT(z, z))

    G = Graph()
    INITGRAPH(G, edges)
    PRINTGRAPH(G)

    print("===========")
    DFS(G)

根据检索的边的连接点的不同，可以将边分为如下类型：

而且易证深度优先搜索有如下性质：

22.4 拓扑排序

拓扑排序就是无向环图的深度优先遍历中u.f值的由大到小的线性排序。

def ENQUEUE(Q, s):
    Q.append(s)

def DEQUEUE(Q):
    r = Q.pop(0)
    return r

WHITE, GRAY, BLACK = (0, 1, 2)

class Vertex:
    def __init__(self, u):
        self.value = u
        self.color = WHITE
        self.d = float("inf")
        self.f = float("inf")
        self.pi = None

class Edge:
    def __init__(self, u, v):
        self.fromV = u
        self.toV = v

class EdgeList:
    def __init__(self, v):
        self.vertex = v
        self.connectedV = []

class Graph:
    def __init__(self):
        self.vertexs = {}

def CONNECT(u, v):
    return Edge(u, v)

def INITGRAPH(G, edges):
    for e in edges:
        if not e.fromV.value in G.vertexs:
            G.vertexs[e.fromV.value] = EdgeList(e.fromV)
        if not e.toV.value in G.vertexs:
            G.vertexs[e.toV.value] = EdgeList(e.toV)

        G.vertexs[e.fromV.value].connectedV.append(e.toV)
        #G.vertexs[e.toV.value].connectedV.append(e.fromV)

def PRINTLIST(el):
    print(el.vertex.value, ":")
    for v in el.connectedV:
        print(v.value)

def PRINTGRAPH(G):
    for v in G.vertexs:
        PRINTLIST(G.vertexs[v])
        print("-----")

global time
time = 0
def DFS(G, TG):
    for u in sorted(G.vertexs.keys()):
        G.vertexs[u].vertex.color = WHITE
        G.vertexs[u].vertex.pi = None
    global time
    time = 0
    for u in sorted(G.vertexs.keys()):
        if G.vertexs[u].vertex.color == WHITE:
            DFS_VISIT(G, G.vertexs[u].vertex, TG)

def DFS_VISIT(G, u, TG):
    global time
    time = time + 1
    u.d = time
    u.color = GRAY
    for v in G.vertexs[u.value].connectedV:
        if v.color == WHITE:
            v.pi = u
            DFS_VISIT(G, v, TG)
    u.color = BLACK
    time = time + 1
    u.f = time
    TG.append(u)
    #print(u.value, u.d, u.f)

def TOPOLOGICAL_SORT(G):
    TG = []
    DFS(G, TG)
    return TG

if __name__ == "__main__":
    a = Vertex('a')
    b = Vertex('b')
    c = Vertex('c')
    d = Vertex('d')
    e = Vertex('e')
    f = Vertex('f')
    g = Vertex('g')
    h = Vertex('h')
    i = Vertex('i')

    edges = []
    edges.append(CONNECT(a, b))
    edges.append(CONNECT(a, d))
    edges.append(CONNECT(b, c))
    edges.append(CONNECT(d, c))
    edges.append(CONNECT(e, e))
    edges.append(CONNECT(f, g))
    edges.append(CONNECT(f, i))
    edges.append(CONNECT(g, i))
    edges.append(CONNECT(g, d))
    edges.append(CONNECT(h, i))



    G = Graph()
    INITGRAPH(G, edges)
    PRINTGRAPH(G)

    print("===========")
    TG = TOPOLOGICAL_SORT(G)
    for u in TG:
        print(u.value, u.d, u.f)

22.5 强连通分量
强连通分量其实就是环，把图G中的环归并到一起，就能将有环图变为无环图，无环图的许多算法可以被应用。如下图：

通过如下代码实现：

def ENQUEUE(Q, s):
    Q.append(s)

def DEQUEUE(Q):
    r = Q.pop(0)
    return r

WHITE, GRAY, BLACK = (0, 1, 2)

class Vertex:
    def __init__(self, u):
        self.value = u
        self.color = WHITE
        self.d = float("inf")
        self.f = float("inf")
        self.pi = None
        self.k = 0

class Edge:
    def __init__(self, u, v):
        self.fromV = u
        self.toV = v

class EdgeList:
    def __init__(self, v):
        self.vertex = v
        self.connectedV = []

class Graph:
    def __init__(self):
        self.vertexs = {}

def CONNECT(u, v):
    return Edge(u, v)

def INITGRAPH(G, edges):
    for e in edges:
        if not e.fromV.value in G.vertexs:
            G.vertexs[e.fromV.value] = EdgeList(e.fromV)
        if not e.toV.value in G.vertexs:
            G.vertexs[e.toV.value] = EdgeList(e.toV)

        G.vertexs[e.fromV.value].connectedV.append(e.toV)
        #G.vertexs[e.toV.value].connectedV.append(e.fromV)

def PRINTLIST(el):
    print(el.vertex.value, ":")
    for v in el.connectedV:
        print(v.value)

def PRINTGRAPH(G):
    for v in G.vertexs:
        PRINTLIST(G.vertexs[v])
        print("-----")

global time
time = 0
def DFS(G, TG, keys):
    for u in keys:
        G.vertexs[u].vertex.color = WHITE
        G.vertexs[u].vertex.pi = None
    global time
    time = 0
    k = 1
    for u in sorted(G.vertexs.keys()):
        if G.vertexs[u].vertex.color == WHITE:
            DFS_VISIT(G, G.vertexs[u].vertex, TG, k)
            k = k + 1

def DFS_VISIT(G, u, TG, k):
    global time
    time = time + 1
    u.d = time
    u.color = GRAY
    for v in G.vertexs[u.value].connectedV:
        if v.color == WHITE:
            v.pi = u
            DFS_VISIT(G, v, TG, k)
    u.color = BLACK
    time = time + 1
    u.f = time
    u.k = k
    TG.append(u)
    #print(u.value, u.d, u.f)

def TOPOLOGICAL_SORT(G, keys):
    TSG = []
    DFS(G, TSG, keys)
    return TSG

def TRANSPOSE(G):
    edges = []
    for k in G.vertexs.keys():
        u = G.vertexs[k].vertex
        for v in G.vertexs[u.value].connectedV:
            edges.append(CONNECT(v, u))

    GT = Graph()
    INITGRAPH(GT, edges)
    return GT

def STRONGLY_CONNECTED_COMPONENTS(G, k):
    GT = TRANSPOSE(G)

    tsg = TOPOLOGICAL_SORT(G, k)
    keys = []
    for u in tsg:
        keys.insert(0,u.value)
        print(u.value)

    gtts = []
    DFS(GT, gtts, keys)
    print("------------")
    k = 0
    for u in gtts:
        if u.k != k:
            print("|")
            k = u.k
        print(u.value)

if __name__ == "__main__":
    a = Vertex('a')
    b = Vertex('b')
    c = Vertex('c')
    d = Vertex('d')
    e = Vertex('e')
    f = Vertex('f')
    g = Vertex('g')
    h = Vertex('h')

    edges = []
    edges.append(CONNECT(a, b))
    edges.append(CONNECT(b, c))
    edges.append(CONNECT(b, e))
    edges.append(CONNECT(b, f))
    edges.append(CONNECT(c, d))
    edges.append(CONNECT(c, g))
    edges.append(CONNECT(d, c))
    edges.append(CONNECT(d, h))
    
    edges.append(CONNECT(e, a))
    edges.append(CONNECT(e, f))
    edges.append(CONNECT(f, g))
    edges.append(CONNECT(g, f))
    edges.append(CONNECT(g, h))
    edges.append(CONNECT(h, h))



    G = Graph()
    INITGRAPH(G, edges)
    PRINTGRAPH(G)

    #STRONGLY_CONNECTED_COMPONENTS(G, ['c', 'g','f','h','d','b','e','a'])
    keys = sorted(G.vertexs.keys())
    print(keys)
    STRONGLY_CONNECTED_COMPONENTS(G, keys)



习题解答

pokeyode
关注
专栏目录
算法导论第二十二章习题解答
01-09
能用代码表示的都用代码表示，不能表示的写出思路，思路都没写的就是我也做不出来
算法导论——基本的图算法
weixin_34258078的博客
08-06 216
　　对于图G=(V,E)，V代表点，E代表边。图有两种标准的表示方法：邻接矩阵法和邻接链表法。 　　邻接链表法适合表示边的条数少的稀疏图，可以节约存储空间。对于有向图G来说，边(u,v)一定会出现在链表Adj[u]中，因此，所有链表的长度之和一定等于|E|。对于无向图来说，边(u,v)会同时出现在Adj[u]和Adj[v]中，因此所有链表的长度之和一...
算法导论 第二十二章:图的搜索
dllTimes
07-20 963
图有两种标准的表示方法，即邻接矩阵和邻接表（通常邻接矩阵用于稠密图，邻接表用于稀疏图）。如下： 对于图的搜索有两种方法：深度优先搜索 & 广度优先搜索。 广度优先搜索（Breadth-first search）      广度优先搜索是将已发现和未发现顶点之间的边界沿其广度方向向外扩展。亦即算法首先会发现和s距离为k的所有点，然后才会发现和s距离为k+1的其他顶点。 伪代码：
《算法导论》第六部分---图算法
weixin_34415923的博客
06-23 107
简要的做一些记录，还有一些没看懂的地方先标记着以后再重新回过头来看。 22.1          图的表示    图的两种表示方法：                           1、邻接表                                     优点：邻接表表示法稍作修改，就能支持其他多种图的变体，因而有很强的适应性。                       ...
《算法导论3rd第二十二章》基础的图算法
懒猫的脚印
12-16 869
算法导论， 第二十二章，基础图算法
算法导论 第二十二章：拓扑排序
dllTimes
07-20 972
拓扑排序（针对有向无回路图DAG）是深度优先搜索的一个应用，其结果图中所有顶点的一个线性排列。 伪代码如下： EG: 拓扑排序完整代码如下： #include #include #include #include using namespace std; #define UDG 0 #define DG 1 #define WHITE 0 #define
算法导论第二十章习题解答
07-07
《算法导论》第二十章习题解答涵盖了各种高级算法问题，主要涉及图论和网络流等内容。在这一章中，作者深入探讨了如何解决实际问题，如最短路径、最大流最小割以及网络调度等问题。以下是部分习题的解析和相关知识点...
算法导论第二十四章习题解答
04-05
《算法导论》第二十四章习题解答涵盖了各种高级算法问题，这些题目旨在深化对算法的理解，提升编程技能。在这一章中，我们通常会遇到动态规划、图论、最优化算法等主题。以下是部分习题的解析和知识点概述： 1. **...
算法导论第十九章习题解答
05-30
第十九章通常聚焦于图算法，因为图在计算机科学中有广泛的应用，如网络路由、社交网络分析、最短路径问题等。本章节的习题解答将涵盖以下几个关键知识点： 1. 图的基本概念：包括图的定义、有向图与无向图、加权图...
算法导论第二十三章习题解答
01-22
《算法导论》第二十三章主要探讨的是图算法，包括图的基本概念、图的表示方法、图的遍历以及各种图的特殊结构如最小生成树、最短路径等。本章习题解答涵盖了这些核心知识点，旨在帮助读者深入理解和应用所学理论。 ...
算法导论22章课后习题答案
01-26
最近在研习算法导论，发现课后习题的精彩程度甚至不亚于正文，对于算法导论的爱好者而言，这是一份不错的参考资料
算法导论（第2版）参考答案
03-12
目录（Table of Contents） 　　前言（Preface） 　　第一部分（Part I） 基础（Foundations） 　　第一章 计算中算法的角色（The Role of Algorithms in Computing） 　　第二章 开始（Getting Started） 　　第三章 函数的增长率（Growth of Functions） 　　第四章 递归（Recurrences） 　　第五章 概率分析与随机化算法（Probabilistic Analysis and Randomized Algorithms） 　　第二部分（Part II） 排序与顺序统计（Sorting and Order Statistics） 　　第六章 堆排序（Heapsort） 　　第七章 快速排序（Quicksort） 　　第八章 线性时间中的排序（Sorting in Linear Time） 　　第九章 中值与顺序统计（Medians and Order Statistics） 　　第三部分（Part III） 数据结构（Data Structures） 　　第十章 基本的数据结构（Elementary Data Structures） 　　第十一章 散列表（Hash Tables） 　　第十二章 二叉查找树（Binary Search Trees） 　　第十三章 红-黑树（Red-Black Trees） 　　第十四章 扩充的数据结构（Augmenting Data Structures） 　　第四部分（Part IV） 高级的设计与分析技术（Advanced Design and Analysis Techniques） 　　第十五章 动态规划（Dynamic Programming） 　　第十六章 贪婪算法（Greedy Algorithms） 　　第十七章 分摊分析（Amortized Analysis） 　　第五部分（Part V） 高级的数据结构（Advanced Data Structures） 　　第十八章 B-树（B-Trees） 　　第十九章 二项式堆（Binomial Heaps） 　　第二十章 斐波纳契堆（Fibonacci Heaps） 　　第二十一章 不相交集的数据结构（Data Structures for Disjoint Sets） 　　第六部分（Part VI） 图算法（Graph Algorithms） 　　第二十二章 基本的图算法（Elementary Graph Algorithms） 　　第二十三章 最小生成树（Minimum Spanning Trees） 　　第二十四章 单源最短路径（Single-Source Shortest Paths） 　　第二十五章 全对的最短路径（All-Pairs Shortest Paths） 　　第二十六章 最大流（Maximum Flow） 　　第七部分（Part VII） 精选的主题（Selected Topics） 　　第二十七章 排序网络（Sorting Networks） 　　第二十八章 矩阵运算（Matrix Operations） 　　第二十九章 线性规划（Linear Programming） 　　第三十章 多项式与快速傅里叶变换（Polynomials and the FFT） 　　第三十一章 数论算法（Number-Theoretic Algorithms） 　　第三十二章 字符串匹配（String Matching） ......................................................
算法导论习题分析—— 22章 基本的图算法
weixin_42078418的博客
04-03 784
算法导论习题分析—— 22章 基本的图算法22-2 衔接点、桥和双连通分量abcdefgh代码实现 22-2 衔接点、桥和双连通分量 a 假如根节点在深度优先树中有两个子节点，则其中一个子节点必无法由其他节点搜索得到（否则就不是根节点的子节点了）。因此这个子节点只跟根节点相连，因此根节点是衔接点。 b 当一个节点vvv存在一个子节点，且该子节点与其后代节点不存在指向vvv的真祖先的后向边，则在深度...
算法导论之图算法
liu_matthew的博客
02-19 890
算法导论之图算法标签（空格分隔）： 学习笔记一、基本图算法1.1 图的表示对于图G = （V,E）中，V代表图的顶点，E代表顶点之间的关系，也就是我们通常说的边。按照边的特性我们可以将图分为有向图或者无向图。但是所有的无向图中的边我们可以用两条互指的有向边进行代替，将无向图转换为有向图，所以这里所有的算法都针对有向图。1.1.1 邻接链表邻接链表表示方法由一个包含|V|条链表的数组Adj所构成，每个
算法导论学习笔记－第二十二章－图的基本算法
kindlucy的专栏
08-20 1498
第二十二章 图的基本算法   总结：这一章讲了图的一些基本算法，例如广度优先搜索、深度优先搜索等，还介绍了拓扑排序、强连通分支等。   1.    图的表示 G=(V,E) 表示方法：邻接表、邻接矩阵 邻接表：存储空间O(V+E) 邻接矩阵：适合稠密图，存储空间O(V2)。还有一个优点，对邻接矩阵中的元素，可用二进位表示。   2.    广度优先搜索BFS 对图中的顶
算法导论（二十二）——图的基本算法
上帝已逝，自求多福
06-25 1404
作者：disappearedgod 文章出处：http://blog.csdn.net/disappearedgod/article/details/32337799 时间：2014-6-25
算法导论学习笔记14_基本图算法
weixin_43374723的博客
04-25 798
基本图算法1. 图的表示1.1 邻接链表 1. 图的表示 对于一个图G=(V,E)G=(V, E)G=(V,E)，通常由两种表示方法：邻接链表和邻接矩阵。对于稀疏图(边的条数∣E∣|E|∣E∣远远小于∣V∣2|V|^2∣V∣2的图)，通常用邻接链表表示，而对于稠密图（∣E∣|E|∣E∣接近∣V∣2|V|^2∣V∣2），通常采用邻接矩阵的形式表示。 1.1 邻接链表 对于图G=(V,E)G=(V,...
算法导论读书笔记（22）基本的图算法
liujianli的博客
07-05 674
第六部分 图算法基本的图算法图的搜索指的是系统化地跟随图中的边来访问图中的每个结点。 图搜索算法可以用来发现图的结构。 图的两种表示法分别是邻接链表和邻接矩阵。1. 图的表示对于图G=（V， E）可以用两种标准表示方法表示： 1. 邻接链表，因为在表示稀疏图（边的条数|E|远远小于|V|^2的图）时非常紧凑而成为通常的选择。 2. 邻接矩阵，在稠密图（|E|接近|V|^2的图）的情况下，倾向
算法导论（七）之图算法
yin__ren的博客
10-26 1162
1. 基本图算法 1. 广度优先搜索(BFS) 从临近源顶点s最近的顶点开始，通过对图G的边的探索发现从源顶点s能够抵达的每个顶点 1. 伪代码 BFS(G,s) for each vertex u 属于 G.V - {S} u.color = WHITE u.d = 无穷 u.pi = NIL s.color = GRAY s.d = 0 s.pi = NIL Q = ...
《算法导论》第二版答案：基础到图算法解析
第六部分专门讨论图算法，从基本的图算法（第二十二章）如遍历，到最小生成树（第二十三章）、单源最短路径（第二十四章）和全对的最短路径（第二十五章）等网络优化问题。 书中的习题答案覆盖了各章节的关键概念，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值