B.Mayor’s posters

POJ2528
题目大意：

D.Count Color

POJ2777
题目大意：长为

L

(

L

≤

1

0

5

)

L( L\leq10^5)

L(L≤105)的序列，每个点上可以有

T

(

T

≤

30

)

T(T\leq30)

T(T≤30)种颜色以供染色（整个序列最开始都为颜色1），

O

(

O

≤

1

0

5

)

O(O\leq10^5)

O(O≤105)次操作：

C

C

C

a

a

a

b

b

b

c

c

c：

[

a

,

b

]

[a,b]

[a,b]染上颜色

c

c

c

P

P

P

a

a

a

b

b

b：查询

[

a

,

b

]

[a,b]

[a,b]上共有几种颜色
思路：因为

T

T

T很小，所以我们可以把颜色集合进行状态压缩，

p

u

s

h

u

p

pushup

pushup的时候直接取两个儿子的并即可，懒标记直接设为仅有对应颜色的集合即可。复杂度

O

(

(

L

+

O

)

l

o

g

L

)

O((L+O)logL)

O((L+O)logL)。此外注意本题

a

a

a可能大于

b

b

b。
代码：

  1. #include<bits/stdc++.h>
  2. #include<unordered_map>
  3. #include<unordered_set>
  4. using namespace std;
  5. typedef long long LL;
  6. typedef unsigned long long ULL;
  7. typedef pair<LL, int> PII;
  8. //#define int LL
  9. #define lc p*2+1
  10. #define rc p*2+2
  11. #define endl '\n'
  12. #define inf 0x3f3f3f3f
  13. #define INF 0x3f3f3f3f3f3f3f3f
  14. #define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
  15. #pragma warning(disable :4996)
  16. const double eps = 1e-8;
  17. const LL mod = 1000000007;
  18. const LL MOD = 998244353;
  19. const int maxn = 100010;
  21. struct node {
  22. 	int l, r, dat, lazy;
  23. };
  25. node tr[maxn * 4];
  27. void build(int p, int l, int r)
  28. {
  29. 	tr[p].l = l, tr[p].r = r, tr[p].lazy = 0;
  30. 	if (l + 1 == r)
  31. 	{
  32. 		tr[p].dat = 1;
  33. 		return;
  34. 	}
  35. 	int mid = (l + r) / 2;
  36. 	build(lc, l, mid), build(rc, mid, r);
  37. 	tr[p].dat = tr[lc].dat | tr[rc].dat;
  38. }
  40. void pushdown(int p)
  41. {
  42. 	if (tr[p].lazy)
  43. 	{
  44. 		tr[lc].dat = tr[rc].dat = tr[lc].lazy = tr[rc].lazy = tr[p].lazy;
  45. 		tr[p].lazy = 0;
  46. 	}
  47. }
  49. void modify(int p, int l, int r, int d)
  50. {
  51. 	if (tr[p].l >= l && tr[p].r <= r)
  52. 	{
  53. 		tr[p].dat = tr[p].lazy = 1 << d;
  54. 		return;
  55. 	}
  56. 	pushdown(p);
  57. 	int mid = (tr[p].l + tr[p].r) / 2;
  58. 	if (l < mid)
  59. 		modify(lc, l, r, d);
  60. 	if (r > mid)
  61. 		modify(rc, l, r, d);
  62. 	tr[p].dat = tr[lc].dat | tr[rc].dat;
  63. }
  65. int query(int p, int l, int r)
  66. {
  67. 	if(tr[p].l >= l && tr[p].r <= r)
  68. 		return tr[p].dat;
  69. 	pushdown(p);
  70. 	int mid = (tr[p].l + tr[p].r) / 2;
  71. 	if (r <= mid)
  72. 		return query(lc, l, r);
  73. 	if (l >= mid)
  74. 		return query(rc, l, r);
  75. 	return query(lc, l, mid) | query(rc, mid, r);
  76. }
  78. int L, T, O;
  80. void solve()
  81. {
  82. 	build(0, 1, L + 1);
  83. 	char t;
  84. 	int a, b, c;
  85. 	for (int i = 1; i <= O; i++)
  86. 	{
  87. 		cin >> t;
  88. 		if (t == 'C')
  89. 		{
  90. 			cin >> a >> b >> c;
  91. 			int l = min(a, b), r = max(a, b);
  92. 			modify(0, l, r + 1, c - 1);
  93. 		}
  94. 		else
  95. 		{
  96. 			cin >> a >> b;
  97. 			int l = min(a, b), r = max(a, b);
  98. 			int num = query(0, l, r + 1), ans = 0;
  99. 			for (int i = 0; i < T; i++)
  100. 				ans += (num >> i) & 1;
  101. 			cout << ans << endl;
  102. 		}
  103. 	}
  104. }
  106. int main()
  107. {
  108. 	IOS;
  109. 	cin >> L >> T >> O;
  110. 	solve();
  112. 	return 0;
  113. }
E.Who Gets the Most Candies?

POJ2886
题目大意：

N

N

N个人围一圈，每个人有

A

[

i

]

A[i]

A[i]，表示这个人沿顺时针

(

A

[

i

]

>

0

)

(A[i]>0)

(A[i]>0)或逆时针

(

A

[

i

]

<

0

)

(A[i]<0)

(A[i]<0)方向数的第

∣

A

[

i

]

∣

|A[i]|

∣A[i]∣个人是下一个要退出的，每次游戏从第

K

K

K个人开始，退出的次序

r

n

k

rnk

rnk的约束个数就是获得的糖果数，问谁获得糖果最多，有多个则输出先退出的。

思路：

i

i

i以内的约数最多的最小数字可以用倍数法

O

(

N

l

o

g

N

)

O(NlogN)

O(NlogN)预处理出来，之后对于每轮游戏直接模拟即可，用

B

I

T

BIT

BIT来维护一下各个位置上的人有没有退出，在

B

I

T

BIT

BIT上二分可以求得剩下的人中相对排名对应的原始位置。

代码：

  1. #include<iostream>
  2. #include<string>
  3. #include<stack>
  4. #include<queue>
  5. #include<vector>
  6. #include<algorithm>
  7. #include<cstring>
  8. #include<cmath>
  9. #include<map>
  10. #include<set>
  11. #include<utility>
  12. #include<cstdio>
  13. using namespace std;
  14. typedef long long LL;
  15. typedef unsigned long long ULL;
  16. typedef pair<int, int> PII;
  17. //#define int LL
  18. #define endl '\n'
  19. #define inf 0x3f3f3f3f
  20. #define INF 0x3f3f3f3f3f3f3f3f
  21. #define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
  22. #pragma warning(disable :4996)
  23. const double eps = 1e-8;
  24. const LL mod = 1000000007;
  25. const LL MOD = 998244353;
  26. const int maxn = (1 << 19) + 10;
  28. int cnt[maxn], S[maxn];
  29. int N, K;
  30. string name[maxn];
  31. int num[maxn], dat[maxn], n;
  33. void add(int i, int x)
  34. {
  35. 	while (i <= (1 << 19))
  36. 	{
  37. 		dat[i] += x;
  38. 		i += i & (-i);
  39. 	}
  40. }
  42. int sum(int i)
  43. {
  44. 	int ans = 0;
  45. 	while (i > 0)
  46. 	{
  47. 		ans += dat[i];
  48. 		i -= i & (-i);
  49. 	}
  51. 	return ans;
  52. }
  54. int getpos(int rk)
  55. {
  56. 	int k = 0, s = 0;
  57. 	for (int i = 18; i >= 0; i--)
  58. 	{
  59. 		int t = k + (1 << i);
  60. 		if (s + dat[t] < rk)
  61. 		{
  62. 			k = t;
  63. 			s += dat[t];
  64. 		}
  65. 	}
  67. 	return k + 1;
  68. }
  70. void init()
  71. {
  72. 	for (int i = 1; i <= 5e5; i++)
  73. 	{
  74. 		for (int j = i; j <= 5e5; j += i)
  75. 			cnt[j]++;
  76. 	}
  77. 	for (int i = 1; i <= 5e5; i++)
  78. 	{
  79. 		if (cnt[i] > cnt[S[i - 1]])
  80. 			S[i] = i;
  81. 		else
  82. 			S[i] = S[i - 1];
  83. 	}
  84. }
  86. void solve()
  87. {
  88. 	string ans1;
  89. 	int ord = 1, lst = N - 1, ans2 = cnt[S[N]], rnk = K;
  90. 	int pos = getpos(rnk), start;
  91. 	while (true)
  92. 	{
  93. 		int A = num[pos];
  94. 		ans1 = name[pos];
  95. 		if (ord == S[N])
  96. 			break;
  97. 		add(pos, -1);
  98. 		if (A > 0)
  99. 		{
  100. 			rnk = (rnk - 1 + A) % lst;
  101. 			if (rnk == 0)
  102. 				rnk = lst;
  103. 			pos = getpos(rnk);
  104. 		}
  105. 		else
  106. 		{
  107. 			rnk = ((rnk + A) % lst + lst) % lst;
  108. 			if (rnk == 0)
  109. 				rnk = lst;
  110. 			pos = getpos(rnk);
  111. 		}
  112. 		ord++;
  113. 		lst--;
  114. 	}
  115. 	cout << ans1 << ' ' << ans2 << endl;
  116. }
  118. int main()
  119. {
  120. 	IOS;
  121. 	init();
  122. 	while (cin >> N >> K)
  123. 	{
  124. 		memset(dat, 0, sizeof(dat));
  125. 		for (int i = 1; i <= N; i++)
  126. 		{
  127. 			cin >> name[i] >> num[i];
  128. 			add(i, 1);
  129. 		}
  130. 		solve();
  131. 	}
  133. 	return 0;
  134. }
F.花神游历各国

LOJ10128
题目大意：
长为

N

(

N

≤

1

0

5

)

N(N\leq10^5)

N(N≤105)的序列，各元素

0

≤

a

i

≤

1

0

9

0\leq a_{i}\leq10^9

0≤ai​≤109，

M

(

M

≤

2

×

1

0

5

)

M(M\leq2\times10^5)

M(M≤2×105)
次操作：

1

1

1

l

l

l

r

r

r：

[

l

,

r

]

[l,r]

[l,r]内所有元素开根号向下取整

2

2

2

l

l

l

r

r

r：询问

[

l

,

r

]

[l,r]

[l,r]内所有元素和

(

1

≤

l

≤

r

≤

N

)

(1\leq l\leq r\leq N)

(1≤l≤r≤N)

思路：
直接向区间加上一个数那样用懒标记处理取平方根显然没有办法维护，注意到

1

0

9

10^9

109内的数最多操作6次就会变为1，而对1和0本身取根号是没有变化的，于是我们可以直接对每个区间修改暴力地进行单点修改，每个节点记录所辖区间内0与1的个数，如果全部是0或者1，那么之后就不去这个区间做修改，这样每个数最多被修改6次，每次修改

O

(

l

o

g

N

)

O(logN)

O(logN)，总的复杂度还是

O

(

(

N

+

M

)

l

o

g

N

)

O((N+M)logN)

O((N+M)logN)

代码：

  1. #include<bits/stdc++.h>
  2. #include<unordered_map>
  3. #include<unordered_set>
  4. using namespace std;
  5. typedef long long LL;
  6. typedef unsigned long long ULL;
  7. typedef pair<LL, int> PII;
  8. #define int LL
  9. #define lc p*2+1
  10. #define rc p*2+2
  11. #define endl '\n'
  12. #define inf 0x3f3f3f3f
  13. #define INF 0x3f3f3f3f3f3f3f3f
  14. #define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
  15. #pragma warning(disable :4996)
  16. const double eps = 1e-8;
  17. const LL mod = 1000000007;
  18. const LL MOD = 998244353;
  19. const int maxn = 100010;
  21. struct node {
  22. 	int l, r, dat;
  23. 	int cnt;//区间<=1之个数
  24. };
  26. int N, M;
  27. int A[maxn];
  28. node tr[maxn * 4];
  30. void build(int p, int l, int r)
  31. {
  32. 	tr[p].l = l, tr[p].r = r, tr[p].cnt = 0;
  33. 	if (l + 1 == r)
  34. 	{
  35. 		tr[p].dat = A[l];
  36. 		if (A[l] <= 1)
  37. 			tr[p].cnt = 1;
  38. 		return;
  39. 	}
  40. 	int mid = (tr[p].l + tr[p].r) / 2;
  41. 	build(lc, l, mid), build(rc, mid, r);
  42. 	tr[p].dat = tr[lc].dat + tr[rc].dat;
  43. 	tr[p].cnt = tr[lc].cnt + tr[rc].cnt;
  44. }
  46. void modify(int p, int l, int r)
  47. {
  48. 	if (tr[p].cnt == tr[p].r - tr[p].l)//该区间不用修改
  49. 		return;
  50. 	if (tr[p].l + 1 == tr[p].r)
  51. 	{
  52. 		tr[p].dat = floor(sqrt(tr[p].dat));
  53. 		if (tr[p].dat <= 1)
  54. 			tr[p].cnt = 1;
  55. 		return;
  56. 	}
  57. 	int mid = (tr[p].l + tr[p].r) / 2;
  58. 	if (l < mid)
  59. 		modify(lc, l, r);
  60. 	if (r > mid)
  61. 		modify(rc, l, r);
  62. 	tr[p].dat = tr[lc].dat + tr[rc].dat;
  63. 	tr[p].cnt = tr[lc].cnt + tr[rc].cnt;
  64. }
  66. int query(int p, int l, int r)
  67. {
  68. 	if (tr[p].l >= l && tr[p].r <= r)
  69. 		return tr[p].dat;
  70. 	int mid = (tr[p].l + tr[p].r) / 2;
  71. 	if (r <= mid)
  72. 		return query(lc, l, r);
  73. 	if (l >= mid)
  74. 		return query(rc, l, r);
  75. 	return query(lc, l, mid) + query(rc, mid, r);
  76. }
  78. void solve()
  79. {
  80. 	build(0, 1, N + 1);
  81. 	cin >> M;
  82. 	int x, l, r;
  83. 	for (int i = 1; i <= M; i++)
  84. 	{
  85. 		cin >> x;
  86. 		if (x == 1)
  87. 		{
  88. 			cin >> l >> r;
  89. 			int a = min(l, r), b = max(l, r);
  90. 			cout << query(0, a, b + 1) << endl;
  91. 		}
  92. 		else
  93. 		{
  94. 			cin >> l >> r;
  95. 			int a = min(l, r), b = max(l, r);
  96. 			modify(0, a, b + 1);
  97. 		}
  98. 	}
  99. }
  101. signed main()
  102. {
  103. 	IOS;
  104. 	cin >> N;
  105. 	for (int i = 1; i <= N; i++)
  106. 		cin >> A[i];
  107. 	solve();
  109. 	return 0;
  110. }
I.二逼平衡树

luoguP3380/LOJ106
题目大意：

思路：
树套树模板题，下标线段树中每个节点用一个动态开点权值线段树维护其区间内的元素，时空都是

O

(

N

l

o

g

2

N

)

O(Nlog^2N)

O(Nlog2N)，
代码：

  1. #include<bits/stdc++.h>
  2. #include<unordered_map>
  3. #include<unordered_set>
  4. using namespace std;
  5. typedef long long LL;
  6. typedef unsigned long long ULL;
  7. typedef pair<LL, int> PII;
  8. //#define int LL
  9. #define lch p*2+1
  10. #define rch p*2+2
  11. #define endl '\n'
  12. #define inf 0x3f3f3f3f
  13. #define INF 0x3f3f3f3f3f3f3f3f
  14. #define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
  15. #pragma warning(disable :4996)
  16. const double eps = 1e-8;
  17. const LL mod = 1000000007;
  18. const LL MOD = 998244353;
  19. const int maxn = 50010;
  20. const int SIZE = 17000000;//注意大小
  22. int totb = 0;
  23. struct nodeb {
  24. 	int dat, lc, rc;
  25. };
  26. nodeb trb[SIZE];//内层权值线段树，动态开点
  28. struct nodea {
  29. 	int root, l, r;
  30. };
  31. nodea tra[maxn * 4];//外层常规下标线段树
  33. //a：外层树操作，b：内层树操作
  35. int buildb()
  36. {
  37. 	++totb;
  38. 	trb[totb].dat = trb[totb].lc = trb[totb].rc = 0;
  40. 	return totb;
  41. }
  43. void modifyb(int p, int l, int r, int val, int delta)
  44. {
  45. 	if (l + 1 == r)
  46. 	{
  47. 		trb[p].dat += delta;
  48. 		return;
  49. 	}
  50. 	int mid = (l + r) / 2;
  51. 	if (val < mid)
  52. 	{
  53. 		if (!trb[p].lc)
  54. 			trb[p].lc = buildb();
  55. 		modifyb(trb[p].lc, l, mid, val, delta);
  56. 	}
  57. 	else
  58. 	{
  59. 		if (!trb[p].rc)
  60. 			trb[p].rc = buildb();
  61. 		modifyb(trb[p].rc, mid, r, val, delta);
  62. 	}
  63. 	trb[p].dat = trb[trb[p].lc].dat + trb[trb[p].rc].dat;
  64. }
  66. int rankb(int p, int l, int r, int x)
  67. {
  68. 	if (p == 0 || l + 1 == r)
  69. 		return 0;
  70. 	int mid = (l + r) / 2;
  71. 	if (x >= mid)
  72. 		return trb[trb[p].lc].dat + rankb(trb[p].rc, mid, r, x);
  73. 	else
  74. 		return rankb(trb[p].lc, l, mid, x);
  75. }
  77. int N, M, A[maxn];
  79. void builda(int p, int l, int r)
  80. {
  81. 	tra[p].root = buildb();
  82. 	tra[p].l = l, tra[p].r = r;
  83. 	if (l + 1 == r)
  84. 	{
  85. 		modifyb(tra[p].root, -1e8, 1e8 + 10, A[l], 1);
  86. 		return;
  87. 	}
  88. 	int mid = (l + r) / 2;
  89. 	builda(lch, l, mid), builda(rch, mid, r);
  90. 	for (int i = l; i < r; i++)
  91. 		modifyb(tra[p].root, -1e8, 1e8 + 10, A[i], 1);
  92. }
  94. void modifya(int p, int pos, int x)
  95. {
  96. 	modifyb(tra[p].root, -1e8, 1e8 + 10, A[pos], -1);
  97. 	modifyb(tra[p].root, -1e8, 1e8 + 10, x, 1);
  98. 	if (tra[p].l + 1 == tra[p].r)
  99. 		return;
  100. 	int mid = (tra[p].l + tra[p].r) / 2;
  101. 	if (pos < mid)
  102. 		modifya(lch, pos, x);
  103. 	else
  104. 		modifya(rch, pos, x);
  105. }
  107. int ranka(int p, int l, int r, int x)//求出[l,r)内小于x的数的个数
  108. {
  109. 	if (tra[p].l >= l && tra[p].r <= r)
  110. 		return rankb(tra[p].root, -1e8, 1e8 + 10, x);
  111. 	int mid = (tra[p].l + tra[p].r) / 2;
  112. 	if (r <= mid)
  113. 		return ranka(lch, l, r, x);
  114. 	if (l >= mid)
  115. 		return ranka(rch, l, r, x);
  116. 	return ranka(lch, l, mid, x) + ranka(rch, mid, r, x);
  117. }
  119. int val(int p, int l, int r, int rk)
  120. {
  121. 	int lo = -1e8, hi = 1e8 + 10;
  122. 	while (hi - lo > 1)
  123. 	{
  124. 		int mid = (lo + hi) / 2;
  125. 		if (ranka(0, l, r, mid) + 1 <= rk)//找排名<=rk的最大值
  126. 			lo = mid;
  127. 		else
  128. 			hi = mid;
  129. 	}
  131. 	return lo;
  132. }
  134. int pred(int p, int l, int r, int x)
  135. {
  136. 	int rk = ranka(0, l, r, x);
  137. 	if (rk < 1)
  138. 		return -2147483647;
  139. 	return val(0, l, r, rk);
  140. }
  142. int succ(int p, int l, int r, int x)
  143. {
  144. 	int rk = ranka(0, l, r, x + 1) + 1;
  145. 	if (rk > r - l)
  146. 		return 2147483647;
  147. 	return val(0, l, r, rk);
  148. }
  150. void solve()
  151. {
  152. 	builda(0, 1, N + 1);
  153. 	int opt, l, r, x, k, pos;
  154. 	for (int i = 1; i <= M; i++)
  155. 	{
  156. 		cin >> opt;
  157. 		switch (opt)
  158. 		{
  159. 			case 1:
  160. 				cin >> l >> r >> x;
  161. 				cout << ranka(0, l, r + 1, x) + 1 << endl;
  162. 				break;
  163. 			case 2:
  164. 				cin >> l >> r >> k;
  165. 				cout << val(0, l, r + 1, k) << endl;
  166. 				break;
  167. 			case 3:
  168. 				cin >> pos >> x;
  169. 				modifya(0, pos, x);
  170. 				A[pos] = x;
  171. 				break;
  172. 			case 4:
  173. 				cin >> l >> r >> x;
  174. 				cout << pred(0, l, r + 1, x) << endl;
  175. 				break;
  176. 			case 5:
  177. 				cin >> l >> r >> x;
  178. 				cout << succ(0, l, r + 1, x) << endl;
  179. 				break;
  180. 		}
  181. 	}
  182. }
  184. int main()
  185. {
  186. 	IOS;
  187. 	cin >> N >> M;
  188. 	for (int i = 1; i <= N; i++)
  189. 		cin >> A[i];
  190. 	solve();
  192. 	return 0;
  193. }
J.冰火战士

luoguP6619/LOJ3299
思路：
当温度确定时，消耗的总能量为冰火两方可参赛战士能量总和最少的一方

×

2

\times2

×2，于是我们只要求出这个最小值即可。
发现对于温度

K

K

K，可以参赛的冰系战士总能量是一个

K

K

K处的前缀和，而可以参赛的火系战士总能量是一个

K

K

K处的后缀和，可以发现冰系战士的总能量是随着温度增加而递增的，而火系是递减的，所以显然二者最小值在二者曲线交点处取最大，但由于二者的曲线不是连续的，所以最大值有两个可能的点，分别是最大的火系总能量

≥

\geq

≥冰系的温度

k

1

k_{1}

k1​，以及最小的火系总能量

≤

\leq

≤冰系的温度

k

2

k_{2}

k2​，这两个点的结果取最大值就是最多能量了，我们可以对温度离散化后用

B

I

T

BIT

BIT来维护冰，火两系战士的能量，而

k

1

,

k

2

k1,k2

k1,k2两个点可以通过在

B

I

T

BIT

BIT上二分来仅用一个

l

o

g

log

log的复杂度求得，

B

I

T

BIT

BIT上的二分可以理解为就是在上面做倍增，不过要注意维护一下已经跳过部分的贡献，冰系的很好维护，火系的由于需要的是后缀和，需要额外记录一下总和

F

I

R

E

FIRE

FIRE以及每个温度处的火系选手的能量值

F

[

i

]

F[i]

F[i]，温度

T

T

T时火系选手的总温度就是

F

I

R

E

−

S

[

T

]

+

F

[

T

]

FIRE-S[T]+F[T]

FIRE−S[T]+F[T]。题目还要求在求得最大能量的前提下，温度要尽可能地大，显然如果答案取在

k

1

k_{1}

k1​，那么就已经是最大的了，而如果取在

k

2

k_{2}

k2​，答案为

x

x

x，我们可以再在

B

I

T

BIT

BIT上面二分来寻找火系总能量

≥

x

\geq x

≥x的温度来作为答案即可。
复杂度

O

(

Q

l

o

g

N

)

O(QlogN)

O(QlogN)

代码：

  1. #include<bits/stdc++.h>
  2. #include<unordered_map>
  3. #include<unordered_set>
  4. using namespace std;
  5. typedef long long LL;
  6. typedef unsigned long long ULL;
  7. typedef pair<int, int> PII;
  8. //#define LL int
  9. #define endl '\n'
  10. #define inf 0x3f3f3f3f
  11. #define INF 0x3f3f3f3f3f3f3f3f
  12. #define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
  13. #pragma warning(disable :4996)
  14. const double eps = 1e-8;
  15. const LL mod = 1000000007;
  16. const LL MOD = 998244353;
  17. const int maxn = (1 << 21) + 5;
  19. int read()
  20. {
  21. 	int x = 0, f = 1;
  22. 	char c = getchar();
  23. 	while (c < '0' || c > '9')
  24. 	{
  25. 		if (c == '-')
  26. 			f = -1;
  27. 		c = getchar();
  28. 	}
  29. 	while (c >= '0' && c <= '9')
  30. 	{
  31. 		x = x * 10 + c - '0';
  32. 		c = getchar();
  33. 	}
  35. 	return x * f;
  36. }
  38. void write(int x)
  39. {
  40. 	if (x < 0)
  41. 	{
  42. 		putchar('-');
  43. 		x = -x;
  44. 	}
  45. 	if (x > 9)
  46. 		write(x / 10);
  47. 	putchar(x % 10 + '0');
  48. }
  50. int Q, M;
  51. int N[maxn], T[maxn], X[maxn], Y[maxn], K[maxn];
  52. int FIRE, F[(1 << 21) + 5];//fire总能量，各点上fire能量
  53. int S[(1 << 21) + 5];
  54. int dat[(1 << 21) + 5][2];//0:ice,1:fire
  56. int compress()
  57. {
  58. 	vector<int>xs;
  59. 	for (int i = 1; i <= Q; i++)
  60. 	{
  61. 		if (N[i] == 1)
  62. 			xs.push_back(X[i]);
  63. 	}
  64. 	sort(xs.begin(), xs.end());
  65. 	xs.erase(unique(xs.begin(), xs.end()), xs.end());
  66. 	for (int i = 1; i <= Q; i++)
  67. 	{
  68. 		if (N[i] == 1)
  69. 		{
  70. 			int tmp = X[i];
  71. 			X[i] = upper_bound(xs.begin(), xs.end(), X[i]) - xs.begin();
  72. 			S[X[i]] = tmp;
  73. 		}
  74. 	}
  76. 	return xs.size();
  77. }
  79. void add(int i, int x, int t)
  80. {
  81. 	while (i <= (1 << 21))
  82. 	{
  83. 		dat[i][t] += x;
  84. 		i += i & (-i);
  85. 	}
  86. }
  88. int sum(int i, int t)
  89. {
  90. 	int ans = 0;
  91. 	while (i > 0)
  92. 	{
  93. 		ans += dat[i][t];
  94. 		i -= i & (-i);
  95. 	}
  97. 	return ans;
  98. }
  100. PII query1()//(最右的fire>=ice点)
  101. {
  102. 	int k = 0, fire = FIRE, ice = 0;
  103. 	for (int i = 20; i >= 0; i--)
  104. 	{
  105. 		int t = k + (1 << i);
  106. 		if (fire - dat[t][1] + F[t] >= ice + dat[t][0])
  107. 		{
  108. 			fire -= dat[t][1];
  109. 			ice += dat[t][0];
  110. 			k = t;
  111. 		}
  112. 	}
  114. 	return PII(k, sum(k, 0));
  115. }
  117. PII query2()//(最左的fire<=ice点)
  118. {
  119. 	int k = 0, fire = FIRE, ice = 0;
  120. 	for (int i = 20; i >= 0; i--)
  121. 	{
  122. 		int t = k + (1 << i);
  123. 		if (fire - dat[t][1] + F[t] > ice + dat[t][0])
  124. 		{
  125. 			k = t;
  126. 			fire -= dat[t][1];
  127. 			ice += dat[t][0];
  128. 		}
  129. 	}
  131. 	return PII(k + 1, FIRE - sum(k + 1, 1) + F[k + 1]);
  132. }
  134. int query3(int x)//(最右的fire>=x点)
  135. {
  136. 	int k = 0, fire = FIRE;
  137. 	for (int i = 20; i >= 0; i--)
  138. 	{
  139. 		int t = k + (1 << i);
  140. 		if (fire - dat[t][1] + F[t] >= x)
  141. 		{
  142. 			k = t;
  143. 			fire -= dat[t][1];
  144. 		}
  145. 	}
  146. 	return k;
  147. }
  149. void solve()
  150. {
  151. 	M = compress();
  152. 	for (int i = 1; i <= Q; i++)
  153. 	{
  154. 		if (N[i] == 1)
  155. 		{
  156. 			add(X[i], Y[i], T[i]);
  157. 			if (T[i])
  158. 			{
  159. 				FIRE += Y[i];
  160. 				F[X[i]] += Y[i];
  161. 			}
  162. 		}
  163. 		else
  164. 		{
  165. 			int x = X[K[i]], y = Y[K[i]], t = T[K[i]];
  166. 			if (t)
  167. 			{
  168. 				FIRE -= y;
  169. 				F[x] -= y;
  170. 			}
  171. 			add(x, -y, t);
  172. 		}
  173. 		PII a = query1(), b = query2();
  174. 		int k1 = a.first, v1 = a.second;
  175. 		int k2 = b.first, v2 = b.second;
  176. 		int ans1, ans2;
  177. 		if (v1 > v2)
  178. 			ans2 = v1, ans1 = k1;
  179. 		else
  180. 			ans2 = v2, ans1 = k2;
  181. 		if (ans2 == v2)
  182. 			ans1 = query3(ans2);
  183. 		if (!ans2)
  184. 			puts("Peace");
  185. 		else
  186. 		{
  187. 			write(S[ans1]), putchar(' ');
  188. 			write(ans2 * 2), putchar('\n');
  189. 		}
  190. 	}
  191. }
  193. int main()
  194. {
  195. 	Q = read();
  196. 	for (int i = 1; i <= Q; i++)
  197. 	{
  198. 		N[i] = read();
  199. 		if (N[i] == 1)
  200. 			T[i] = read(), X[i] = read(), Y[i] = read();
  201. 		else
  202. 			K[i] = read();
  203. 	}
  204. 	solve();
  206. 	return 0;
  207. }
K.混合果汁

luoguP4602/LOJ2555
题目大意：

N

(

N

≤

1

0

5

)

N(N\leq10^5)

N(N≤105)种果汁，每种果汁有美味度

d

i

d_{i}

di​，单价

p

i

p_{i}

pi​，购买上限

l

i

(

1

≤

d

i

,

p

i

,

l

i

≤

1

0

5

)

l_{i}(1\leq d_{i},p_{i},l_{i}\leq10^5)

li​(1≤di​,pi​,li​≤105)，有

M

(

M

≤

1

0

5

)

M(M\leq10^5)

M(M≤105)次询问，每次询问给出拥有的钱

g

i

g_{i}

gi​，至少购买的果汁升数

L

i

(

1

≤

g

i

,

L

i

≤

1

0

18

)

L_{i}(1\leq g_{i},L_{i}\leq10^{18})

Li​(1≤gi​,Li​≤1018)，混合果汁的美味度为所购买的果汁中美味度最低的，对于每个询问，需要使所购买满足要求的混合果汁中美味度最大，如果不能购买满足要求的果汁，输出

−

1

-1

−1。

思路：
我们考虑单独

1

1

1个询问，显然我们可以二分美味度

d

d

d，

c

h

e

c

k

check

check时考虑所有

d

i

≥

d

d_{i}\geq d

di​≥d的果汁，贪心地从单价低的开始购买，看能不能卖出满足要求的即可。
现在有多组询问，每次都直接二分显然是不行的，于是我们可以建一个主席树维护单价

p

p

p上的信息，对所有的

d

d

d从大到小可持久化（实现时对果汁按

d

d

d排序之后对下标可持久化，二分也改为二分下标即可），每个节点维护所辖区间的果汁总购买上限以及购买他们所需要的总价格，对于每个查询，二分

c

h

e

c

k

check

check时只需要查询主席树上对应的版本就可以了，这样每个询问可以在

O

(

l

o

g

2

N

)

O(log^2N)

O(log2N)的时间内回答，总的复杂度为

O

(

N

l

o

g

2

N

)

O(Nlog^2N)

O(Nlog2N)。

代码：

  1. #include<bits/stdc++.h>
  2. #include<unordered_map>
  3. #include<unordered_set>
  4. using namespace std;
  5. typedef long long LL;
  6. typedef unsigned long long ULL;
  7. typedef pair<int, int> PII;
  8. #define int LL
  9. #define endl '\n'
  10. #define inf 0x3f3f3f3f
  11. #define INF 0x3f3f3f3f3f3f3f3f
  12. #define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
  13. #pragma warning(disable :4996)
  14. const double eps = 1e-8;
  15. const LL mod = 1000000007;
  16. const LL MOD = 998244353;
  17. const int maxn = 100010;
  19. struct node {
  20. 	int lc, rc, sum, lim;
  21. }tr[maxn * 40];
  22. struct juice {
  23. 	int d, p, l;
  24. }J[maxn];
  25. int tot = 0, root[maxn], N, M, mx = -INF;
  27. bool cmp(const juice& a, const juice& b)
  28. {
  29. 	return a.d < b.d;
  30. }
  32. int build(int l, int r)//[)
  33. {
  34. 	int p = ++tot;
  35. 	if (l + 1 == r)
  36. 	{
  37. 		tr[p].lim = tr[p].sum = 0;
  38. 		return p;
  39. 	}
  40. 	int mid = (l + r) / 2;
  41. 	tr[p].lc = build(l, mid), tr[p].rc = build(mid, r);
  42. 	tr[p].lim = tr[tr[p].lc].lim + tr[tr[p].rc].lim;
  43. 	tr[p].sum = tr[tr[p].lc].sum + tr[tr[p].rc].sum;
  45. 	return p;
  46. }
  48. int modify(int now, int l, int r, int x, int val)
  49. {
  50. 	int p = ++tot;
  51. 	tr[p] = tr[now];
  52. 	if (l + 1 == r)
  53. 	{
  54. 		tr[p].sum += x * val, tr[p].lim += val;
  55. 		return p;
  56. 	}
  57. 	int mid = (l + r) / 2;
  58. 	if (x < mid)
  59. 		tr[p].lc = modify(tr[now].lc, l, mid, x, val);
  60. 	else
  61. 		tr[p].rc = modify(tr[now].rc, mid, r, x, val);
  62. 	tr[p].lim = tr[tr[p].lc].lim + tr[tr[p].rc].lim;
  63. 	tr[p].sum = tr[tr[p].lc].sum + tr[tr[p].rc].sum;
  65. 	return p;
  66. }
  68. bool query(int p, int q, int l, int r, int k, int s)//k:购买上限，s:所持有的钱数
  69. {
  70. 	if (k > tr[q].lim - tr[p].lim || s < 0)
  71. 		return false;
  72. 	if (l + 1 == r)
  73. 		return l * k <= s;
  74. 	int mid = (l + r) / 2;
  75. 	int llim = tr[tr[q].lc].lim - tr[tr[p].lc].lim, lsum = tr[tr[q].lc].sum - tr[tr[p].lc].sum;
  76. 	if (k <= llim)
  77. 		return query(tr[p].lc, tr[q].lc, l, mid, k, s);
  78. 	else
  79. 		return query(tr[p].rc, tr[q].rc, mid, r, k - llim, s - lsum);
  80. }
  82. void solve()
  83. {
  84. 	sort(J + 1, J + N + 1, cmp);
  85. 	int lst = J[N].d;
  86. 	root[0] = build(1, mx + 1);
  87. 	for (int i = N; i >= 1; i--)
  88. 		root[N - i + 1] = modify(root[N - i], 1, mx + 1, J[i].p, J[i].l);
  89. 	int g, l;
  90. 	for (int i = 1; i <= M; i++)
  91. 	{
  92. 		cin >> g >> l;
  93. 		int lo = 0, hi = N + 1;//对下标二分
  94. 		while (hi - lo > 1)
  95. 		{
  96. 			int mid = (hi + lo) / 2;
  97. 			if (query(root[0], root[N - mid + 1], 1, mx + 1, l, g))
  98. 				lo = mid;
  99. 			else
  100. 				hi = mid;
  101. 		}
  102. 		cout << (lo ? J[lo].d : -1) << endl;
  103. 	}
  104. }
  106. signed main()
  107. {
  108. 	IOS;
  109. 	cin >> N >> M;
  110. 	for (int i = 1; i <= N; i++)
  111. 	{
  112. 		cin >> J[i].d >> J[i].p >> J[i].l;
  113. 		mx = max(mx, J[i].p);
  114. 	}
  115. 	solve();
  117. 	return 0;
  118. }
L.陌上花开

luoguP3810/LOJ112
题目大意：

1

≤

N

≤

1

0

5

,

1

≤

K

≤

2

×

1

0

5

1\leq N\leq10^5,1\leq K\leq2\times10^5

1≤N≤105,1≤K≤2×105

思路：
三维偏序模板题，第一维排序，第二维用树状数组维护，第三维用动态开点的权值线段树维护。
（树状数组的每个节点维护一颗维护其所辖第二维区间上的第三维值域上面信息的线段树。）

代码：

  1. #include<bits/stdc++.h>
  2. #include<unordered_map>
  3. #include<unordered_set>
  4. using namespace std;
  5. typedef long long LL;
  6. typedef unsigned long long ULL;
  7. typedef pair<LL, int> PII;
  8. //#define int LL
  9. #define lch p*2+1
  10. #define rch p*2+2
  11. #define endl '\n'
  12. #define inf 0x3f3f3f3f
  13. #define INF 0x3f3f3f3f3f3f3f3f
  14. #define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
  15. #pragma warning(disable :4996)
  16. const double eps = 1e-8;
  17. const LL mod = 1000000007;
  18. const LL MOD = 998244353;
  19. const int maxn = 200010;
  20. const int SIZE = 30000000;
  22. int tot = 0;
  24. struct point {
  25. 	int a, b, c, id;
  26. 	bool operator<(const point& rhs)
  27. 	{
  28. 		if (a == rhs.a)
  29. 		{
  30. 			if (b == rhs.b)
  31. 				return c < rhs.c;
  32. 			return b < rhs.b;
  33. 		}
  34. 		return a < rhs.a;
  35. 	}
  36. 	bool operator==(const point& rhs)
  37. 	{
  38. 		return a == rhs.a && b == rhs.b && c == rhs.c;
  39. 	}
  40. };
  42. struct node {
  43. 	int dat, lc, rc;
  44. };
  45. node tr[SIZE];//内层权值线段树，动态开点
  47. int build()
  48. {
  49. 	++tot;
  50. 	tr[tot].dat = tr[tot].lc = tr[tot].rc = 0;
  52. 	return tot;
  53. }
  55. void modify(int p, int l, int r, int val, int delta)
  56. {
  57. 	if (l + 1 == r)
  58. 	{
  59. 		tr[p].dat += delta;
  60. 		return;
  61. 	}
  62. 	int mid = (l + r) / 2;
  63. 	if (val < mid)
  64. 	{
  65. 		if (!tr[p].lc)
  66. 			tr[p].lc = build();
  67. 		modify(tr[p].lc, l, mid, val, delta);
  68. 	}
  69. 	else
  70. 	{
  71. 		if (!tr[p].rc)
  72. 			tr[p].rc = build();
  73. 		modify(tr[p].rc, mid, r, val, delta);
  74. 	}
  75. 	tr[p].dat = tr[tr[p].lc].dat + tr[tr[p].rc].dat;
  76. }
  78. int query(int p, int l, int r, int x)
  79. {
  80. 	if (p == 0 || l + 1 == r)
  81. 		return 0;
  82. 	int mid = (l + r) / 2;
  83. 	if (x >= mid)
  84. 		return tr[tr[p].lc].dat + query(tr[p].rc, mid, r, x);
  85. 	else
  86. 		return query(tr[p].lc, l, mid, x);
  87. }
  89. int N, K;
  90. int ans[maxn];
  91. point A[maxn];
  92. int dat[maxn], n;
  94. void add(int posx, int posy, int x)
  95. {
  96. 	while (posx <= n)
  97. 	{
  98. 		if (!dat[posx])
  99. 			dat[posx] = build();
  100. 		modify(dat[posx], 1, K + 5, posy, x);
  101. 		posx += posx & (-posx);
  102. 	}
  103. }
  105. int sum(int posx, int posy)
  106. {
  107. 	int tmp = 0;
  108. 	while (posx > 0)
  109. 	{
  110. 		tmp += query(dat[posx], 1, K + 5, posy + 1);
  111. 		posx -= posx & (-posx);
  112. 	}
  114. 	return tmp;
  115. }
  117. void solve()
  118. {
  119. 	n = K + 5;
  120. 	sort(A + 1, A + N + 1);
  121. 	int tmp = 1;
  122. 	for (int i = 1; i <= N; i++)
  123. 	{
  124. 		if (A[i] == A[i + 1])
  125. 		{
  126. 			tmp++;
  127. 			continue;
  128. 		}
  129. 		add(A[i].b, A[i].c, tmp);
  130. 		ans[sum(A[i].b, A[i].c) - 1] += tmp;
  131. 		tmp = 1;
  132. 	}
  133. 	for (int i = 0; i < N; i++)
  134. 		cout << ans[i] << endl;
  135. }
  137. int main()
  138. {
  139. 	IOS;
  140. 	cin >> N >> K;
  141. 	for (int i = 1; i <= N; i++)
  142. 	{
  143. 		cin >> A[i].a >> A[i].b >> A[i].c;
  144. 		A[i].id = i;
  145. 	}
  146. 	solve();
  148. 	return 0;
  149. }
M.A Plus B Problem

2021CCPC桂林站B
题目大意：
两个长度为

N

(

N

≤

1

0

6

)

N(N\leq10^6)

N(N≤106)的数字

A

,

B

A,B

A,B做加法，结果也为一个长度为

N

N

N的数字（多出来的高位被忽略），

Q

(

Q

≤

1

0

6

)

Q(Q\leq10^6)

Q(Q≤106)个次操作，每次操作把选择两个加数的其中一个，将其某一位数字替换为

0

0

0到

9

9

9中的一个数字，询问每次操作后，两个加数以及和中，总共有多少数字发生变化。

思路：
主要是要解决更改数字后的进位问题，对于每一位，最多向前进

1

1

1位，所以只要该位上两个加数的数字相加不等于

9

9

9，那么这一位向前进位与否就仅取决于自己，否则还要取决于更低一位是否进位，设当前位为

i

i

i,

i

i

i右边的第一个加数和不为

9

9

9的位记为

j

j

j，那么第

i

i

i位和数上的值就等于

(

A

i

+

B

i

+

[

A

j

+

B

j

≥

10

]

)

%

10

(A_{i}+B_{i}+[A_{j}+B_{j}\geq 10])\%10

(Ai​+Bi​+[Aj​+Bj​≥10])%10
那么显然如果更改后某一位上的进位状态没有发生变化，就仅会改变

2

2

2个数字，如果发生了变化，那么受其原先进位状态影响的若干个连续的更高位也会发生变化，记

i

i

i位左侧首个加数和不为

9

9

9的位为

j

j

j，

i

i

i位所能影响的就是

j

j

j到

i

i

i这若干位，于是变化的位数就是这些位数

+

1

+1

+1了。
我们可以维护所有加数和不等于

9

9

9的位，并且要插入，删除，查询前驱后继，所以我们用

s

e

t

set

set就可以轻松维护，在

O

(

Q

l

o

g

N

)

O(QlogN)

O(QlogN)内解决问题。
注意一些边界情况要特别处理一下。

代码：

  1. #include<bits/stdc++.h>
  2. #include<unordered_map>
  3. #include<unordered_set>
  4. using namespace std;
  5. typedef long long LL;
  6. typedef unsigned long long ULL;
  7. typedef pair<int, int> PII;
  8. //#define int LL
  9. #define endl '\n'
  10. #define inf 0x3f3f3f3f
  11. #define INF 0x3f3f3f3f3f3f3f3f
  12. #define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
  13. #pragma warning(disable :4996)
  14. const double eps = 1e-8;
  15. const LL mod = 1000000007;
  16. const LL MOD = 998244353;
  17. const int maxn = 1000010;
  19. int N, Q;
  20. string S[2];
  21. int num[2][maxn];
  22. set<int>ss;
  24. void solve()
  25. {
  26. 	ss.insert(N + 1), ss.insert(0);
  27. 	for (int i = 1; i <= N; i++)
  28. 	{
  29. 		num[0][i] = S[0][i - 1] - '0', num[1][i] = S[1][i - 1] - '0';
  30. 		if (num[0][i] + num[1][i] != 9)
  31. 			ss.insert(i);
  32. 	}
  33. 	int r, c, d;
  34. 	for (int i = 1; i <= Q; i++)
  35. 	{
  36. 		int ans1 = 2, ans2;
  37. 		cin >> r >> c >> d;
  38. 		bool up1 = false, up2 = false;
  39. 		int up = 0;
  40. 		int a = num[1][c] + num[0][c];
  41. 		int succ = *ss.upper_bound(c);
  42. 		up = num[1][succ] + num[0][succ] >= 10;
  43. 		if (a + up >= 10)
  44. 			up1 = true;
  45. 		if (a != 9)
  46. 			ss.erase(c);
  47. 		num[r - 1][c] = d;
  48. 		int b = num[1][c] + num[0][c];
  49. 		if (b != 9)
  50. 			ss.insert(c);
  51. 		succ = *ss.upper_bound(c);
  52. 		up = num[1][succ] + num[0][succ] >= 10;
  53. 		if (b + up >= 10)
  54. 			up2 = true;
  55. 		ans2 = (b + up) % 10;
  56. 		if (a == b)
  57. 		{
  58. 			cout << ans2 << ' ' << 0 << endl;
  59. 			continue;
  60. 		}
  61. 		if (up1 ^ up2)
  62. 		{
  63. 			int pred = *(--ss.lower_bound(c));
  64. 			ans1 += c - pred;
  65. 			if (pred == 0)
  66. 				ans1--;
  67. 		}
  68. 		cout << ans2 << ' ' << ans1 << endl;
  69. 	}
  70. }
  72. int main()
  73. {
  74. 	IOS;
  75. 	cin >> N >> Q >> S[0] >> S[1];
  76. 	solve();
  78. 	return 0;
  79. }

AHUACM寒假集训II（线段树）的更多相关文章

  1. UVA10869 - Brownie Points II(线段树)

    UVA10869 - Brownie Points II(线段树) 题目链接 题目大意:平面上有n个点,Stan和Ollie在玩游戏,游戏规则是:Stan先画一条竖直的线作为y轴,条件是必需要经过这个 ...

  2. 2020牛客寒假算法基础集训营3 - G. 牛牛的Link Power II(线段树)

    题目链接:牛牛的Link Power II 题意:给你一个只含$0$和$1$的串,定义串的$Link$值为串中两个的$1$之间的距离的和,$(u,v)$和$(v,u)$被看认为是同一对,有$m$次操作 ...

  3. CDOJ 1259 昊昊爱运动 II 线段树+bitset

    昊昊爱运动 II 昊昊喜欢运动 他N天内会参加M种运动(每种运动用一个[1,m]的整数表示) 现在有Q个操作,操作描述如下 昊昊把第l天到第r天的运动全部换成了x(x∈[1,m]) 问昊昊第l天到第r ...

  4. SPOJ 1557. Can you answer these queries II 线段树

    Can you answer these queries II Time Limit: 20 Sec Memory Limit: 256 MB 题目连接 https://www.spoj.com/pr ...

  5. bzoj 2482: [Spoj GSS2] Can you answer these queries II 线段树

    2482: [Spoj1557] Can you answer these queries II Time Limit: 20 Sec  Memory Limit: 128 MBSubmit: 145 ...

  6. 4990: [Usaco2017 Feb]Why Did the Cow Cross the Road II 线段树维护dp

    题目 4990: [Usaco2017 Feb]Why Did the Cow Cross the Road II 链接 http://www.lydsy.com/JudgeOnline/proble ...

  7. hdu 5831 Rikka with Parenthesis II 线段树

    Rikka with Parenthesis II 题目连接: http://acm.hdu.edu.cn/showproblem.php?pid=5831 Description As we kno ...

  8. 【CF687D】Dividing Kingdom II 线段树+并查集

    [CF687D]Dividing Kingdom II 题意:给你一张n个点m条边的无向图,边有边权$w_i$.有q个询问,每次给出l r,问你:如果只保留编号在[l,r]中的边,你需要将所有点分成两 ...

  9. 【BZOJ2482】[Spoj1557] Can you answer these queries II 线段树

    [BZOJ2482][Spoj1557] Can you answer these queries II Description 给定n个元素的序列. 给出m个询问:求l[i]~r[i]的最大子段和( ...

随机推荐

  1. 布客&#183;ApacheCN 编程/后端/大数据/人工智能学习资源 2020.9

    公告 ApacheCN 项目的最终目标:五年内备份并翻译 Github 上的所有教程(其实快被我们啃完了,剩下的不多了). 警告各位培训班:对 ApacheCN 宣传文章的举报,也将视为对 Apach ...

  2. 社交网络分析的 R 基础：（三）向量、矩阵与列表

    在第二章介绍了 R 语言中的基本数据类型,本章会将其组装起来,构成特殊的数据结构,即向量.矩阵与列表.这些数据结构在社交网络分析中极其重要,本质上对图的分析,就是对邻接矩阵的分析,而矩阵又是由若干个向 ...

  3. NoSuchMethodError错误

    发生原因: 一个项目中包含有相同名字,但内容不同的包 解决办法:删除其中暂时不用的包 后记:如果不知道哪一个包是多余的,直接用IDE查找:找到该类,然后将该包进行反编译,再次导入该项目,再找到该类,出 ...

  4. bom-client

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  5. CentOS 7中的系统语言包及UTF-8、en_US.UTF-8和zh_CN.UTF-8的区别

    UTF-8.en_US.UTF-8和zh_CN.UTF-8的区别 en_US.UTF-8.zh_CN.UTF-8叫做字符集,就是说'A'.'B'.'中'.'国'等对应的整数值,en_US.UTF-8只 ...

  6. Java8-Consumer、Supplier、Predicate和Function方法总结

    这几个接口都在 java.util.function 包下的,分别是Consumer(消费型).supplier(供给型).predicate(谓词型).function(功能性): 那么,下面,我们 ...

  7. 动态修改UINavigationBar的背景色－－by－胡旭

    这是我们最终想要得到的效果 思路 在UISrollView的delegate方法 - (void)scrollViewDidScroll:(UIScrollView *)scrollView中根据当前 ...

  8. LeetCode随缘刷题之字符串转换整数

    package leetcode.day_01_29; import java.util.regex.Matcher; import java.util.regex.Pattern; /** * 请你 ...

  9. Typora如何上传图片到gitee

    Typora是一款非常好用的Markdown文本编辑器,深受广大程序员的青睐,那么在使用过程中,当我们插入图片的时候,其实是默认放在一个相对路径文件夹下的,这就导致,一旦我们移动文件,或者发送给别人, ...

  10. CentOS卸载自带的JDK

    一般在配置JDK之前要卸载CentOS自带的openjdk,接下来演示如何卸载自带的openjdk 进入root模式 查看jdk是否已经安装jdk rpm -qa | grep jdk 3. 卸载op ...