Tarjan用法总结【模板预备】

最新推荐文章于 2022-08-30 20:13:44 发布
最新推荐文章于 2022-08-30 20:13:44 发布
阅读量179 收藏 1
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42819250/article/details/109911220
版权

Tarjan

可缩点、DAG有向无环图、强连通分量及其出入度，割点、割边、点双联通分量、边双连通分量，LCA。

一、基础算法及理解

dfn[x]：访问到该节点的时间戳。

low[x]：x和x子树中的所有节点，通过一条边(除去树边)，可到达的节点最小时间戳。

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+6;
vector<int>G[maxn];
int tot,tp,cnt;
int dfn[maxn],low[maxn],st[maxn],in[maxn],col[maxn];
int v[maxn],val[maxn];
void tarjan(int x){
	dfn[x]=low[x]=++tot;
	st[++tp]=x;
	in[x]=1;
	for(int i=0;i<G[x].size();i++){
		int v=G[x][i];
		if(!dfn[v]){
			tarjan(v);
			low[x]=min(low[x],low[v]);
		}
		else if(in[v])
		low[x]=min(low[x],dfn[v]);
	}
	if(dfn[x]==low[x]){
		cnt++;
		col[x]=cnt;
		val[cnt]=v[x];
		in[x]=0;
		while(st[tp]!=x){
			col[st[tp]]=cnt;
			val[cnt]+=v[st[tp]];
			in[st[tp]]=0;
			tp--;
		}
		tp--;//这里小心！
	}
}

在栈中的节点，他自己子节点的遍历任务没有完成，也就是说子树中还有节点的遍历没完成，假设此时时间停止，那么此时正在进行的遍历的节点x，是栈中所有节点的子树的一份子（假设时间停止在对x的子节点遍历之前，可以理解成刚进入tarjan(x)函数还未进行其他操作）。所以当前的x和栈中的节点是祖先关系，即栈中元素可达x。

设tarjan遍历没有遇到阻碍（即dfn==0）时经过的边为树边，由所谓树边连接的称父子节点。

根据low[x]定义，是x及其子树跨过某条边可达的节点的dfn的最小dfn值，同时二者彼此可达。

  1. 那么对于同一棵子树，直接取每个子节点的low值更新即可。l

  2. 对于非子树的节点v，如果还在栈中，那么v和x其实早就有“先后”顺序了，而此时的“当前正在进行的遍历的点x”，又有新边（不可能称为树边了，“祖先边”）连接到v，由此二者彼此可达。用dfn更新完美地符合定义。

二、相关概念

  1. 强连通分量：分量内部的节点彼此可达。

  2. 点双联通分量：分量内部没有割点

  3. 边双连通分量：分量内部没有割边（桥）

三、易错点

注意有无孤立点、重边，自环；注意有向图和无向图的算法区别。

割点可忽视重边，割边不可忽视重边

四、tarjan求有向图

1. 求强连通分量(缩点)

https://www.luogu.com.cn/problem/T103440

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+6;
vector<int>G[maxn];
int tot,tp,cnt;
int dfn[maxn],low[maxn],st[maxn],in[maxn],col[maxn];
int v[maxn],val[maxn];
void tarjan(int x){
	dfn[x]=low[x]=++tot;
	st[++tp]=x;
	in[x]=1;
	for(int i=0;i<G[x].size();i++){
		int v=G[x][i];
		if(!dfn[v]){
			tarjan(v);
			low[x]=min(low[x],low[v]);
		}
		else if(in[v])
		low[x]=min(low[x],dfn[v]);
	}
	if(dfn[x]==low[x]){
		cnt++;
		col[x]=cnt;
		val[cnt]=v[x];
		in[x]=0;
		while(st[tp]!=x){
			col[st[tp]]=cnt;
			val[cnt]+=v[st[tp]];
			in[st[tp]]=0;
			tp--;
		}
		tp--;//这里小心！
	}
}
int vis[maxn];
int main(){
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>v[i];
	}
	int u,v;
	for(int i=1;i<=m;i++){
		cin>>u>>v;
		G[u].push_back(v);
	}
	for(int i=1;i<=n;i++){
		if(!dfn[i])tarjan(i);
	}
	for(int i=1;i<=n;i++){
		if(!vis[col[i]]){
			cout<<val[col[i]]<<"\n";
			vis[col[i]]=1;
		}
	}
}

2. 求出度入度

https://ac.nowcoder.com/acm/contest/76/E?&headNav=www

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+6;
vector<int>G[maxn];
int tot,tp,cnt;
int dfn[maxn],low[maxn],st[maxn],in[maxn],col[maxn];
int in_[maxn],out_[maxn];

void tarjan(int x){
	dfn[x]=low[x]=++tot;
	st[++tp]=x;
	in[x]=1;
	for(int i=0;i<G[x].size();i++){
		int v=G[x][i];
		if(!dfn[v]){
			tarjan(v);
			low[x]=min(low[x],low[v]);
		}
		else if(in[v])
		low[x]=min(low[x],dfn[v]);
	}
	if(dfn[x]==low[x]){
		cnt++;
		col[x]=cnt;
		in[x]=0;
		while(st[tp]!=x){
			col[st[tp]]=cnt;
			in[st[tp]]=0;
			tp--;
		}
		tp--;
	}
}
int vis[maxn],vis_[maxn];
int main(){
	int n,m;
	cin>>n>>m;
	int x;
	for(int i=1;i<=m;i++){
		cin>>x;
		vis[x]=1;
	}
	int u,v,num_;
	for(int i=1;i<=n;i++){
		cin>>num_;
		for(int j=0;j<num_;j++){
			cin>>v;
			G[i].push_back(v);
		}
	}
	for(int i=1;i<=n;i++){
		if(!dfn[i])tarjan(i);
	}
	for(int i=1;i<=n;i++){
		if(vis[i])
		vis_[col[i]]=1;
	}
	for(int i=1;i<=n;i++){
		for(int j=0;j<G[i].size();j++){
			int v=G[i][j];
			if(col[i]!=col[v]){
				out_[col[i]]++;//连通块出度 
				in_[col[v]]++;//连通块入度 
			}
		}
	} 
	int cnt_=0;
	for(int i=1;i<=cnt;i++){
		if(in_[i]==0)cnt_++;
	}
	if(cnt_>m){
		printf("-1\n");
		return 0;
	}
	int ans=0;
	for(int i=1;i<=cnt;i++){
		if(in_[i]==0){
			if(vis_[i]==0){
				printf("-1\n");
				return 0;
			} 
			else{
				ans++;
			}
		}
	}
	cout<<ans<<"\n";
}

3. 缩点+出入度 重构成DAG

https://www.luogu.com.cn/problem/P3387

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
#define pii pair<int,int>
const int maxn=1e6+6;
vector<int>G[maxn];
vector<int>g[maxn];
int v[maxn],val[maxn];
int dfn[maxn],low[maxn],col[maxn],st[maxn],in[maxn];
int out_[maxn],in_[maxn];
int tot,cnt,tp;
void tarjan(int x){
	dfn[x]=low[x]=++tot;
	in[x]=1;
	st[++tp]=x;
	for(int i=0;i<G[x].size();i++){
		int v=G[x][i];
		if(!dfn[v]){
			tarjan(v);
			low[x]=min(low[x],low[v]);
		}else if(in[v])low[x]=min(low[x],dfn[v]);
	}
	if(dfn[x]==low[x]){
		cnt++;
		col[x]=cnt;
		in[x]=0;
		val[cnt]=v[x];
		while(st[tp]!=x){
			col[st[tp]]=cnt;
			in[st[tp]]=0;
			val[cnt]+=v[st[tp]];
			tp--;
		}
		tp--;
	}
}
void rebuild(int x){
	for(int i=0;i<G[x].size();i++){
		int v=G[x][i];
		if(col[x]!=col[v]){
			g[col[x]].push_back(col[v]);
		//	out_[col[x]]++;
			in_[col[v]]++;
		}
	} 
}
int sum[maxn];
int dfs(int x){
	if(sum[x]!=0)return sum[x];
	sum[x]=val[x];
	int tmp=0;
	for(int i=0;i<g[x].size();i++){
		int v=g[x][i];
		tmp=max(tmp,dfs(v));
	}
	sum[x]+=tmp;
	return sum[x];
}
int main(){
	int n,m;
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)scanf("%d",&v[i]);
	for(int i=1;i<=m;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		G[u].push_back(v);
	}
	for(int i=1;i<=n;i++){
		if(!dfn[i])tarjan(i);
	}
	for(int i=1;i<=n;i++){
		rebuild(i);
	}
	for(int i=1;i<=cnt;i++){
		if(in_[i]==0){
			dfs(i);
		}
	}
	int ans=0;
	for(int i=1;i<=cnt;i++){
		ans=max(ans,sum[i]);
	}
	cout<<ans<<"\n";
}

五、tarjan求无向图

1. 求割点

https://www.luogu.com.cn/problem/P3388

#include<bits/stdc++.h>
using namespace std;
const int maxn=3e5+6;
vector<int>G[maxn];
int dfn[maxn],low[maxn],snum[maxn];
int deep;
void tarjan(int u,int fa){
    dfn[u]=++deep;
    low[u]=deep;
    int sz=G[u].size();
    for(int i=0;i<sz;i++){
        int v=G[u][i];
        if(!dfn[v]){
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
            if(low[v]>=dfn[u])snum[u]++; //u未必就是割点（u是子树根时）
        }
        else if(v!=fa)low[u]=min(low[u],dfn[v]);//和有向图的区别
    }
}
int main(){
	int n,m;
	scanf("%d%d",&n,&m);
	for(int i=0;i<m;i++){
		int aa,bb;
		scanf("%d%d",&aa,&bb);
		G[aa].push_back(bb);
		G[bb].push_back(aa);
	}
	int ans=0;
	for(int i=1;i<=n;i++){
		if(!dfn[i])tarjan(i,i),ans++,snum[i]--;//根节点需要snum[i]-- 
	}
	//snum[i]:去掉i后,增加的联通块数。
    //snum[i]>0时，i才为割点。 
}

2. 求割边

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=1e6+6;
vector<int>G[maxn];
int dfn[maxn],low[maxn],num[maxn];
int tot;
#define pii pair<int,int>
vector<pii>vc;
void tarjan(int x,int fa){
	dfn[x]=low[x]=++tot;
	for(int i=0;i<G[x].size();i++){
		int v=G[x][i];
		if(!dfn[v]){
			tarjan(v,x);
			low[x]=min(low[x],low[v]);
			if(low[v]>dfn[x]){
				vc.push_back(pii(x,v));//割边 
			}
		}
		else if(v!=fa)low[x]=min(low[x],dfn[v]); 
	}
}
int main(){
	int n,m;
	cin>>n>>m;
	int u,v;
	for(int i=1;i<=m;i++){
		cin>>u>>v;
		G[u].push_back(v);
		G[v].push_back(u);
	}
	int ans=0; 
	for(int i=1;i<=n;i++){
		if(!dfn[i]){
			tarjan(i,0);
			ans++;
		}
	}
	cout<<vc.size()+ans<<"\n"; //求出整个图中，边双联通分量的数目
}

3. 求出边双联通分量的数量

https://www.luogu.com.cn/problem/T103489

只需要将上面求割边代码中的main函数改为：

int main(){
	int n,m;
	cin>>n>>m;
	int u,v;
	for(int i=1;i<=m;i++){
		cin>>u>>v;
		G[u].push_back(v);
		G[v].push_back(u);
	}
	int ans=0; 
	for(int i=1;i<=n;i++){
		if(!dfn[i]){
			tarjan(i,0);
			ans++;
		}
	}
	cout<<vc.size()+ans<<"\n"; //求出整个图中，边双联通分量的数目
}

即可。

4. 求出每一个点双联通分量

https://www.luogu.com.cn/problem/T103492

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=1e6+6;
vector<int>G[maxn];
int dfn[maxn],low[maxn],in[maxn],st[maxn];
int tot,tp;
void tarjan(int x,int fa){
	dfn[x]=low[x]=++tot;
	st[++tp]=x;
	if(fa==0&&G[x].size()==0){//注意这里 孤立点的处理 
		cout<<x<<"\n";
		return;
	}
	for(int i=G[x].size()-1;i>=0;i--){
		int v=G[x][i];
		if(!dfn[v]){
			tarjan(v,x);
			low[x]=min(low[x],low[v]);
			if(low[v]>=dfn[x]){
				int z;
				do{
					z=st[tp--];
					cout<<z<<" ";
				}while(z!=v);
				cout<<x<<"\n";
            }    
		/*	这里不用以下的代码： 
			while(st[tp]!=x){
				cout<<st[tp]<<" ";
				tp--;
			}
			cout<<x<<"\n";
			原因是，v后面未必就是x。
			栈里面的数据是点第一次被访问就进去一个新的，
			但是出栈却是有更严格的条件：需要low[v]>=dfn[x]。
			进和出的条件不在同一水平。 
		*/ 	
		}
		else if(v!=fa)low[x]=min(low[x],dfn[v]); 
	}
}
int main(){
	int n,m;
	cin>>n>>m;
	int u,v;
	for(int i=1;i<=m;i++){
		cin>>u>>v;
		G[u].push_back(v);
		G[v].push_back(u);
	}
	for(int i=1;i<=n;i++){
		if(!dfn[i]){
			tarjan(i,0);
		}
	}
}

六、tarjan求树

1. 求LCA[离线求法]

https://www.luogu.com.cn/problem/P3379

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
#define pii pair<int,int>
const int maxn=1e6+6;
vector<int>G[maxn];
vector<int>Q[maxn];
map<pii,int>mp;
int vis[maxn],fa[maxn];
int ffa(int x){
	if(fa[x]==x)return x;
	return fa[x]=ffa(fa[x]);
	//又是这里出锅 
	//1.return fa[x]=ffa(x);
	//2.return ffa(fa[x]);
	//以上两种皆会T 
}
void tarjan(int x){
	vis[x]=1;
	fa[x]=x;
	for(int i=0;i<G[x].size();i++){
		int v=G[x][i];
		if(vis[v])continue;
		tarjan(v);
		fa[v]=x;//这里感觉是精髓！
	}
	for(int i=0;i<Q[x].size();i++){
		int v=Q[x][i];
		if(vis[v]){
			mp[pii(x,v)]=mp[pii(v,x)]=ffa(v);
		}
	}
}
struct Query{
	int u,v;
}query[maxn];
int main(){
	int n,m,rt;
	scanf("%d%d%d",&n,&m,&rt);
	for(int i=1;i<n;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		G[u].push_back(v);
		G[v].push_back(u);
	}
	for(int i=1;i<=m;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		query[i].u=u;
		query[i].v=v;
		Q[u].push_back(v);
		Q[v].push_back(u);
	}
	tarjan(rt);
	for(int i=1;i<=m;i++){
        cout<<mp[pii(query[i].u,query[i].v)]<<"\n";
	}
}
xiao小c
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
文章总数35祭+tarjan的多种用法：求强连通分量，缩点，割点、桥，LCA，点双连通图、边双联通图、2-SAT问题
weixin_43872370的博客
02-12 419
文章总数35祭+tarjan的三种用法：求强连通分量，缩点，割点和桥 tarjan算法十分奇妙，有许多不同的运用。下面我们一起看看。 0.背景知识 先度娘一下tarjan: Robert Tarjan，计算机科学家，以LCA、强连通分量等算法闻名。他拥有丰富的商业工作经验，1985年开始任教于普林斯顿大学。 Robert Tarjan他还在多所大学担任学术职务，如：康奈尔大学（1972-1973年...
tarjan算法各种应用
zyhyz的博客
07-17 1271
Robert Tarjan，一个很牛逼的计算机科学家。 tarjan算法真的是一个神奇的算法，一个简单的dfs却可以解决联通性的问题以及求最近公共祖先。 首先介绍一下什么是强连通分量。 强连通：在一个有向图，对于任意两点a,b都互相可达，则称这个图是强连通的。 强连通分量：有向图的极大强连通子图。 先去健身。。。。剩下的回头补...
tarjan-用法（缩点-求出入度，求强连通分量，割点，割边）
weixin_46433162的博客
07-09 161
tarjan 的用法有：求强连通分量，求强连通分量的出入度，割点，割边
Tarjan 算法介绍及用法
Caristra的博客
08-02 629
Tarjan 简介： 这是一个有关图联通的算法，它基于dfs 在解决有环的有向图或无向图的问题时，很多算法不好是操作… 那么就先要将环进行缩点，将其转换为DAG（有向无环图）或一棵树，然后问题应会迎刃而解 常规操作： 首先补几个概念： - 强连通：在一个DAG中，有 a,b 两点，若a可以到达b且b可以到达a，则(a,b)即为强连通 - 强连通图：若在一个DAG中，任意两...
tarjan - tarjan的几种用法
weixin_30629977的博客
09-28 73
前言 tarjan是一种神奇的算法， 它可以在线性时间内求强联通分量/缩点/LCA/割点/割边/... 但由于博主咸鱼，暂时掌握不了这么多， 先讲讲其中最简单的一些。 概述 tarjan是以DFS为基础的算法。 在DFS的过程中会产生一棵树。 tarjan在DFS过程中要用到2个数组(其实还有一个栈)： low[],节点i能够回溯到的最早位于栈中的节点; dfn[],深度优先搜索遍历时节点i被...
有向图缩点：tarjan强连通缩点(模板)
01-20
有向图缩点是图论中的一个重要概念，...通过这个模板，可以方便地在实际问题中应用Tarjan算法解决有向图的强连通分量问题。在使用时，需要根据具体的有向图数据结构和需求，调整输入和输出部分，以适应不同的应用场景。
无向图缩点：tarjan点双与边双缩点(模板)
01-20
总结一下，这个模板代码提供了两种无向图缩点的方法：一种是基于边的DCC（Disjoint Connected Components，即不相交连通分量）缩点，另一种是基于点的DCC缩点。这两种方法都利用了Tarjan算法来查找强连通分量和桥，...
HDU-1269（Tarjan模板-求强连通分量）
01-03
 Tarjan模板题 补习： AC code: /* Tarjan求有向图的强连通分量， */ #include #include #include #include #include using namespace std; const int MAXN = 1e5 + 10; struct Edge{ int to, next, dis; }edge...
Tarjan算法模板
05-25
C++实现Tarjan算法的一个简单模板，求有向图的强连通分量。时间复杂度为O(N+M)。
Tarjan算法讲义
07-14
Tarjan 算法是图论中非常实用 / 常用的算法之一，能解决强连通分量，双连通分量，割点和桥，求最近公共...本篇文章我们主要介绍如何使用 Tarjan 算法求解无向图的割点与桥。 我们先来简单地了解下什么是 Tarjan 算法
Tarjan算法详解
Ezereal的博客
09-13 521
Tarjan算法的用途之一是，求一个有向图G=(V,E)里极大强连通分量。强连通分量是指有向图G里顶点间能互相到达的子图。而如果一个强连通分量已经没有被其它强通分量完全包含的话，那么这个强连通分量就是极大强连通分量。 【算法思想】     用dfs遍历G中的每个顶点，通dfn[i]表示dfs时达到顶点i的时间，low[i]表示i所能直接或间接达到时间最小的顶点。(实际操作中low[i]
Tarjan 算法及其应用
Kwjdefulgn的博客
01-20 222
Tarjan 算法及其应用 NO.1 求强连通分量 学习链接： https://www.cnblogs.com/shadowland/p/5872257.html 学习心得： dfn[cur] 记录访问 cur 结点的时间戳，low[cur] 记录 cur 结点及其子树中时间戳最小是多少，显然当访问 cur 结点的子节点 to 时，若 dfn[to] 不为0，则 to 结点到 cur 或 cur ...
Tarjan算法详解（包含人工栈写法）
weixin_42137657的博客
04-28 1468
一、Tarjan算法简介 Tarjan算法是由Robert Tarjan发明的一种基于DFS的图论算法，他可以用来求解有向图的强联通 分量或者求解无向图的中的割点和桥等，可以说是图论算法中的基本算法之一。本文将以求解有向 图的强联通分量来介绍Tarjan算法。 二、有向图的强联通 有向图的两个结点可以相互到达，他们便在一个强联通分量内，如图所示： 其中{1,2,3,5}四个结点可以相互到达，...
浅说——tarjan
weixin_30832143的博客
08-04 128
Tarjan陪伴强连通分量， 生成树完成后思路才闪光。 Euler跑过的七桥古塘 让你，心驰神往…… 相关连接： https://big-news.cn/2019/02/07/%E5%BC%BA%E8%BF%9E%E9%80%9A%E5%88%86%E9%87%8F/ https://www.langlangago.xyz/index.php/archives/83/...
Tarjan缩点算法 作用、原理、模板
avgstuBoboge的博客
07-07 797
Tarjan原理&模板 来了来了，鸽了好久的图论基础。 众所周知一个对于一个DAG我们可以做很多骚操作(比如拓扑，无需标记访问的DFS等)，那么一个图如果有环怎么办呢。Tarjan他来了（j不发音，所以中文应该是塔扬）。 Tarjan算法作用： 将一个有环图中的连通块缩成一个点(同一个连通块染上相同颜色)，使其变成一个DAG(有向无环图)后做各种操作。 Tarjan算法原理 其实还是DFS。 需要一个dfn数组和一个low数组以及一个栈用于存放已遍历过但尚未染色的结点。 dfn数组定义：dfn[u]
浅谈tarjan算法
eyuhaobanga的博客
08-30 362
题目的意思是牛A能当明星牛，当且仅当所有牛都喜欢他，而且牛对牛的喜欢可以传递，这就相当于一张由有向边构成的有向图，我们要先求出所有强连通分量来，然后进行缩点，如果缩点以后有出度为0的，那么这个点就有可能是一个或一群明星牛，为什么说可能呢，因为如果出度为0的点大于1个的话，也就是说这些出度为0的点之间是不连通的，那么也就不符合所有牛都喜欢的定义，注意，这个点指的是缩完以后的点，并不是最初定义的编号1-n的点。low[]在该点的子树中能够回溯到的最早的已经在栈中的结点。还有DFS树、DFS序等请前往。.....
tarjan算法原理介绍
zakheav的专栏
06-09 5412
证明比较繁琐，仔细检查了应该没有大错，记录一下证明过程。 强连通分量定义： 在有向图中，强连通分量的定义是：有向图的某个子图，其中任意两个点之间可以互达。 强连通分量的定理： 定理1：一个完整的强连通分量一定包含在一棵深度优先搜索树中。 定理2：子图是强连通分量子图中的每一条路径都归属于一个环状（除非只有一个点）。 证明：根据强连通分量的定义，任意两个点之间可以互达，所以等价于
VIJOS1769 网络的关键边 [Tarjan][桥]
lemonoil的博客
10-18 379
网络的关键边描述考虑一个连通的无向图，可以知道，任意两个节点都可以通过一条路径连接起来。在所有节点中，某些节点向所有与它连通的节点提供A服务（包括向它自己），同时某些节点向所有与它连通的节点提供B服务（也包括向它自己）。注意一个节点也可能同时提供A、B两种服务。当图中的某条边E被去掉的时候，如果图中有任何一个点无法接受A服务或者接受B服务，我们称E边为关键边。那么，你需要做的事情就是： 1、输出图中
Tarjan及2-SAT讲课PPT
最新发布
10-20
Tarjan算法是图论中常见的一种方法，可以用于缩点和求强连通分量。 Tarjan算法的重要性在于它可以将有向图中的强连通分量缩成一个点，从而将原图转化为一个有向无环图。这个过程可以通过DFS来实现。首先对于一个图...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值