最短路练习

原创 已于 2022-03-13 11:45:34 修改 · 220 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

于 2021-10-10 10:22:00 首次发布

P1629 邮递员送信
题意：
n n n 个点， m m m 条边的有向图，每条边花费时间 w w w，注意边是单向的，每次从 1 1 1 出发到达 2 2 2 ，返回 1 1 1 ，出发到 3 3 3 ，返回 1 1 1，…直至重复到 n n n
求结束时的最小时间花费
思路：
最暴力的算法， F l o y e d Floyed Floyed 算法求全源最短路，显然会 T L E TLE TLE。
然后考虑跑 n n n 遍 D i j k s t r a Dijkstra Dijkstra，复杂度 O ( n 2 l o g n ) O(n^2logn) O(n2logn)，实测也 T T T 了
仔细分析下这个问题
每次从 1 1 1 出发到 2 , 3 , 4... n 2,3,4...n 2,3,4...n，我们跑一遍起点为 1 1 1 的最短路即可
主要是返回时间的最小花费该如何求，跑 n n n 遍 D i j k s t r a Dijkstra Dijkstra 算法实际上做了很多无用功，因为我们只需要求得 2 , 3 , 4... n 2,3,4...n 2,3,4...n 到 1 1 1 的最短路即可。
从 1 1 1 到其余点的最短路是 一对多 的形式，而从其他点到 1 1 1 是 多对一 的形式
如果能把 多对一 转化为 一对多，问题好解决了，一次 D i j k s t r a Dijkstra Dijkstra 算法就是解决这个问题的
如果我们在建原始图的同时，再建一张反向图，在原始图中每次从 2 , 3 , 4... n 2,3,4...n 2,3,4...n 点跑到 1 1 1 的最短路和在反向图中跑一遍从 1 1 1 开始的最短路实际上是等价的
code：

#include<bits/stdc++.h>
#define ll long long
#define endl '\n'
using namespace std;
const int maxn = 1e3 + 9;
int n, m;
struct node
{
	int to, next, w;
}e[maxn * 200];
int head[maxn * 2], cnt;
inline void add(int x, int y, int z)
{
	e[++cnt].w = z;
	e[cnt].to = y;
	e[cnt].next = head[x];
	head[x] = cnt;
}
int dis[maxn * 2];
bool vis[maxn * 2];
void dij(int s)
{	
	memset(dis, 0x3f, sizeof(dis));
	dis[s] = 0;
	priority_queue <pair<int,int>, vector<pair<int,int> >, greater<pair<int,int> > > q;
	q.push({0, s});
	while(!q.empty())
	{
		int now = q.top().second;q.pop();
		if(vis[now]) continue;
		vis[now] = 1;
		for(int i = head[now]; i; i = e[i].next)
		{
			int tmp = e[i].to;
			if(!vis[tmp] && dis[tmp] > dis[now] + e[i].w)
			{
				dis[tmp] = dis[now] + e[i].w;
				q.push({dis[tmp], tmp});
			}
		}
	}
}
void work()
{

	cin >> n >> m;
	while(m--)
	{
		int x, y, z;
		cin >> x >> y >> z;
		add(x, y, z);
		add(y + n, x + n, z);
	}
	ll ans = 0;
	dij(1);
	for(int i = 2; i <= n; ++i)
		ans += dis[i];
	dij(1 + n);
	for(int i = 2 + n; i <= n * 2; ++i)
		ans += dis[i];
	cout << ans << endl;
	
}

int main()
{
	ios::sync_with_stdio(0);
	work();
	return 0;
}

P1119 灾后重建
题意：
n n n 个点，第 i i i 个点在 t i t_i ti​ 时间后才可以到达， m m m 条边，表示 x x x 到 y y y 的路径花费 w w w，不存在重边， q q q 个询问，查询 x x x 到 y y y 的最短路，不存在则输出 − 1 -1 −1。
n < = 200 ,   m < = n ∗ ( n − 1 ) / 2 ,   q < = 50000 n<=200, \ m<=n*(n-1)/2, \ q<=50000 n<=200, m<=n∗(n−1)/2, q<=50000
思路：
正向加点问最短路，正好符合 f l o y d floyd floyd 算法枚举中转点 k k k ，按时间递增顺序加入的点，当作中转点 k k k 更新最短路即可

题目数据范围比较小
最短路算法可以考虑 F l o y e d Floyed Floyed 算法
查询时间保证了是单增的
每次把重建好的点当作中转点，更新最短路
code：

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 2e2 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
ll n, m;
int dis[maxn][maxn];
int t[maxn];
void work()
{
	cin >> n >> m;
	for(int i = 0; i < n; ++i) cin >> t[i];
	for(int i = 0; i < n; ++i)
		for(int j = 0; j < n; ++j)
			dis[i][j] = inf;
	for(int i = 0; i < n; ++i) dis[i][i] = 0;
	for(int i = 0; i < m; ++i)
	{
		int x, y, z;cin >> x >> y >> z;
		dis[x][y] = dis[y][x] = z;
	}
	int q;cin >> q;
	int now = 0;
	while(q--)
	{
		int l, r, z;cin >> l >> r >> z;
		while(t[now] <= z && now < n)
		{
			for(int i = 0; i < n; ++i)
				for(int j = 0; j < n; ++j) if(dis[i][j] > dis[i][now] + dis[now][j])
					dis[i][j] = dis[i][now] + dis[now][j];
			++now;
		}
		if(t[l] > z || t[r] > z) cout << -1 << endl;
		else if(dis[l][r] == inf) cout << -1 << endl;
		else cout << dis[l][r] << endl;
	}
}

int main()
{
	ios::sync_with_stdio(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

B. Greg and Graph
题意:
每次删去一个点，求当前删去该点之前的所有边的最小权值和。
思路：
每次删去一个点，直到把所有点都删尽。倒过来就相当于每次加入一个点，求加入该点后所有存在边的最小权值和，与 f l o y d floyd floyd 枚举中转点求最短路一致

P1522 [USACO2.4]牛的旅行 Cow Tours
题意：
n 个点的坐标，其中至少有两个连通块，要求在两个连通块中加一条边，然后使得新连通块的任意两个点的最短路的最大值最小。输出新连通块中的值最大的最短路，当然，是最小化后的。
思路：
因为存在连通块，所以我们可以先对连通块进行染色，进行区分。
最短路的最大值会怎么得到？
两个连通块本身的最短路的最大值，以及新连通块的最短路的最大值，三个取最大
那么如何来快速求得新连通块中最短路的最大值？
每次是连接两个连通块中的两个点，如果我们知道这两个点，分别在自己的连通块中，与其他点的最短路的最大值，我们就可以直接求得新连通块的最大值（两个点在自己连通块最短路的最大值+两点之间的距离）。因此，我们求一下每个点在自己连通块中与其他点最短路的最大值。到这可以发现，求出来每个点在自己连通块的与其他点的最短路的最大值，我们可以直接用这个最大值更新每个连通块的最大值。

步骤

  1. 先用 D F S DFS DFS 对连通块进行染色
  2. 用 F l o y e d Floyed Floyed 算法求得全源最短路
  3. 计算每个连通块中，每个点到其他点的 最短路 的最大值，以及连通块中所有最短路的最大值。
  4. 最后是找答案：对任意两个点，先判断是否同一个连通块。如果不是，考虑加入一条边，变成一个新的连通块。可以直接计算出通过这条边的最短路的最大值。 需要注意的是，通过这条边的最短路的最大值不一定是新连通块的所有最短路的最大值。这里需要比较三个值（j连通块 A 的所有最短路的最大值，连通块 B 的所有最短路的最大值， 加边后通过这条边的最短路的最大值），才能得到正确的新连通块的最大值。 枚举所有点对， 维护一下新连通块中最短路最大值的最小值。

code：

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 2e2 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double INF = 1e20;
int n, m;
char mp[maxn];
int color[maxn];// 染色 
double dis[maxn][maxn];
double x[maxn], y[maxn];
double Maxn[maxn];// 每个点到其他点最短路的最大值
double Maxm[maxn];// 每个连通块中最短路的最大值 
inline double jl(int i, int j)
{
	return sqrt((x[i]-x[j])*(x[i]-x[j]) + (y[i]-y[j])*(y[i]-y[j]));
}
void dfs(int i, int id)
{
	color[i] = id;
	for(int j = 1; j <= n; ++j) if(!color[j] && dis[i][j] < INF)
		dfs(j, id);
}
void work()
{
	cin >> n;
	for(int i = 1; i <= n; ++i)
		cin >> x[i] >> y[i];
	for(int i = 1; i <= n; ++i)
	{
		cin >> (mp + 1);
		for(int j = 1; j <= n; ++j)
		{
			if(i == j) dis[i][j] = 0;
			else if(mp[j] == '0') dis[i][j] = INF;
			else dis[i][j] = jl(i, j);
		}
	}
// 染色 
	int id = 0;
	for(int i = 1; i <= n; ++i) if(!color[i]) 
		dfs(i, ++id);
// 求全源最短路 
	for(int k = 1; k <= n; ++k)
		for(int i = 1; i <= n; ++i)
			for(int j = 1; j <= n; ++j)
				if(dis[i][j] > dis[i][k] + dis[k][j])
					dis[i][j] = dis[i][k] + dis[k][j];
// 求出每个连通块中，每个点到其他点的最短路的最大值，以及每个连通块中最短路的最大值
	for(int i = 1; i <= n; ++i) 
	{
		Maxn[i] = 0;
		for(int j = 1; j <= n; ++j) if(dis[i][j] != INF)
			Maxn[i] = max(Maxn[i], dis[i][j]);
		Maxm[color[i]] = max(Maxm[color[i]], Maxn[i]);
	}
// 最小化答案 
	double Min = INF, Max = 0;
	for(int i = 1; i <= n; ++i)
		for(int j = i + 1; j <= n; ++j)
			if(color[i] != color[j])
			{
				Max = max({Maxm[color[i]], Maxm[color[j]], Maxn[i] + jl(i, j) + Maxn[j]});
				Min = min(Min, Max);
			}
	cout << fixed << setprecision(6) << Min << endl;
	// 只有 setprecision(6) 表示控制有效位数，加上 fixed 就变成了控制小数 
}

int main()
{
	ios::sync_with_stdio(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

P1144 最短路计数
题意：
n n n 个点 m m m 条边的无向无权图，顶点 1 − n 1-n 1−n。求从顶点 1 1 1 开始，到其他每个点的最短路有几条。
输出 a n s   % 1 e 5 + 3 ans \ \% 1e5 + 3 ans %1e5+3，如果无法到达 i i i，输出 0 0 0。
思路：
迪杰斯特拉跑最短路顺便计数
code：

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 1e6 + 9;
const int mod = 100003;
const int inf = 0x3f3f3f3f;

int n, m;
struct node
{
	int to, next;
}e[maxn * 4];
int head[maxn], cnt;
inline void add(int x, int y)
{
	e[++cnt].to = y;
	e[cnt].next = head[x];
	head[x] = cnt;
}
int dis[maxn], ans[maxn];
bool vis[maxn];
priority_queue <pair<int,int>, vector<pair<int,int> >, greater<pair<int,int> > > q;
void work()
{
	cin >> n >> m;
	int u, v;
	for(int i = 1; i <= m; ++i)
	{
		cin >> u >> v;add(u, v);add(v, u);// 自环删不删不影响结果
	}
	for(int i = 1; i <= n; ++i)
		dis[i] = 1e9, vis[i] = 0;
	dis[1] = 0, ans[1] = 1;
	q.push({0, 1});
	while(!q.empty())
	{
		int now = q.top().second;q.pop();
		if(vis[now]) continue;
		vis[now] = 1;
		for(int i = head[now]; i; i = e[i].next)
		{
			int tmp = e[i].to;
			if(dis[tmp] > dis[now] + 1)
			{
				dis[tmp] = dis[now] + 1;
				ans[tmp] = ans[now];
				if(!vis[tmp])
				{
					q.push({dis[tmp], tmp});
				}
			}
			else if(dis[tmp] == dis[now] + 1)// 计数
				ans[tmp] = (ans[tmp] + ans[now]) % mod;
		}
	}
	for(int i = 1; i <= n; ++i)
		cout << ans[i] << endl;
} 

int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

1003 Emergency (25 分)
最短路计数升级版
题解
题意： n n n 个点， m m m 条边的图，要求从 c 1 c1 c1 到 c 2 c2 c2 的最短路的数量。每个节点有一个权值 w w w，最后输出最短路的数量以及最短路中节点权值和的最大值。
思路：
在最短路计数的基础上多维护一个权值和
这个题用spfa会比较麻烦，因为spfa算法中可能会经过一个点多次，因此在统计最短路径条数的时候需要额外用一个set进行存储和去重的工作。感觉比较难理解这个过程
code：

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 1e6 + 9;
const int mod = 1000000009;
const int inf = 0x3f3f3f3f;

int n, m;
struct node
{
	int to, next, w;
}e[maxn * 2];
int head[maxn], cnt;
inline void add(int x, int y, int z)
{
	e[++cnt].to = y;
	e[cnt].next = head[x];
	e[cnt].w = z;
	head[x] = cnt;
}
int dis[maxn], ans[maxn], W[maxn], res[maxn];
bool vis[maxn];
priority_queue <pair<int,int>, vector<pair<int,int> >, greater<pair<int,int> > > q;
void work()
{
	int c1, c2;
	cin >> n >> m >> c1 >> c2;
	int u, v, w;
	for(int i = 0; i < n; ++i) cin >> W[i];
	for(int i = 1; i <= m; ++i)
	{
		cin >> u >> v >> w;add(u, v, w);add(v, u, w);
	}
	for(int i = 0; i < n; ++i)
		dis[i] = 1e9, vis[i] = 0;
	dis[c1] = 0, ans[c1] = 1;
	q.push({0, c1});
	res[c1] = W[c1];// 初始化起点价值
	while(!q.empty())
	{
		int now = q.top().second;q.pop();
		if(vis[now]) continue;
		vis[now] = 1;
		for(int i = head[now]; i; i = e[i].next)
		{
			int tmp = e[i].to;
			if(dis[tmp] > dis[now] + e[i].w)
			{
				dis[tmp] = dis[now] + e[i].w;
				ans[tmp] = ans[now];
				res[tmp] = res[now] + W[tmp];
				q.push({dis[tmp], tmp});
			}
			else if(dis[tmp] == dis[now] + e[i].w)
			{
				ans[tmp] += ans[now];
				res[tmp] = max(res[tmp], res[now] + W[tmp]);
				//q.push({dis[tmp], tmp});
			}
		}
	}
	cout << ans[c2] << " " << res[c2] << endl;
} 

int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

P1462 通往奥格瑞玛的道路
题意：
n n n 个点， m m m 条边，边权为 c i c_i ci​ 代表通过这条边花费的生命值，初始生命值为 b b b。每个节点有一个权值 f i f_i fi​ 代表通过这个城市的花费。从 1 1 1 跑到 n n n，在能跑到节点 n n n 的情况下，最小化通过一个城市花费的最大值。
思路：
最小化最大值，显然二分。
注意如何特判掉输出 APK 的情况：把对花费的约束置为 inf，跑一遍dij判断是不是无法到达。
注意在 c h e c k check check 中加一个 f l a g flag flag 判断是否到达过这个思路是有问题的，因为 c h e c k check check 的 m i d mid mid 不够大，花仍然会约束路径
code：

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
using namespace std;
const int maxn = 1e4 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
int n, m, b;
int f[maxn];
ll dis[maxn];
struct Edge
{
	int to, next, w;
}e[maxn * 10];
int head[maxn], vis[maxn], cnt;
inline void add(int x, int y, int z)
{
	e[++cnt].to = y;
	e[cnt].w = z;
	e[cnt].next = head[x];
	head[x] = cnt;
}
bool check(int mid)
{
	if(f[1] > mid) return false;// 特判起点 
	priority_queue<pair<ll,int>,vector<pair<ll,int> >,greater<pair<ll,int> > > q;
	for(int i = 1; i <= n; ++i) dis[i] = inf, vis[i] = 0;
	dis[1] = 0;
	q.push({0, 1});
	while(!q.empty())
	{
		int now = q.top().second;q.pop();
		if(vis[now]) continue;
		vis[now] = 1;
		for(int i = head[now]; i; i = e[i].next)
		{
			int to = e[i].to;
			if(f[to] <= mid && dis[to] > dis[now] + e[i].w)
			{
				dis[to] = dis[now] + e[i].w;
				q.push({dis[to], to});	
			}
		}
	}
	if(dis[n] < b) return true;
	else return false;
}
void work()
{
	cin >> n >> m >> b;
	for(int i = 1; i <= n; ++i) cin >> f[i];
	for(int i = 1; i <= m; ++i)
	{
		int a, b, c;cin >> a >> b >> c;
		add(a, b, c);add(b, a, c);
	}
	if(!check(inf)){
		cout << "AFK" << endl;return;
	}
	int l = 0, r = 1e9;
	while(l < r)
	{
		int mid = (l + r) >> 1;
		if(check(mid)) r = mid;
		else l = mid + 1; 
	}
	cout << l << endl;
}

int main()
{
	ios::sync_with_stdio(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}
解题报告：【kuangbin带你飞】专题四 最短路练习题
繁凡さん的博客
07-10 1262
最短路合集
[kuangbin带你飞]专题四 做题顺序与题解 【最短路练习】
指弹键盘哼民谣
02-23 5972
随便说点： 博主正在刷kuangbin专题的题目，初学者，没接触过什么算法，刷题的初衷是备战蓝桥杯，后来发现了算法资料大多是针对acm的，挑选kuangbin专题入门也是如此，毕竟这样分类看起来能达到比较有目的的刷题。 所以有的代码比较冗余，越往后面的题解代码变化越大， 代码的风格和算法思想也是在一步步的学习和进步，多多包容，互相借鉴。 建议做题顺序： dijk: 1 7 4 10 3 2 1...
最短路专题练习
zhuml123的专栏
10-23 615
一、入门难度 1、HDU 2544（一级） 【题意】 给出n个顶点m条边，以及每条边的权值为w，求1到n的最短路 【思路】 裸题 2、HDU 2066 (一级) 【题意】 因为草儿的家在一个小镇上，没有火车经过，所以她只能去邻近的城市坐火车（好可怜啊~）。 【思路】 这道题其实一次Dijkstra就可以了，我们将草儿的家看做0，从草儿家到相邻镇的花费看做0，那么我们就只需要求草...
[kuangbin带你飞]专题四 最短路练习
09-12 254
A - Til the Cows Come Home  POJ - 2387  题意：t条边，n个点，求最短路。2&lt;=n&lt;=1000,1&lt;=t&lt;=2000。 题解：floyd时间复杂度O（n^3）1e9肯定超时. //Floyd，超时代码 #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cst...
最短路习题
Jackzhan的博客
08-13 735
有限制最短路（枚举+最短路） 分层图最短路
acm训练专题四：最短路练习
软糖汽水
04-10 1358
专题训练四：最短路练习
洛谷 P5651 基础最短路练习题
2301_78981471的博客
12-10 1113
定义一条简单路径的权值为路径上所有边边权的异或和。本题就是让我们求两点之间异或值最小的那一条路。中不存在简单环使得边权异或和不为。保证没有重边和自环。保证没有重边和自环。行，一行一个整数表示答案。条边的简单无向连通图。行，一行三个非负整数。异或(xor)的性质。
[kuangbin带你飞] 专题四 最短路练习 练习
CCCCTong的博客
04-23 322
1、Til the Cows Come Home 裸的最短路，wa一路发现自己T，N读入反了，据说还有重边，不过是邻接矩阵需要考虑的问题，前向星和邻接表可以忽略。 #include <iostream> #include <algorithm> #include <cstdio> #include <queue> #include <c...
poj 1860 Currency Exchange ([kuangbin带你飞]专题四 最短路练习)
Strive
11-10 565
Description Several currency exchange points are working in our city. Let us suppose that each point specializes in two particular currencies and performs exchange operations only with these curren
[kuangbin]专题四 最短路练习 Tram POJ - 1847【dijkstra】
inv0ker的博客
09-02 309
【题目描述】 Tram network in Zagreb consists of a number of intersections and rails connecting some of them. In every intersection there is a switch pointing to the one of the rails going out of the interse...
最短路 || 最长路 || 次短路
最新发布
qq_43052183的博客
09-11 1371
简单粗略讲了一些路径问题的思路，附带一些题目
最短路习题集（hdu）
ljlhnick的博客
08-05 1434
下面把在杭电刷题的最短路的代码贴上 hdu 2544 点击打开链接 dijkstra算法 #include <iostream> #include <algorithm> #include <stdio.h> #include <string.h> #define N 200 #define Y 33333110 using names...
P6560 [SBCOI2020] 时光的流逝 （博弈，反向建图，拓扑排序
cosx_的博客
03-09 4749
洛谷P6560 [SBCOI2020] 时光的流逝 题意： 给定一个有向图（可能有环），给定起点和终点，两个人玩游戏，一人走一步，先到达终点的人赢或者先无法移动的人输 思路： 题解 因为是终点和叶子节点是必败态，这是确定的，因此我们可以倒着搞 建反图跑拓扑排序更新节点胜负态 存在环就很难搞，拓扑排序的时候是无法进入环的，那么环上的点就难以确定胜负态 更新思想有点类似于点权这个题 就是如果当前节点胜负态是确定的，就可以去更新其他节点，我们就把他 pushpushpush 到队列中，而不是按照拓扑排序的顺序来
最小环算法
cosx_的博客
11-29 2763
知乎学习链接 最小环概念： 在无向图中，最小环至少应当包含 333 个顶点。也就是说，将无向边拆分为两条有向边，以此形成的 222 顶点环，不能视作最小环，有向图则无顶点数的限制。 在图论中，一张图的最小环长度也被称为它的围长（girth）。 Floyd求无向图最小环 该算法最常使用，足以解决绝大多数无向图最小环问题。 当最外层恰好循环到 kkk 时，代表着目前所求出的最短路所含的点集为 [1,k)[1,k)[1,k)。 这时的中转点 kkk 一定不存在于 iii —> jjj 的最短路中，然后再枚举
欧拉回路/欧拉路径
cosx_的博客
02-26 1181
搬来大佬的前置知识： 定义：从一个点出发，不重不漏的经过图中每一条边的一条路径（允许多次经过同一个点）。如果此路径的起点和终点相同，则称其为一条欧拉回路。 欧拉路径判定（是否存在）： 首先要保证连通 有向图欧拉路径：图中恰好存在 111 个点出度比入度多 111（这个点即为起点 SSS），111 个点入度比出度多 111（这个点即为终点 TTT），其余节点出度 === 入度。 有向图欧拉回路：所有点的入度 === 出度（起点 SSS 和终点 TTT 可以为任意点）。 无向图欧拉路径：图中恰好存在 222
2021 RoboCom 世界机器人开发者大赛-本科组（初赛）
cosx_的博客
10-11 1126
7-2 芬兰木棋 (25 分) 被这题背刺了，最后才想明白wa点，想了一个小时，草了 code： #include<bits/stdc++.h> #define endl '\n' #define ll long long using namespace std; const int maxn = 1e5 + 9; const int mod = 1e9 + 7; const int inf = 0x3f3f3f3f; ll n, m; int x[maxn], y[maxn], p[maxn]
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值