使用Tarjan算法计算强连通分量

最新推荐文章于 2025-05-09 19:33:52 发布
最新推荐文章于 2025-05-09 19:33:52 发布
阅读量276 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： # 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/roadtohacker/article/details/118402665
本文详细介绍了强连通分量的概念，并通过实例解释了Tarjan算法如何求解有向图的强连通分量。在Tarjan算法中，通过dfs序、low值和sccno值来判断节点是否属于同一个SCC，并进行了栈的运用来实现SCC的划分。此外，还探讨了缩点的概念，即将SCC视为单个节点简化图的过程。最后，给出了模板题的解题思路和代码实现，包括邻接表和链式前向星两种存储方式，以及如何优化时间复杂度。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

SCC

强连通分量

  • 强连通分量（Strongly Connected Component）简称SCC
  • 首先要理解一个定义，什么是强连通分量
  • 所谓强连通，有两个点 u u u和 v v v，从 u u u到 v v v有一条路径，从 v v v到 u u u也有一条路径，那么说这两个点之间是强连通的，也叫做互相可达；如果一个有向图 G G G中的任意两个点之间都是强连通的，那么就说这个图是一个强连通图
  • 强连通分量。如果一个有向图 G G G不是强连通图，那么可以把它分成多个子图，且每个子图的内部是强连通的，而且这些子图已经扩展到最大，不能与这个子图以外的任意点强连通，可称这个图是一个极大联通子图。那么这个极大联通子图就是图 G G G的一个强连通分量
  • 画一个图理解一下，见下图
    在这里插入图片描述
  • 上图中有四个SCC，分别是 { 1 , 2 , 3 , 4 } , { 5 } , { 6 } , { 7 } \{1,2,3,4\},\{5\},\{6\},\{7\} {1,2,3,4},{5},{6},{7}
  • 关于SCC可以容易的得到一个定理，就是在一个SCC中，从其中任何一个点出发，都至少有一条路径能绕回到自己，这个定理是显然的

Tarjan算法求解SCC

算法详解

  • 那么如何去求一个有向图中有多少个SCC呢？Tarjan提出了一种求解的办法
  • 设置三个数组, n u m [ i ] num[i] num[i]表示节点 i i i的 d f s dfs dfs序，也叫做时间戳； l o w [ i ] low[i] low[i]表示 i i i节点能够回溯到的最远祖先， s c c n o [ i ] sccno[i] sccno[i]表示 i i i节点位于第几个 S C C SCC SCC
  • 设置一个栈，栈上方的一些连续元素用来储存当前SCC的节点
    在这里插入图片描述
  • 还是用这个图做例子，我们先自己看看怎么求SCC，首先我们很容易的可以看出来 { 1 , 2 , 3 , 4 } \{1,2,3,4\} {1,2,3,4}属于一个SCC，那么我们就看它，怎么把它和图里其他SCC分开
  • 首先我们从1出发，进行 d f s dfs dfs搜索，显然搜索路径为1-3-4-2，把这四个元素都入栈，前面说了 n u m num num数组表示的是节点的时间戳（进入递归的顺序）， l o w low low数组初始值和 n u m num num相同，那么显然，这四个节点的初始时间戳、回溯值和SCC标号如下
inum[i]low[i]sccno[i]
num[1]110
num[2]440
num[3]220
num[4]330
  • 现在的这些值都已经记录好了，到达节点2，接下来要到节点1了，这时候发现节点1已经进入递归了，也就是 n u m num num数组有标记，所以这时候1就不再进入递归，而是更新它的 l o w low low值为它能够回溯到的最早的祖先节点显然是它本身，更新方式为 l o w [ u ] = m i n ( l o w [ u ] , n u m [ v ] ) low[u]=min(low[u],num[v]) low[u]=min(low[u],num[v])
  • 上述公式改为 l o w [ u ] = m i n ( l o w [ u ] , l o w [ v ] ) low[u]=min(low[u],low[v]) low[u]=min(low[u],low[v])也不影响正确性，原因是到这一步更新必然是到达了祖先节点，而祖先节点的 l o w [ v ] = n u m [ v ] low[v]=num[v] low[v]=num[v]始终成立
  • 可以看出，第一个进入 d f s dfs dfs的节点就是它所在SCC的祖先节点
  • 接下来，需要进行的是更新这个SCC上面的所有节点的 l o w low low值，因为整个过程是递归进行的，所以这步操作是一个回溯的过程，写在递归后面即可，方程为 l o w [ u ] = m i n ( l o w [ u ] , l o w [ v ] ) low[u]=min(low[u],low[v]) low[u]=min(low[u],low[v])意思就是从后往前更新回溯值，这样一圈操作下来，得到这个SCC的各个节点的信息如下
inum[i]low[i]sccno[i]
num[1]110
num[2]410
num[3]210
num[4]310
  • 容易发现，只有祖先节点的 n u m num num和 l o w low low是相等的，所以如果发现某个节点在递归结束以后满足这个特性，那么就一定是祖先节点，这时候，将栈顶祖先节点之前（包括本身）的元素全部弹出，加上SCC标号，这样就成功的划分出了一个SCC
inum[i]low[i]sccno[i]
num[1]111
num[2]441
num[3]221
num[4]331
  • 可能有人会觉得这个例子过于简单，要是走到了别的SCC内部怎么办，这就牵扯到了一个关键话题，就是这个栈里面并不是只有一个SCC，它是根据 l o w low low和 n u m num num划分的不同SCC，也就是以 l o w [ u ] = = n u m [ u ] low[u]==num[u] low[u]==num[u]为一层，将栈划分成了若干个SCC
  • 还是上面这个例子，比如要是从5号节点开始 d f s dfs dfs会怎样呢？比如说它先到4，那么 d f s dfs dfs序为5-4-2-1-3-7-6，那么显然5在栈底，到3以后，接下来是4，发现4已经进入了递归，这时候更新3、1、2的 l o w low low值与4相同，结果还是 l o w [ 4 ] = n u m [ 4 ] low[4]=num[4] low[4]=num[4]，这样把栈顶元素一直到4这一段弹出，标记为第一个SCC，然后现在栈里就一个5，继续遍历到7-6，接下来是3，发现3进入了递归且已经标好了SCC，所以3就和接下来没关系了，现在从栈顶到栈底依次为6、7、5，因为没有接下来的节点了，所以一看 l o w [ 6 ] = n u m [ 6 ] low[6]=num[6] low[6]=num[6]，所以就弹出6，标记为第二个SCC，弹出7标记为第三个SCC，最后弹出5，标记为第四个SCC， t a r j a n tarjan tarjan算法结束
  • 代码实现如下
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
const int MAXN = 1e6 + 100;
vector<int> g[MAXN];
int num[MAXN];
int sccno[MAXN];
int low[MAXN];
int dfn;
int cnt;
stack<int> st;
void tarjan(int s){
    st.push(s);
    low[s] = num[s] = ++cnt;
    for(int i=0;i<g[s].size();i++){
        int v = g[s][i];
        if(!num[v]){
            tarjan(v);
            low[s] = min(low[s], low[v]);
        }else if(!sccno[v]){
            low[s] = min(low[s], num[v]);
        }
    }
    if(low[s] == num[s]){
        cnt++;
        while(1){
            int v = st.top();
            st.pop();
            sccno[v] = cnt;
            if(v == s) break;
        }
    }
}
  • 这里我暂且使用邻接表存图，之后再使用链式前向星改写
  • 还有一个问题，图不连通怎么办，我们只需要把每个没有进入递归的节点都进行一次 t a r j a n tarjan tarjan算法即可

缩点

  • 经过上面的操作，我们已经将整个图划分为了若干个SCC，这样其实就起到了一个化简图的过程，每个SCC可以看作为一个点，这也就是我们所说的缩点，根据SCC标号，对于上述例子，我们可以构建一个新图如下
    在这里插入图片描述

  • 这就是缩点之后得到的图，可以发现，SCC之间的指向关系和之前的关系是一致的，这是显然成立的，我们利用这一点来建图

  • 这时候我们可以仔细观察一下SCC的标号，这个标号实际上是一个逆拓扑序，这个性质在后面的 2 − S A T 2-SAT 2−SAT问题中有应用

练习

模板题

  • 这个题思路如下：首先我们要建图，接着使用 t a r j a n tarjan tarjan算法进行缩点，同时记录每一个SCC的内部权值和，之后要重新建图，最后对于每一个SCC计算它能够达到的最大点权和，取所有的最大值即为答案
#include <iostream>
#include <stack>
#include <cstring>
#include <vector>
using namespace std;
const int MAXN = 2e5 + 100;
vector<int> g[MAXN];
int num[MAXN];
int sum[MAXN];
int low[MAXN];
int sccno[MAXN];
int val[MAXN];
int x[MAXN];
int y[MAXN];
int f[MAXN];
int dfn;
int cnt;
inline int read(){
	int x = 0, f = 1;char c = getchar();
	while(c < '0' || c > '9'){if(c == '-') f = -1;c = getchar();}
	while(c >= '0' && c <= '9'){x = (x << 1) + (x << 3) + (c ^ 48);c = getchar();}
	return x * f;
}
stack<int> st;
void tarjan(int u){
	low[u] = num[u] = ++dfn;
	st.push(u);
	for(int i=0;i<g[u].size();i++){
		int v = g[u][i];
		if(!num[v]){
			tarjan(v);
			low[u] = min(low[u], low[v]);
		}else if(!sccno[v]){
			low[u] = min(low[u], num[v]);
		}
	}
	if(low[u] == num[u]){
		cnt++;
		while(1){
			int v = st.top();
			st.pop();
			sccno[v] = cnt;
			sum[cnt] += val[v];
			if(u == v) break;
		}
	}
}
void dfs(int u){
	if(f[u]) return;
	f[u] = sum[u];
	int maxsum = 0;
	for(int i=0;i<g[u].size();i++){
		int v = g[u][i];
		if(!f[v]){
			dfs(v);
		}
		maxsum = max(maxsum, f[v]);
	}
	f[u] += maxsum;
}
int main(){
	int n, m;
	n = read();
	m = read();
	for(int i=1;i<=n;i++) val[i] = read();
	for(int i=0;i<m;i++){
		x[i] = read();
		y[i] = read();
		g[x[i]].push_back(y[i]);
	}
	for(int i=1;i<=n;i++){
		if(!num[i]){
			tarjan(i);
		}
	}
	memset(g, 0, sizeof g);
	for(int i=0;i<m;i++){
		if(sccno[x[i]] != sccno[y[i]]){
			g[sccno[x[i]]].push_back(sccno[y[i]]);
		}
	}
	int ans = -1;
	for(int i=1;i<=cnt;i++){
		if(!f[i]){
			dfs(i);
		}
		ans = max(ans, f[i]);
	}
	cout << ans;
	return 0;
}
  • 修改为链式前向星
#include <iostream>
#include <stack>
#include <cstring>
#include <vector>
using namespace std;
const int MAXN = 2e5 + 100;
int num[MAXN];
int sum[MAXN];
int low[MAXN];
int sccno[MAXN];
int val[MAXN];
int x[MAXN];
int y[MAXN];
int f[MAXN];
int head[MAXN];
int dfn;
int cnt;
int tot;
struct Edge{
	int to;
	int next;
	int val;
}edge[MAXN];
inline int read(){
	int x = 0, f = 1;char c = getchar();
	while(c < '0' || c > '9'){if(c == '-') f = -1;c = getchar();}
	while(c >= '0' && c <= '9'){x = (x << 1) + (x << 3) + (c ^ 48);c = getchar();}
	return x * f;
}
void Add_Edge(int u, int v, int w){
	edge[cnt].to = v;
	edge[cnt].next = head[u];
	edge[cnt].val = w;
	head[u] = cnt++;
}
stack<int> st;
void tarjan(int u){
	low[u] = num[u] = ++dfn;
	st.push(u);
	for(int i=head[u];i!=-1;i=edge[i].next){
		int v = edge[i].to;
		if(!num[v]){
			tarjan(v);
			low[u] = min(low[u], low[v]);
		}else if(!sccno[v]){
			low[u] = min(low[u], num[v]);
		}
	}
	if(low[u] == num[u]){
		tot++;
		while(1){
			int v = st.top();
			st.pop();
			sccno[v] = tot;
			sum[tot] += val[v];
			if(u == v) break;
		}
	}
}
void dfs(int u){
	if(f[u]) return;
	f[u] = sum[u];
	int maxsum = 0;
	for(int i=head[u];i!=-1;i=edge[i].next){
		int v = edge[i].to;
		if(!f[v]){
			dfs(v);
		}
		maxsum = max(maxsum, f[v]);
	}
	f[u] += maxsum;
}
int main(){
	int n, m;
	n = read();
	m = read();
	memset(head, -1, sizeof head);
	for(int i=1;i<=n;i++) val[i] = read();
	for(int i=0;i<m;i++){
		x[i] = read();
		y[i] = read();
		Add_Edge(x[i], y[i], 1);
	}
	for(int i=1;i<=n;i++){
		if(!num[i]){
			tarjan(i);
		}
	}
	memset(head, -1, sizeof head);
	cnt = 0;
	for(int i=0;i<m;i++){
		if(sccno[x[i]] != sccno[y[i]]){
			Add_Edge(sccno[x[i]], sccno[y[i]], 1);
		}
	}
	int ans = -1;
	for(int i=1;i<=tot;i++){
		if(!f[i]){
			dfs(i);
		}
		ans = max(ans, f[i]);
	}
	cout << ans;
	return 0;
}
  • 时间优化幅度非常巨大
Tarjan强连通分量算法
Wu_while的博客
10-12 762
“Tarjan 陪伴强连通分量 生成树完成后思路才闪光 欧拉跑过的七桥古塘 让你 心驰神往“” ——《膜你抄》
Tarjan算法-求强连通分量入门
keepcoral的博客
06-27 1089
Tarjan算法求强连通分量，强连通分量就是有向图(可以是子图)中的任意两点都能互相到达，所以我们可以用Tarjan算法去求出所有的强连通分量，相当于缩点，然后把这些缩点连接起来，就是DAG(有向无环图)，DAG一定有一个点是出度为0的，可以尝试画画图。#include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;cstring&gt...
Tarjan算法求强连通分量
02-03
使用Tarjan算法进行快速计算强连通分量，C++语言实现。
[模版]Tarjan算法求强连通分量
WR_Eternity的博客
09-04 218
        今天，我们要探讨的就是——Tarjan算法。        Tarjan算法的主要作用便是求一张无向图中的强连通分量，并且用它缩点，把原本一个杂乱无章的有向图转化为一张DAG（有向无环图），以便解决之后的问题。        首先，我们在原图上跑一遍DFS，然后会发现三种边：         1、正常边：嗯，顾名思义就是连接祖先和儿子节点的边。         2、横叉边：...
Tarjan 算法学习笔记（超详细）
最新发布
weixin_27645199的博客
05-09 43
对于一张有向图\(S\)的子图\(V\)，满足\(V\)内的点两两之间可达，并且不存在一个子图\(G\)使得，通俗的讲就是无法继续扩张的两两可达的子图。对于无向图（注意：图不一定连通），割边的定义为：去掉这条边后图的连通块数量增加。对于无向图（注意：图不一定连通），割点的定义为：去掉这个点后图的连通块数量增加。
2140: 稳定婚姻 - BZOJ
weixin_30325071的博客
05-29 131
Description 我国的离婚率连续7年上升，今年的头两季，平均每天有近5000对夫妇离婚，大城市的离婚率上升最快，有研究婚姻问题的专家认为，是与简化离婚手续有关。 25岁的姗姗和男友谈恋爱半年就结婚，结婚不到两个月就离婚，是典型的“闪婚闪离”例子，而离婚的导火线是两个人争玩电脑游戏，丈夫一气之下，把电脑炸烂。有社会工作者就表示，80后求助个案越来越多，有些是与父母过多干预有关。而根据民政部...
【图论】Tarjan算法（强连通分量）
muyangquan0013的博客
08-21 1621
Tarjan算法是一种由美国计算机科学家罗伯特·塔杨（Robert Tarjan）提出的求解有向图强连通分量的线性时间的算法。
图论：tarjan 算法求解强连通分量
PengFly123的博客
02-17 1040
有一个 nnn 个点，mmm 条边的有向图，请求出这个图点数大于 111 的强连通分量个数。第一行为两个整数 nnn 和 mmm。第二行至 m+1m+1m+1 行，每一行有两个整数 aaa 和 bbb，表示有一条从 aaa 到 bbb 的有向边。仅一行，表示点数大于 111 的强连通分量个数。 提示 数据规模与约定 对于全部的测试点，保证 2≤n≤1042\le n \le 10^42≤n≤104，2≤m≤5×1042\le m\le 5\times 10^42≤m≤5×104，1≤a,b≤n1 \leq
20行代码实现，使用Tarjan算法求解强连通分量
TechFlow的博客
09-23 390
今天是算法数据结构专题的第36篇文章，我们一起来继续聊聊强连通分量分解的算法。 在上一篇文章当中我们分享了强连通分量分解的一个经典算法Kosaraju算法，它的核心原理是通过将图翻转，以及两次递归来实现。今天介绍的算法名叫Tarjan，同样是一个很奇怪的名字，奇怪就对了，这也是以人名命名的。和Kosaraju算法比起来，它除了名字更好记之外，另外一个优点是它只需要一次递归，虽然算法的复杂度是一样的，但是常数要小一些。它的知名度也更高，在竞赛当中经常出现。 先给大家提个醒，相比于Kosaraju算法，Tarj
Tarjan 的强连通分量算法的Python实现
06-08
）图作为输入，并以拓扑顺序返回其强连通分量作为输出 循环依赖 在各种情况下，依赖关系可能是循环的，并且必须同时执行一组相互依赖的操作。同时执行成本高昂的情况并不少见。使用 Tarjan 算法，可以确定执行相互...
Tarjan算法——求强连通分量
Martisum的博客
07-12 3179
什么是强连通分量 强连通分量，是一个有向图的最大强连通子图（看起来好像没有什么解释效果…），好吧，强连通分量就是在一个有向图中，从任意一个点出发，最多可以走过的所有的点构成的一个点集，将其称之为强连通。强连通分量就是这些集合里面最大的那个。如下图： 2,3,5,就是强连通的，因为从二出发可以到达2,3,5的任意一个点。所以1,4,也是强连通的。我们不难发现，除了双向边以外，强连通都是环套环的形式...
hdu1269 tarjan强联通分量
Merc_A的专栏
11-25 472
第一次看这种强联通的题，，找了个模板套了一下，这是地址： http://blog.youkuaiyun.com/jokes000/article/details/7538994。膜拜一下。 #include #include #include #include using namespace std; #define MIN(a,b) ((a)<(b)?(a):(b)) #define N 1000
Network of Schools POJ - 1236 （tarjan）
码农的一亩三分地
07-17 198
A number of schools are connected to a computer network. Agreements have been developed among those schools: each school maintains a list of schools to which it distributes software (the “receiving sc...
Tarjan算法之求强连通分量
qq_40005800的博客
08-29 451
最近又学习了强连通分量的Tarjan求法，先是看了别人的许多博客，才勉勉强强看懂，自己写完博客后感到十分显然，也没有表面上看的那么高大上。 好了，转入正题，先说说什么是强连通分量： 有向图强连通分量：在有向图G中，如果两个顶点vi,vj间（vi&gt;vj）有一条从vi到vj的有向路径，同时还有一条从vj到vi的有向路径，则称两个顶点强连通(strongly connected)。如果有向图G...
图论算法（6）（更新版） --- Tarjan算法求强连通分量
VV
09-22 1039
之前Tarjan算法求强连通分量博文中，代码实现用到了固定大小数组，扩展起来似乎并不是很方便，在java里这样来实现本身就是不太妥当的，所以下面给出一个更新版本的代码实现，算法本身比较简单，如果对算法不太理解，请先看之前的博文讲解。
Tarjan算法（求强连通分量与割点）
Untersee-boot XXI
02-22 239
Tarjan算法，是以一位计算机界大佬的名字命名的算法，多用于解决LCA，割点，强连通分量等问题，下面是其发明者的简短介绍。 Robert Tarjan，计算机科学家，以LCA、强连通分量等算法闻名。他拥有丰富的商业工作经验，1985年开始任教于普林斯顿大学。 切入正题，我们先来看一下tarjan算法的第一个主要用途：求强连通分量。 1.强连通分量 什么是强连通分量呢？ 有向图强连...
[图解算法]Tarjan算法求图的强连通分量
飞鱼の博客
11-23 819
强连通分量简介   有向图强连通分量：在有向图G中，如果两个顶点Vi,VjV_i, V_jVi​,Vj​ 间有一条从ViV_iVi​到VjV_jVj​的有向路径，同时还有一条从VjV_jVj​到ViV_iVi​的有向路径，则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。有向图的极大强连通子图，称为强连通分量(strongly con...
tarjan算法求强连通分量
03-26
<think>好的，用户想了解Tarjan算法如何求解图中的强连通分量，包括原理和代码示例。我需要先回忆Tarjan算法的基本思路，然后结合已有的引用资料来组织回答。 首先，Tarjan算法的核心是深度优先搜索（DFS），通过维护两个数组dfn和low来判断强连通分量。dfn记录每个节点的访问顺序，low记录当前节点能够回溯到的最早的节点。当dfn等于low时，说明找到了一个强连通分量，这时候需要将栈中的节点弹出，组成一个SCC。 然后，我需要确保回答中的数学公式符合用户给的格式要求，比如行内公式用$...$，独立公式用$$...$$。例如，递归条件中的dfn和low的关系可能需要用公式表达。 接下来，用户需要代码示例。根据引用[1]和[4]，有Python和C++的示例，但用户可能希望Python的实现，所以需要参考引用[1]中的Python代码结构，但要注意Tarjan算法的正确实现。可能需要自己编写一个Python版本的Tarjan算法，确保正确性，比如使用栈、标记在栈中的节点等。 另外，用户的问题中提到要生成相关问题，我需要根据Tarjan算法的相关内容，提出几个相关的问题，比如与其他算法的比较、复杂度分析、应用场景等。 需要注意的是，引用的文献中，引用[1]提到了Python实现Tarjan算法，但示例代码可能不完整或需要调整。需要确保代码正确，比如使用递归DFS，维护index、栈、on_stack等数据结构。同时，引用[3]提到了其他算法如Kosaraju和Garbow，可以在相关问题中提及。 最后，检查回答是否符合用户的结构要求：分步骤说明原理，代码示例，相关问题，引用正确标注。确保LaTeX语法正确，例如数学变量用$包围，独立公式单独成段。同时，使用中文回答，保持口语化，但避免使用Markdown格式。</think>### Tarjan算法实现强连通分量(SCC)的原理 Tarjan算法基于深度优先搜索(DFS)实现，通过维护两个核心数组$dfn[]$和$low[]$来识别强连通分量： 1. **$dfn[v]$**: 记录节点$v$的访问时间戳(DFS遍历顺序) 2. **$low[v]$**: 表示节点$v$通过非父边能回溯到的最早时间戳 3. **栈结构**: 保存当前DFS路径上的节点 **核心条件**：当$low[v] = dfn[v]$时，说明当前栈顶到$v$的节点构成一个强连通分量[^3][^4]。 ### Python代码实现示例 ```python def tarjan_scc(graph): index = 0 stack, on_stack = [], set() dfn = {}; low = {}; result = [] def strongconnect(v): nonlocal index dfn[v] = low[v] = index index += 1 stack.append(v) on_stack.add(v) for w in graph.get(v, []): if w not in dfn: strongconnect(w) low[v] = min(low[v], low[w]) elif w in on_stack: low[v] = min(low[v], dfn[w]) if low[v] == dfn[v]: scc = [] while True: w = stack.pop() on_stack.remove(w) scc.append(w) if w == v: break result.append(scc) for v in graph: if v not in dfn: strongconnect(v) return result ``` **示例输入与输出**： ```python graph = { 1: [3], 2: [1], 3: [2,4], 4: [5], 5: [6], 6: [7], 7: [8], 8: [5] } print(tarjan_scc(graph)) # 输出：[[5, 8, 7, 6], [4], [2, 3, 1]] ``` ### 算法特性分析 - **时间复杂度**：$O(|V|+|E|)$，每个节点和边只被访问一次[^3] - **空间复杂度**：$O(|V|)$，主要来自递归栈和辅助数组[^4]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Clarence Liu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值