到这里 \(A\) 了这题， \(Splay\) 就能算入好门了吧。

今天是个特殊的日子， \(NOI\) 出成绩， 大佬 \(Cu\)

不敢相信这一切这么快， 一下子机房就只剩我和 \(zrs\) 了。

忽然回想起之前大佬的一幕幕， 有一丝惆怅

真的不知道该怎么安慰dalao。。。

不过上天不会忽视那些默默努力的人的对吧

不想被说做作， 但是如果dalao能看到这篇博客的话，

大佬， 高考加油啊

为什么在这里写这些呢？ \(Splay\) 其实是大佬领进门的， 学习的也是大佬的板子， 大佬很久以前的Q名还是 \(Splay\) 加上一颗椰子树。。放心吧大佬， 我会继续努力的

P2042 [NOI2005]维护数列

题目描述

请写一个程序，要求维护一个数列，支持以下 6 种操作：（请注意，格式栏 中的下划线‘ _ ’表示实际输入文件中的空格）

输入输出格式

输入格式：

输入文件的第 1 行包含两个数 N 和 M，N 表示初始时数列中数的个数，M 表示要进行的操作数目。 第 2 行包含 N 个数字，描述初始时的数列。 以下 M 行，每行一条命令，格式参见问题描述中的表格

输出格式：

对于输入数据中的 GET-SUM 和 MAX-SUM 操作，向输出文件依次打印结 果，每个答案（数字）占一行。

\(Splay\) 的挺全面的基本操作： 插入、 删除、 修改、 翻转、 求和、 求最大子列

因为插入的数可能会很多， 题目又保证在任意时刻序列内元素的数量 \(<= 500 000\) 所以隐藏一个要求： 让我们回收节点编号

自然地， 有插入操作， 所以我们记得加入哨兵节点

\(Ins\) 插入

这里和原来的插入不同， 是一次插入一段序列， 容易想到现在主树外新建一棵树， 用树根代表整个序列， 像原来一样插入即可。

但是值得注意的是， 若是用原来单个元素插入的方法建树的话， 每次插入的复杂度可以达到 \(O(n\log n)\) ，加上 \(Splay\) 算法本来就常数较大， 承受不起这样的方法， 于是我们引入一种类似线段树建树的递归建树。 和线段树有所不同的是，每个点代表自己本身的属性和子区间的属性， 所以建完的 \(Splay\) 树的大小为 \(N\) ， 复杂度是线性的。

注意引用以保证节点编号的正确传递

最后将主树的 \(x, x + 1\) 分别 \(Splay\) 到根和根的右子节点， 右子节点的左子节点就是插入的位置， 把新树的根接上去即可

  1. int ori[maxn];
  2. void build(int &id, int F, int l, int r){//注意引用
  3. 	if(l > r)return ;//因为下面的-1和+1，可能会出现区间错位的情况
  4. 	int mid = (l + r) >> 1;
  5. 	id = New(F, ori[mid]);
  6. 	if(l == r)return ;
  7. 	build(ch[id][0], id, l, mid - 1);//注意这里和线段树不一样，子区间是没有mid的
  8. 	build(ch[id][1], id, mid + 1, r);
  9. 	pushup(id);
  10. 	}
  11. void Ins(){
  12. 	int x = RD(), tot = RD();
  13. 	for(int i = 1;i <= tot;i++)ori[i] = RD();
  14. 	int rt;build(rt, 0, 1, tot);
  15. 	x = find(root, x + 1);//注意哨兵节点的加一
  16. 	splay(x, 0, root);
  17. 	x = find(root, size[ch[root][0]] + 2);
  18. 	splay(x, root, root);
  19. 	ch[ch[root][1]][0] = rt;
  20. 	fa[rt] = ch[root][1];
  21. 	pushup(ch[root][1]), pushup(root);
  22. 	}

\(Del\ \& \ New\)

删除及节点回收

同样和之前的单个删除不一样， 这是删除一段区间 \([L, R]\)。 容易想到我们应该将 \(L - 1, R + 1\)分别 \(Splay\) 到根和右子节点， 右子节点的左子树即为操作树

直接删除很简单， 只需要将根的右子节点的左子节点设为 \(0\) 即可， 但是这题要求我们空间回收， 所以我们用 \(dfs\) 遍历摘下来的子树上的节点， 将节点加入一个队列中即可， 下次新建节点可以直接在此队列中取出编号重新使用

对于新建节点的 \(New\) 函数， 因为这个点之前可能被使用过， 所谓我们需要将其所有属性全部初始化， 再使用

  1. int root, tot;
  2. queue<int>Q;
  3. int New(int F, int v){//包办一切编号重启，方便得一批
  4. 	int now;
  5. 	if(Q.empty())now = ++tot;
  6. 	else now = Q.front(), Q.pop();
  7. 	fa[now] = F; ch[now][0] = ch[now][1] = 0;
  8. 	val[now] = v;
  9. 	size[now] = 1; lazy[now] = -INF;rev[now] = 0;
  10. 	sum[now] = maxx[now] = v;
  11. 	lmax[now] = rmax[now] = max(0, v);
  12. 	return now;
  13. 	}
  14. void dfs_del(int id){//深搜回收编号
  15. 	Q.push(id);
  16. 	if(ch[id][0])dfs_del(ch[id][0]);
  17. 	if(ch[id][1])dfs_del(ch[id][1]);
  18. 	}
  19. void Del(){
  20. 	int x = RD(), tot = RD();
  21. 	x = find(root, x);//哨兵节点 + 1 - 1
  22. 	splay(x, 0, root);
  23. 	x = find(root, size[ch[root][0]] + tot + 2);
  24. 	splay(x, root, root);
  25. 	int del = ch[ch[root][1]][0];
  26. 	dfs_del(del);
  27. 	ch[ch[root][1]][0] = 0;
  28. 	pushup(ch[root][1]), pushup(root);
  29. 	}

\(Change\ \&\ Reverse\)

区间修改及区间翻转

和 \(Splay\) 模板题的翻转差不多， 都是套路， 将 \(L - 1, R + 1\) \(Splay\) 到根和根的右子节点， 根的右子节点的左子树即为修改区间， 打个懒标记。 注意这里的懒标记是给儿子使用的。还有就是修改与翻转的优先级的关系： 只要全部染色了翻不翻转都无所谓， 故修改懒标记的优先级修改染色 \(>\) 翻转，所以我们可以在下推染色标记时将翻转懒标记清空； 同理在翻转时， 当此区间有染色标记的时候， 我们也不需要翻转了

注意后面需要维护区间最大子段和， 需要维护一个区间的 取左端最大值 、取右端最大值 、 本区间子段最大值（参见小白逛公园）， 从而更新。

所以我们区间翻转注意要先交换子区间的取左右端最大值， 再交换两个区间

  1. void pushup(int id){
  2. 	int lid = ch[id][0], rid = ch[id][1];
  3. 	size[id] = size[lid] + size[rid] + 1;
  4. 	sum[id] = sum[lid] + sum[rid] + val[id];
  5. 	lmax[id] = max(lmax[lid], sum[lid] + val[id] + lmax[rid]);
  6. 	rmax[id] = max(rmax[rid], sum[rid] + val[id] + rmax[lid]);
  7. 	int MAX = max(maxx[lid], maxx[rid]);
  8. 	maxx[id] = max(MAX, rmax[lid] + val[id] + lmax[rid]);
  9. 	}
  10. void pushdown(int id){//像线段树一样标记给儿子用
  11. 	int lid = ch[id][0], rid = ch[id][1];
  12. 	if(lazy[id] != -INF){
  13. 		val[lid] = val[rid] = lazy[id];
  14. 		lazy[lid] = lazy[rid] = lazy[id];
  15. 		sum[lid] = size[lid] * lazy[id];
  16. 		sum[rid] = size[rid] * lazy[id];
  17. 		if(lazy[id] >= 0){
  18. 			maxx[lid] = lmax[lid] = rmax[lid] = sum[lid];
  19. 			maxx[rid] = lmax[rid] = rmax[rid] = sum[rid];
  20. 			}
  21. 		else{
  22. 			lmax[lid] = rmax[lid] = 0, maxx[lid] = lazy[id];
  23. 			lmax[rid] = rmax[rid] = 0; maxx[rid] = lazy[id];
  24. 			}
  25. 		lazy[id] = -INF; rev[id] = 0;
  26. 		}
  27. 	if(rev[id]){
  28. 		rev[id] = 0;rev[lid] ^= 1, rev[rid] ^= 1;
  29. 		swap(lmax[lid], rmax[lid]), swap(lmax[rid], rmax[rid]);
  30. 		swap(ch[lid][0], ch[lid][1]);
  31. 		swap(ch[rid][0], ch[rid][1]);
  32. 		}
  33. 	}
  34. void Change(){
  35. 	int x = RD(), tot = RD(), c = RD();
  36. 	x = find(root, x);
  37. 	splay(x, 0, root);
  38. 	x = find(root, size[ch[root][0]] + tot + 2);
  39. 	splay(x, root, root);
  40. 	int change = ch[ch[root][1]][0];
  41. 	val[change] = lazy[change] = c;
  42. 	sum[change] = c * size[change];
  43. 	if(c >= 0)maxx[change] = lmax[change] = rmax[change] = sum[change];
  44. 	else maxx[change] = c, lmax[change] = rmax[change] = 0;
  45. 	pushup(ch[root][1]), pushup(root);
  46. 	}
  47. void Reverse(){
  48. 	int x = RD(), tot = RD();
  49. 	x = find(root, x);
  50. 	splay(x, 0, root);
  51. 	x = find(root, size[ch[root][0]] + tot + 2);
  52. 	splay(x, root, root);
  53. 	int change = ch[ch[root][1]][0];
  54. 	if(lazy[change] == -INF){
  55. 		rev[change] ^= 1;
  56. 		swap(lmax[change], rmax[change]);
  57. 		swap(ch[change][0], ch[change][1]);
  58. 		pushup(ch[root][1]), pushup(root);
  59. 		}
  60. 	}

\(Sum\ \&\ MSum\)

区间求和及最大子段和

\(Sum\) 都是套路， 不再赘述， \(MSum\) 更简单， 只要你前面维护得正确， 输出根的最大子段和的值即可

  1. void Sum(){
  2. 	int x = RD(), tot = RD();
  3. 	x = find(root, x);
  4. 	splay(x, 0, root);
  5. 	x = find(root, size[ch[root][0]] + tot + 2);
  6. 	splay(x, root, root);
  7. 	printf("%d\n", sum[ch[ch[root][1]][0]]);
  8. 	}
  9. void MSum(){
  10. 	printf("%d\n", maxx[root]);
  11. 	}

至此， \(Splay\) 的大部分区间操作都已经被提到和总结了。谢谢大佬，谢谢

Code

  1. #include<iostream>
  2. #include<cstdio>
  3. #include<queue>
  4. #include<cstring>
  5. #include<algorithm>
  6. #define LL long long
  7. using namespace std;
  8. int RD(){
  9. 	int flag = 1, out = 0;char c = getchar();
  10. 	while(c < '0' || c > '9'){if(c == '-')flag = -1;c = getchar();}
  11. 	while(c >= '0' && c <= '9'){out = out * 10 + c - '0';c = getchar();}
  12. 	return flag * out;
  13. 	}
  14. const int maxn = 1000019, INF = 1e9 + 19;
  15. int num, na;
  16. //splay, 需支持插入删除修改翻转求和最大子列
  17. int ch[maxn][2], fa[maxn];
  18. int val[maxn];
  19. int size[maxn], lazy[maxn], rev[maxn];
  20. int sum[maxn], maxx[maxn], lmax[maxn], rmax[maxn];
  21. int root, tot;
  22. queue<int>Q;
  23. int New(int F, int v){//包办一切编号重启，方便得一批
  24. 	int now;
  25. 	if(Q.empty())now = ++tot;
  26. 	else now = Q.front(), Q.pop();
  27. 	fa[now] = F; ch[now][0] = ch[now][1] = 0;
  28. 	val[now] = v;
  29. 	size[now] = 1; lazy[now] = -INF;rev[now] = 0;
  30. 	sum[now] = maxx[now] = v;
  31. 	lmax[now] = rmax[now] = max(0, v);
  32. 	return now;
  33. 	}
  34. void pushup(int id){
  35. 	int lid = ch[id][0], rid = ch[id][1];
  36. 	size[id] = size[lid] + size[rid] + 1;
  37. 	sum[id] = sum[lid] + sum[rid] + val[id];
  38. 	lmax[id] = max(lmax[lid], sum[lid] + val[id] + lmax[rid]);
  39. 	rmax[id] = max(rmax[rid], sum[rid] + val[id] + rmax[lid]);
  40. 	int MAX = max(maxx[lid], maxx[rid]);
  41. 	maxx[id] = max(MAX, rmax[lid] + val[id] + lmax[rid]);
  42. 	}
  43. void pushdown(int id){//像线段树一样标记给儿子用
  44. 	int lid = ch[id][0], rid = ch[id][1];
  45. 	if(lazy[id] != -INF){
  46. 		val[lid] = val[rid] = lazy[id];
  47. 		lazy[lid] = lazy[rid] = lazy[id];
  48. 		sum[lid] = size[lid] * lazy[id];
  49. 		sum[rid] = size[rid] * lazy[id];
  50. 		if(lazy[id] >= 0){
  51. 			maxx[lid] = lmax[lid] = rmax[lid] = sum[lid];
  52. 			maxx[rid] = lmax[rid] = rmax[rid] = sum[rid];
  53. 			}
  54. 		else{
  55. 			lmax[lid] = rmax[lid] = 0, maxx[lid] = lazy[id];
  56. 			lmax[rid] = rmax[rid] = 0; maxx[rid] = lazy[id];
  57. 			}
  58. 		lazy[id] = -INF; rev[id] = 0;
  59. 		}
  60. 	if(rev[id]){
  61. 		rev[id] = 0;rev[lid] ^= 1, rev[rid] ^= 1;
  62. 		swap(lmax[lid], rmax[lid]), swap(lmax[rid], rmax[rid]);
  63. 		swap(ch[lid][0], ch[lid][1]);
  64. 		swap(ch[rid][0], ch[rid][1]);
  65. 		}
  66. 	}
  67. bool lor(int id){return ch[fa[id]][0] == id ? 0 : 1;}
  68. void spin(int id){
  69. 	int F = fa[id], d = lor(id);
  70. 	fa[id] = fa[F];
  71. 	if(fa[F])ch[fa[F]][lor(F)] = id;
  72. 	fa[F] = id;
  73. 	ch[F][d] = ch[id][d ^ 1];
  74. 	if(ch[id][d ^ 1])fa[ch[id][d ^ 1]] = F;
  75. 	ch[id][d ^ 1] = F;
  76. 	pushup(F), pushup(id);
  77. 	}
  78. void splay(int id, int goal, int &rt){//rt为splay的主根
  79. 	while(fa[id] != goal){
  80. 		int F = fa[id];
  81. 		pushdown(fa[F]), pushdown(F), pushup(id);
  82. 		if(fa[F] == goal)spin(id);
  83. 		else if(lor(id) ^ lor(F))spin(id), spin(id);
  84. 		else spin(F), spin(id);
  85. 		}
  86. 	if(!goal)rt = id;
  87. 	}
  88. int find(int id, int rank){
  89. 	pushdown(id);
  90. 	if(!id)return INF;
  91. 	if(size[ch[id][0]] >= rank)return find(ch[id][0], rank);
  92. 	else if(size[ch[id][0]] + 1 == rank)return id;
  93. 	else return find(ch[id][1], rank - size[ch[id][0]] - 1);
  94. 	}
  95. void insert(int id, int v, int &rt){
  96. 	ch[id][1] = New(id, v);
  97. 	splay(ch[id][1], 0, rt);
  98. 	}
  99. int ori[maxn];
  100. void build(int &id, int F, int l, int r){//注意引用
  101. 	if(l > r)return ;//因为下面的-1和+1，可能会出现区间错位的情况
  102. 	int mid = (l + r) >> 1;
  103. 	id = New(F, ori[mid]);
  104. 	if(l == r)return ;
  105. 	build(ch[id][0], id, l, mid - 1);//注意这里和线段树不一样，子区间是没有mid的
  106. 	build(ch[id][1], id, mid + 1, r);
  107. 	pushup(id);
  108. 	}
  109. void Ins(){
  110. 	int x = RD(), tot = RD();
  111. 	for(int i = 1;i <= tot;i++)ori[i] = RD();
  112. 	int rt;build(rt, 0, 1, tot);
  113. 	x = find(root, x + 1);//注意哨兵节点的加一
  114. 	splay(x, 0, root);
  115. 	x = find(root, size[ch[root][0]] + 2);
  116. 	splay(x, root, root);
  117. 	ch[ch[root][1]][0] = rt;
  118. 	fa[rt] = ch[root][1];
  119. 	pushup(ch[root][1]), pushup(root);
  120. 	}
  121. void dfs_del(int id){//深搜回收编号
  122. 	Q.push(id);
  123. 	if(ch[id][0])dfs_del(ch[id][0]);
  124. 	if(ch[id][1])dfs_del(ch[id][1]);
  125. 	}
  126. void Del(){
  127. 	int x = RD(), tot = RD();
  128. 	x = find(root, x);//哨兵节点 + 1 - 1
  129. 	splay(x, 0, root);
  130. 	x = find(root, size[ch[root][0]] + tot + 2);
  131. 	splay(x, root, root);
  132. 	int del = ch[ch[root][1]][0];
  133. 	dfs_del(del);
  134. 	ch[ch[root][1]][0] = 0;
  135. 	pushup(ch[root][1]), pushup(root);
  136. 	}
  137. void Change(){
  138. 	int x = RD(), tot = RD(), c = RD();
  139. 	x = find(root, x);
  140. 	splay(x, 0, root);
  141. 	x = find(root, size[ch[root][0]] + tot + 2);
  142. 	splay(x, root, root);
  143. 	int change = ch[ch[root][1]][0];
  144. 	val[change] = lazy[change] = c;
  145. 	sum[change] = c * size[change];
  146. 	if(c >= 0)maxx[change] = lmax[change] = rmax[change] = sum[change];
  147. 	else maxx[change] = c, lmax[change] = rmax[change] = 0;
  148. 	pushup(ch[root][1]), pushup(root);
  149. 	}
  150. void Reverse(){
  151. 	int x = RD(), tot = RD();
  152. 	x = find(root, x);
  153. 	splay(x, 0, root);
  154. 	x = find(root, size[ch[root][0]] + tot + 2);
  155. 	splay(x, root, root);
  156. 	int change = ch[ch[root][1]][0];
  157. 	if(lazy[change] == -INF){
  158. 		rev[change] ^= 1;
  159. 		swap(lmax[change], rmax[change]);
  160. 		swap(ch[change][0], ch[change][1]);
  161. 		pushup(ch[root][1]), pushup(root);
  162. 		}
  163. 	}
  164. void Sum(){
  165. 	int x = RD(), tot = RD();
  166. 	x = find(root, x);
  167. 	splay(x, 0, root);
  168. 	x = find(root, size[ch[root][0]] + tot + 2);
  169. 	splay(x, root, root);
  170. 	printf("%d\n", sum[ch[ch[root][1]][0]]);
  171. 	}
  172. void MSum(){
  173. 	printf("%d\n", maxx[root]);
  174. 	}
  175. int main(){
  176. 	num = RD(), na = RD();
  177. 	root = New(0, -INF);
  178. 	for(int i = 1;i <= num;i++)insert(root, RD(), root);
  179. 	insert(root, -INF, root);//初始化
  180. 	char cmd[19];
  181. 	for(int i = 1;i <= na;i++){
  182. 		cin>>cmd;
  183. 		if(cmd[2] == 'S')Ins();
  184. 		else if(cmd[2] == 'L')Del();
  185. 		else if(cmd[2] == 'K')Change();
  186. 		else if(cmd[2] == 'V')Reverse();
  187. 		else if(cmd[2] == 'T')Sum();
  188. 		else MSum();
  189. 		}
  190. 	return 0;
  191. 	}

P2042 [NOI2005]维护数列 && Splay区间操作（四）的更多相关文章

  1. 洛谷 P2042 [NOI2005]维护数列-Splay(插入 删除 修改 翻转 求和 最大的子序列)

    因为要讲座,随便写一下,等讲完有时间好好写一篇splay的博客. 先直接上题目然后贴代码,具体讲解都写代码里了. 参考的博客等的链接都贴代码里了,有空再好好写. P2042 [NOI2005]维护数列 ...

  2. P2042 [NOI2005]维护数列[splay或非旋treap·毒瘤题]

    P2042 [NOI2005]维护数列 数列区间和,最大子列和(必须不为空),支持翻转.修改值.插入删除. 练码力的题,很毒瘤.个人因为太菜了,对splay极其生疏,犯了大量错误,在此记录,望以后一定 ...

  3. BZOJ 1500 Luogu P2042 [NOI2005] 维护数列 (Splay)

    手动博客搬家: 本文发表于20180825 00:34:49, 原地址https://blog.csdn.net/suncongbo/article/details/82027387 题目链接: (l ...

  4. [bzoj1500][NOI2005 维修数列] (splay区间操作)

    Description Input 输入的第1 行包含两个数N 和M(M ≤20 000),N 表示初始时数列中数的个数,M表示要进行的操作数目. 第2行包含N个数字,描述初始时的数列. 以下M行,每 ...

  5. Luogu P2042 [NOI2005]维护数列(平衡树)

    P2042 [NOI2005]维护数列 题意 题目描述 请写一个程序,要求维护一个数列,支持以下\(6\)种操作:(请注意,格式栏中的下划线'_'表示实际输入文件中的空格) 输入输出格式 输入格式: ...

  6. [NOI2005]维护数列（区间splay）

    [NOI2005]维护数列(luogu) 打这玩意儿真是要了我的老命 Description 请写一个程序,要求维护一个数列,支持以下 6 种操作:(请注意,格式栏 中的下划线‘ _ ’表示实际输入文 ...

  7. BZOJ1500: [NOI2005]维修数列 [splay序列操作]【学习笔记】

    以前写过这道题了,但我把以前的内容删掉了,因为现在感觉没法看 重写! 题意: 维护一个数列,支持插入一段数,删除一段数,修改一段数,翻转一段数,查询区间和,区间最大子序列 splay序列操作裸题 需要 ...

  8. NOI2005 维护数列(splay)

    学了半天平衡树,选择了一道题来写一写,发现题目是裸的splay模板,但是还是写不好,这个的精髓之处在于在数列的某一个位置加入一个数列,类似于treap里面的merge,然后还学到了题解里面的的回收空间 ...

  9. Luogu P2042 [NOI2005]维护数列

    题目描述 请写一个程序,要求维护一个数列,支持以下 6 种操作:(请注意,格式栏 中的下划线' _ '表示实际输入文件中的空格) 输入输出格式 输入格式: 输入文件的第 1 行包含两个数 N 和 M, ...

随机推荐

  1. tcp/ip客户端与服务器

    单击“发送数据”把数据发送到指定IP地址的指定端口号 using System; using System.Collections.Generic; using System.ComponentMod ...

  2. spring冲刺第八天

    昨天使人物成功的在地图上运动,并设计炸弹爆炸效果. 今天使炸弹可以炸死人物并可以炸没砖块,并试着将小怪加入地图. 遇到的问题:现在还没有将小怪加入地图,各个模块的整合是比较麻烦的,我还要在这方面下点功 ...

  3. The Begining

    学习记录之旅,就此开始.软件工程,Java神马的统统到我碗里来.

  4. NetFPGA-SUME下reference_nic测试

    Reference_nic Reference_nic是NetFPGA-SUME中提供的一个参考Demo,本文主要介绍如何构建并在SUME上运行reference_nic. GIT源 git clon ...

  5. 1001 A+B

    代码链接 PDF链接 首先要说的是这道题的难点是如何把数字输出加入逗号,毕竟数据范围并没有超过Long.当然这个难点也不是问题,将数字转为字符串,C中就有这样的函数,然后再用 %3==0 这样来控制输 ...

  6. POJ 1185 炮兵阵地 状压dp

    题目链接: http://poj.org/problem?id=1185 炮兵阵地 Time Limit: 2000MS Memory Limit: 65536K 问题描述 司令部的将军们打算在N*M ...

  7. 第三周作业（一）VS安装及单元测试练习

    第三周作业(一) 需求:练习教科书第22~25页单元测试练习,要求自行安装Visual Studio开发平台,版本至少在2010以上,要求把程序安装过程和练习过程写到博客上,越详细越好,要图文并茂,没 ...

  8. profibus 的DPV0 和DPV1

    DP的功能经过扩展,一共有3个版本:DP-V0,DP-V1和DP-V2.有的用户手册将DP-V1简写为DPV1. 1.基本功能(DP-V0) (1)总线访问方法:各主站之间为令牌传送,主站与从站间为主 ...

  9. 如何查看Maven项目的jar包依赖

    问题 十年以前写java项目总会干这么一个事情: 调包. java项目往往依赖了很多第三方jar包,而这些jar包又有他自己依赖的第三方jar包,从而就能形成一个依赖树. 而程序运行要把这些所有的依赖 ...

  10. 软工网络15团队作业8——Beta阶段敏捷冲刺（day1）

    第 1 篇 Scrum 冲刺博客 1. 介绍小组新加入的成员,Ta担任的角色 --给出让ta担当此角色的理由 小组新加入的成员:3085叶金蕾 担任的角色:测试/用户体验/开发 理由:根据小组讨论以及 ...