【基于联通性的状态压缩动态规划】

最新推荐文章于 2024-07-25 19:26:22 发布
最新推荐文章于 2024-07-25 19:26:22 发布
阅读量1.2k 收藏
点赞数
分类专栏： dp 文章标签： include list hashmap bt struct c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cjoilmd/article/details/7327495
版权

  


      以前一直被【jyltxdztysdtgh】吓到，虽然cdq的论文看的懂，但一直没有写，太恶心了。

      不过这个时候是必须要写了。

      先贴几个链接：

       http://www.notonlysuccess.com/index.php/plug_dp/

      http://blog.csdn.net/jasonzhu8/article/details/5779518


      就小小的总结一下，写【......】的时候让人感觉实在玩接水管游戏，其实只要把各种状态写在纸上，细心一点，多写几遍之后就没那么恶心了。

       利用4进制，0表示无括号，1表示左括号，2表示右括号，为了防止写错，就写了两个过程，get（state， p）和cor（state，p，alt），分别是询问state的第p位 / 把state的第p位染成alt，这样每次转移时只用这两个过程，就是的对于一遇到很多运算套在一起就晕（比如我）是一个很大的帮助，虽然会增加代码量，但是为了写对还是值得的。

     

      主要就是要注意细节，换行时的转移，障碍的转移，hash表的处理，只要细节处理好了，就基本上差不多了。

      虽然不好调，但是模块化应该还是没有问题的。


       ural1519：

     模板题，曼哈顿回路个数。

# include <cstdlib>
# include <cstdio>
# include <cmath>
# include <cstring>
# include <ctime>

using namespace std;

const int S = 15000;

typedef long long int64;
struct HashMap
{
	int top, linke[S*10], next[S*10], point[S*10];
	int link(int x, int y)
	{
		++top; next[top] = linke[x]; linke[x] = top; point[top] = y;
		return top;
	}
	int ask(int state)
	{
		int ke, hs = state % 10009; 
		for (ke = linke[hs]; ke; ke = next[ke])
		   if (point[ke] == state) break;
	    return ke? ke: link(hs, state);
	}
}hash;

int n, m, head[2], tail[2], que[2][S*10], p;
int64 ans, f[2][S*10];
int mat[30], bct[30];
int lastn, lastm;
char c[30][30];
bool step[S*10];
inline int get(int state, int pl)
{
	return (state>>((pl-1)<<1))&3;
}
inline void cor(int &state, int p, int alt)
{
	int pri = get(state, p);
	state ^= pri << ((p-1)<<1);
	state |= alt << ((p-1)<<1);
}
void update(int SX, int x, int y)
{
     f[p][x] += f[!p][y];
     if (!step[x]) que[p][++tail[p]] = SX,step[x]=true;
}
void expand(int state, int line, int list)
{
	 //printf("%d\n", state);
	 int i,aim, X, Y, Z, pX, pY;
	 pX = list+1; pY = list+2;
     X = get(state, pX); Y = get(state, pY);
     if (c[line][list]=='*'&&(X!=0||get(state,list)!=0)) return;
     if (list == m)
     {
		if (!X) update(state<<2, hash.ask(state<<2),hash.ask(state));
	 }
	 else if (c[line][list+1] == '*')
	 {	
		if ((!X)&&(!Y))
		  update(state, hash.ask(state),hash.ask(state));	
	 } 
	 else if ((!X) && (!Y))
	 {
		aim = state; cor(aim, pX, 1); 
		cor(aim, pY, 2);
	    update(aim, hash.ask(aim),hash.ask(state));
	 } 
	 else if ((!X)||(!Y))
	 {
		update(state, hash.ask(state), hash.ask(state));
		aim = state; cor(aim, pX, 0); 
		cor(aim, pY, 0); 
		cor(aim, pX, Y); 
		cor(aim, pY, X);
		update(aim, hash.ask(aim),hash.ask(state));
	 }
	 else if (X==2 && Y==1)
	 {
	    aim = state; cor(aim, pX, 0); 
		cor(aim, pY, 0);
	    update(aim, hash.ask(aim),hash.ask(state));
	 }
	 else if (X==Y)
	 {
		memset(mat,0,sizeof(mat));
		memset(bct,0,sizeof(bct));	
		for (i = 1; i <= m+1; i++)
		{
			Z = get(state, i);
			if (Z==1) mat[++mat[0]] = i;
			else if (Z==2) bct[i] = mat[mat[0]], bct[mat[mat[0]--]] = i;
		}
		aim = state; cor(aim, pX, 0); cor(aim, pY, 0);
		if (X==1) cor(aim, bct[pY], 1), update(aim, hash.ask(aim),hash.ask(state));
		if (X==2) cor(aim, bct[pX], 2), update(aim, hash.ask(aim),hash.ask(state));	
	 }
	 else if (lastn == line && lastm-1 == list)
	 {
		aim = state; cor(aim, pX, 0); cor(aim, pY, 0);
	    if (!aim)ans += f[!p][hash.ask(state)];
	 }
}
void work()
{
	int i, j;
	que[1][head[1] = tail[1] = 1] = 0; p = 1; 
	f[1][hash.ask(0)] = 1;
	for (i = 1; i <= n; i++)
	  for (j = 0; j <= m; j++)
	  {
			p ^= 1; 
			memset(f[p], 0, sizeof(f[p])); head[p] = 1; tail[p] = 0;
			memset(step, false, sizeof(step));
			for (;head[!p] <= tail[!p]; head[!p]++)
			   expand(que[!p][head[!p]], i, j);
			if (i == lastn && j == lastm) return;
	  }
}
int main()
{
	int i, j;
	freopen("ural1519.in", "r", stdin);
	freopen("ural1519.out", "w", stdout);
	scanf("%d%d\n", &n, &m);
	for (i = 1; i <= n; i++)
	{
		for (j = 1; j <= m; j++)
		{
		  scanf("%c", &c[i][j]);
		  if (c[i][j] == '.') lastn = i, lastm = j;
		}
		scanf("\n");
	}
	work();
	//printf("%d\n", hash.top);
	printf("%I64d", ans);
	return 0;
}

poj1379：

有限制的曼哈顿路径数量。

仅仅只是对上面的程序改了一点点。      


# include <cstdlib>
# include <cstdio>
# include <cmath>
# include <cstring>
# include <ctime>

using namespace std;

const int S = 1000;
typedef long long int64;

int linke[S], next[S], point[S];
int bct[20], que[2][S], head[2], tail[2], mat[20];
int64 ans, f[2][S];
int n, m, lastn, lastm, X, Y, pX, pY, p;
bool step[S];
char c[20][20];
int top;

inline int link(int x, int y)
{
	++top; next[top] = linke[x]; linke[x] = top; point[top] = y;
	return top; 
}
inline int ask(int state)
{
	int ke , hs = state % 997;
	for (ke = linke[hs]; ke; ke = next[ke])
	  if (point[ke] == state) break;
	return ke? ke:link(hs, state);
}
inline int get(int state, int pl)
{
	return (state>>((pl-1)<<1))&3;
}
inline void cor(int &state, int p, int alt)
{
	int tp = get(state, p);
	state ^= tp  << ((p-1)<<1);
	state ^= alt << ((p-1)<<1);
}
inline void update(int state, int x, int y)
{
	f[p][x] += f[!p][y];
	if (!step[x]) que[p][++tail[p]] = state, step[x] = true;
} 
void expand(int state, int line , int list)
{
    int aim, i, pX = list+1, pY = list+2, X = get(state, pX), Y = get(state, pY);
    if (list == m)
    {
		if (!X) update(state<<2, ask(state<<2), ask(state));
	}
	else if (c[line][list+1] == '#')
	{
		if ((!X)&&(!Y)) update(state, ask(state), ask(state));
	}
	else if ((!X)&&(!Y)) 
	{
		aim = state; cor(aim, pX, 1); cor(aim, pY, 2);
		update(aim, ask(aim), ask(state));
	}
	else if ((!X)||(!Y))
	{
		aim = state; update(aim, ask(aim), ask(state));
		cor(aim, pX, 0); cor(aim, pY, 0);
		cor(aim, pX, Y); cor(aim, pY, X);
		update(aim, ask(aim), ask(state));
	}
	else if (X==2&&Y==1)
	{
		aim = state; 
		cor (aim, pX, 0); cor(aim, pY, 0);
		update(aim, ask(aim), ask(state));
	}
	else if (X==Y)
	{
		aim = state; memset(bct,0,sizeof(bct)); memset(mat,0,sizeof(mat));
		for (i = 1; i <= m+1; i++)
        {
			int z = get(state, i);
			if (z == 1) mat[++mat[0]] = i;
			else if (z== 2) bct[i] = mat[mat[0]], bct[mat[mat[0]--]] = i;
		}
		cor(aim, pX, 0); cor(aim, pY, 0);
		if (X==1) cor(aim, bct[pY], 1), update(aim, ask(aim), ask(state));
		if (X==2) cor(aim, bct[pX], 2), update(aim, ask(aim), ask(state));
	}
	else if (line == lastn && list == lastm-1)
	{
		aim = state; cor(aim, pX, 0); cor(aim, pY, 0);
		if (!aim) ans += f[!p][ask(state)];
	}
}

void origin()
{
	memset(c, sizeof(c), 0);
	memset(linke, 0, sizeof(linke));
	memset(point, 0, sizeof(point));
	memset(next,  0, sizeof(next));
	top = 0; ans =0; memset(f, 0, sizeof(f));
}

void work()
{
	int i, j;
	int aim = 0; cor(aim, 2, 1); cor(aim, m+1, 2);
	p = 1; que[p][head[1]=tail[1]=1] = aim; f[p][ask(aim)] = 1;
	for (i = 1; i <= n; i++)
	  for (j = 0; j <= m; j++)
	   {
	      if (i == lastn&& j == lastm) return;
		  p^=1;
		  memset(f[p], 0, sizeof(f[p]));
		  memset(step, 0, sizeof(step));
		  head[p] = 1;tail[p] = 0;
		  for (;head[!p]<=tail[!p];head[!p]++)
		    expand(que[!p][head[!p]], i, j);
	   }
}
int main()
{
	int i, j;
	//freopen("1739.in", "r", stdin);
	//freopen("1739.out", "w", stdout);
	for (;;)
	{
	  origin();
	  scanf("%d%d\n", &n, &m);
	  if ((!n)&&(!m)) return 0;
	  for (i = n; i >= 1; i--)
      {
		  for (j = 1; j <= m; j++)
		    scanf("%c", &c[i][j]);
		  scanf("\n");
	  }
	  for (i = 1; i <= n; i++)
	      for (j = 1; j <= m; j++)
	        if (c[i][j]=='.') lastn = i, lastm = j;
	  work();
	 // printf("%d\n", top);
	  if (c[1][1] == '#' || c[1][m] == '#') printf("0\n");
	  else printf("%I64d\n", ans);
	}
	return 0;
}


  zoj3256

上题 + 矩乘

每次先用按格转移的方式预处理出行与行之间的转移，然后用矩乘优化。

写的很丑很丑。。。。。。在zoj上tle了。。。。。。

# include <cstdlib>
# include <cstdio>
# include <cmath>
# include <cstring>
# include <ctime>

using namespace std;

typedef long long int64;

const int mo = 7777777, S = 580;
int tot, n, m, p;
int bct[30], mat[30], head[2], tail[2], que[2][S+10];
int top, next[S+10], linke[S+10], point[S+10]; 
int64 f[2][S*5], g[180][180], mtx[180][180], tmp[180][180];
bool step[S*5];

inline int get(int state, int p)
{
	return (state>>((p-1)<<1))&3;
}
inline void cor(int &state, int p, int alt)
{
	int pri = get(state, p);
	state ^= pri<<((p-1)<<1);
	state |= alt<<((p-1)<<1);
}
inline int link(int x, int y)
{
	++top; next[top] = linke[x]; linke[x] = top; point[top] = y;
	//if (top > 200) exit(0);
	return top;
}
inline int ask(int state)
{
	int ke,hs = state % 173;
	for (ke = linke[hs]; ke ; ke = next[ke])
	  if (point[ke] == state) break;
	return ke?ke:link(hs, state);
}
inline bool check(int state)
{
	int i, bt = 0, Z;
	for (i = 1; i <= n; i++)
	{
		Z = get(state, i);
		if (Z == 1) bt++;
		else if (Z == 2) bt--;
		if (bt<0) return false;
	}
	return bt?false:true; 
}
inline void update(int st, int x, int y)
{
	int Dx = ask(x);int Dy = ask(y);
	f[p][Dx] += f[!p][Dy];
	if (step[Dx]!=st) step[Dx] = st, que[p][++tail[p]] = x; 
}
void expand(int st, int state, int list)
{
	int i, aim, pX = list+1, pY = list+2, X = get(state, pX), Y = get(state, pY);
	
	if (list == n-1 && X == 1 && Y == 2)
	{
		aim = state; cor(aim, pX, 0); cor(aim, pY, 0);
		if (!aim) update(st, aim, state);
	}
	else if ((!X)&&(!Y))
	{
		aim = state; cor(aim, pX, 1); cor(aim, pY, 2);
		update(st, aim, state);
	}
	else if ((!X)||(!Y))
	{
		aim = state; update(st, aim, state);
		cor(aim, pX, Y); cor(aim, pY, X);
		update(st, aim, state);
	}
	else if (X == 2&& Y == 1)
	{
		aim = state;
		cor(aim, pX, 0); cor(aim, pY, 0);
		update(st, aim, state);
	}
	else if (X == Y)
	{
		aim = state; cor(aim, pX, 0); cor(aim, pY, 0);
		memset(bct, 0, sizeof(bct)); memset(mat, 0, sizeof(mat));
		for (i = 1; i <= n+1; i++)
		{
			int Z = get(state, i);
			if (Z == 1) mat[++mat[0]] = i;
			else if (Z == 2) bct[i] = mat[mat[0]], bct[mat[mat[0]--]] = i;
		}
		if (X == 1) cor(aim, bct[pY], 1), update(st, aim, state);
		if (X == 2) cor(aim, bct[pX], 2), update(st, aim, state);
	}
}
void work(int state)
{
    int i;
	p = 1;head[p] = tail[p] = 1; que[1][1] = state;  
	memset(f, 0, sizeof(f)); f[p][ask(state)] = 1;
    for (i = 0; i <  n; i++)
    {
		p ^= 1; head[p] = 1; tail[p] = 0;
		memset(f[p], 0, sizeof(f[p]));
		memset(step, false, sizeof(step));
		for (;head[!p]<= tail[!p];head[!p]++)
		  if (que[!p][head[!p]]!=0) expand(state,que[!p][head[!p]], i);
	}
	for (;head[p] <= tail[p];head[p]++)
	   if (get(que[p][head[p]], n+1)==0)
	     mtx[ask(state)][ask(que[p][head[p]]<<2)] += f[p][ask(que[p][head[p]])];
}
void dfs(int p, int state)
{
	if (p == 0) {if (check(state)&&(state!=0)) work(state<<2)/*, printf("%d\n", state)*/;	return;}
	dfs(p-1,  state<<2);
	dfs(p-1, (state<<2)+1);
	dfs(p-1, (state<<2)+2);
}
void dfsp(int p, int state)
{
	if (p == 0) 
	{
		 if (check(state)) 
		  ask(state<<2);
		return;
	};
	dfsp(p-1,  state<<2);
	dfsp(p-1, (state<<2)+1);
	dfsp(p-1, (state<<2)+2);
}
void mul(int64 c[180][180], int64 a[180][180], int64 b[180][180])
{
	int i, j, k;
	memset(tmp, 0, sizeof(tmp));
	for (i = 1; i <= tot; i++)
	  for (j = 1; j <= tot; j++)
	    for (k = 1; k <= tot; k++)
	      tmp[i][j] = (tmp[i][j] + a[i][k]*b[k][j]) % mo;
	for (i = 1; i <= tot; i++)
	  for (j = 1; j <= tot; j++)
	      c[i][j] = tmp[i][j]; 
}
void origin()
{
	top = 0; memset(next, 0, sizeof(next));
	memset(linke, 0, sizeof(linke));
	memset(point, 0, sizeof(point));
	memset(g, 0, sizeof(g));
	memset(mtx, 0, sizeof(mtx));
}
int main()
{
	int i, j;
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
	while (scanf("%d%d", &n, &m)!=EOF)
	{ 
	  origin();
	  dfsp(n,0);
	  tot = top;
	  dfs(n,0);
	  for (i = 1; i <= tot; i++) 
	    for (j = 1; j <= tot; j++)
	      g[i][j] = mtx[i][j];
	  for (m--; m > 0; m>>=1, mul(mtx, mtx, mtx))
	    if (m&1) mul(g, g, mtx);
       int aim = 0; cor(aim, 2, 1); cor(aim, n+1, 2);
 	   int64 ans = g[ask(aim)][ask(0)];
	  if (ans) printf("%I64d\n", ans);
	  else printf("Impossible\n");
    }
	return 0;
}


cjoilmd
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于连通性状态压缩的DP问题——状态压缩DP
m0_66252872的博客
05-05 251
🎁题目: 炮兵阵地 司令部的将军们打算在N×M的网格地图上部署他们的炮兵部队。 一个N×M 的地图由NN行M列组成，地图的每一格可能是山地（用H表示），也可能是平原（用P表示），如下图。 在每一格平原地形上最多可以布置一支炮兵部队（山地上不能够部署炮兵部队）；一支炮兵部队在地图上的攻击范围如图中黑色区域所示： 如果在地图中的灰色所标识的平原上部署一支炮兵部队，则图中的黑色的网格表示它能够攻击到的区域：沿横向左右各两格，沿纵向上下各两格。 图上其它白色网格均攻击不到。 从...
【动态规划】状态压缩动态规划
繁凡さん的博客
08-31 933
一、集合类状态压缩 A、 AcWing 91. 最短Hamilton路径 状压DP基础应用 #include<cstdio> #include<algorithm> #include<cstring> using namespace std; int f[1 << 20][20]; int w[20][20]; int n, m; int main(){ scanf("%d", &n); for(int i = 0; i <
【连通性状态压缩DP】URAL1519
氧化钠的博客
02-07 492
URAL1519（vjudge） 题意：给出一个n*m的矩阵，有的是空白格，有的是障碍格。你的任务是用一条回路来遍历整个矩阵的空白格，不能经过障碍格。统计这样的回路数量。题解： 这道题和hdu1693唯一的不同，就是它限定了只有一条回路（但却恶心了好多倍）。一条回路，即意味着每个插头属于同一个联通块。所以在hdu1693的基础上，我们还要确定每个插头的连通性。这里仅介绍编码复杂度小，耗时较多的方
基于连通性状态压缩的动态规划问题
weixin_34106122的博客
10-20 356
基于连通性状态压缩的动态规划问题 基于状态压缩的动态规划问题是一类以集合信息为状态且状态总数为指数级的特殊的动态规划问题．在状态压缩的基础上，有一类问题的状态中必须要记录若干个元素的连通情况，我们称这样的问题为基于连通性状态压缩的动态规划问题，本文着重对这类问题的解法及优化进行探讨和研究． 本文主要从动态规划的几个步骤——划分阶段，确立状态，状态转移以及...
动态规划之状态压缩专题
剑锋OI SharpSwordOI
11-27 1073
态压缩动态规划（简称状压dp）是另一类非常典型的动态规划，通常使用在NP问题的小规模求解中，虽然是指数级别的复杂度，但速度比搜索快，其思想非常值得借鉴。 为了更好的理解状压dp，首先介绍位运算相关的知识。 1.’&’符号，x&y，会将两个十进制数在二进制下进行与运算，然后返回其十进制下的值。例如3(11)&2(10)=2(10)。 2.’|’符号，x|y，会将两个十进制数在二进制下进行或运算，
2008_陈丹琦_基于连通性状态压缩的动态规划问题_Cdq
07-08
陈丹琦_基于连通性状态压缩的动态规划问题
算法文档无代码基于连通性状态压缩的动态规划问题
04-14
算法文档无代码基于连通性状态压缩的动态规划问题提取方式是百度网盘分享地址
基于连通性状态压缩的动态规划问题_Cdq.ppt
05-21
【基于连通性状态压缩的动态规划问题】是一种在解决特定类型问题时，结合连通性信息和动态规划策略的方法。动态规划通常用于优化多阶段决策过程，通过将大问题分解为子问题来求解。在本讲义中，湖南省雅礼中学的...
roosephu 考题之一： 三维偏序
cjoilmd的专栏
10-18 2340
roosephu的考题，水题倒还是水，难题难的无语。             三维偏序，本来是以前省队集训的时候遇到的东西，那时候是彻底被恶心到了，没写出来，而这一次仍旧被小小的恶心到了。             原题是给三个1~n的排列列，求三个排列的最长公共子序列。             转化成三维偏序是比较好想的，而主要问题是这个恶心的三维偏序必须做到nlog^2(n) 的复杂度。
【左偏树】 poj3016
cjoilmd的专栏
02-22 1727
ps： 难道我天生程序就写得丑么=。=！有一个算法在我手上变慢了(⊙o⊙)…           左偏树主要优点是支持堆合并，当然，它牺牲了树的平衡，牺牲了树的平衡使得左偏树仅仅对最值的操作比较方便，对其他值的操作往往要借助lazy标记。        左偏树并不极力维护树的平衡，而是以树的左偏为代价，保证从根节点一直往右走到达“外节点”的路径长度不超过logn,这样各种操作仍然保证了log
【ctsc2010 星际旅行】
cjoilmd的专栏
03-20 1524
题意很简单：    给定一棵树，问从根分别走到每个节点的最长路程，其中每个点给定lim，即最多从该点出发lim次，保证lim大于等于该点的度数。    特别“鸣谢”ldl在他的模拟题中出了这道题。    当题解讲这要用树形dp解网络流模型时，都被惊异了，完全没有想到网络流，也完全没有必要网络流，atm在考场上直接有树形dp AC之，考后hyc也自己YY出了另一种dp方法， 网络流对
【AC自动机复习】 noi2011阿狸的打字机
cjoilmd的专栏
02-21 1416
有些算法学了很久没有复习，今天重刷了两道后缀数组的题，然后想找到AC自动机的题目，毕竟以前也没写过几遍。        然后尴尬的发现去年noi的阿狸的打字机还没写，去年暑假因为不懂AC自动机，没有去动它，后来就一直忘记了=。=！          不说废话了。          将所有输出的单词存入AC自动机，由于题目特殊，建起来比一般的AC自动机要简单。        考虑打裸，对
因数小于16的正整数拆分方案：一个有趣的dp
cjoilmd的专栏
11-01 925
“灰常灰常”有趣的dp；         给定一个高精数，将这个高精数分解成若干个不大于16的因数的幂的积，求方案数；         也就是把s分解为：a1^K1 * a2^k2 * a3^k3......,其中a            由于给出数字实在太大了，考场上以为是个矩乘或母函数（TAT）......          这道题的dp也算隐藏的比较深；
poj3613 奇特的矩阵乘法
cjoilmd的专栏
08-19 787
题目大意很简单：给出一个无向图，求两个点之间的经过k条边的最短路（边可以重复经过）       最多只有100条边，但是k高达10^6。       可以用 类bellman ford的方法，将边迭代n次        （与bellman ford不同的是，每一次迭代都必须选边，不过spfa无法保证每一条边都取）；       这样的复杂的事o（ne）的 ，已经有10^8，而且中间
Java集合——Array、ArrayList、LinkedList
最新发布
A21281005_的博客
07-25 788
添加元素到ArrayList时，ArrayList会判断是否达到了最大大小Integer.MAX_VALUE，若达到则不再扩容，否则扩容。：提供了额外的方法，如addFirst()，addLast()，removeFirst(),removeLast()增删元素：在末尾加元素很快，但在其他地方操作可能需要移动后续元素，时间复杂度O(n)增删元素：在列表任意位置增删元素都很快，这只需要改变几个引用指针，是O(1)复杂度。使用场景：需要频繁访问元素，且增删操作主要在列表末尾进行，选择ArrayList。
Arraylist与LinkedList的区别
尚未佩妥剑 转眼便江湖
07-25 522
概念概念。
连通性状态压缩动态规划：解法与优化探讨
动态规划是一种强大的算法设计技术，特别适用于解决涉及子问题重叠和最优化的计算问题。...通过实例演示和理论分析，该论文为理解并解决这类基于连通性状态压缩的动态规划问题提供了有价值的见解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值