[wc2013]糖果公园

最新推荐文章于 2020-08-10 16:18:14 发布
最新推荐文章于 2020-08-10 16:18:14 发布
阅读量2.4k 收藏
点赞数
分类专栏： 题目
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JerryDung/article/details/8796870
版权

树上莫队算法：

#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>

typedef long long int64;
typedef int (*cmp_t) (const void *, const void *);

#ifdef WIN32
#define fmt64 "%I64d"
#else
#define fmt64 "%lld"
#endif
#define oo 0x13131313
#define swap(x, y) ({ int _ = x; x = y; y = _; })

void get(int *x)
{
	char c = getchar();
	for (; '0' > c || c > '9'; c = getchar());
	*x = c - '0', c = getchar();
	for (; '0' <= c && c <= '9'; c = getchar()) *x *= 10, *x += c - '0';
}

typedef struct edge { int t; struct edge *n; } edge;
typedef struct elem { int x, y, t; struct elem *n; } elem;
typedef struct info { int t, f; struct info *n; } info;
typedef int arr32[200100];

edge mem[200005], *adjc = mem, *adj[100005];
elem memo[100005], *me = memo, *modify[100005], *que[100005], *ask[60][60];
info Mem[200005], *memt = Mem, *list[100005];
arr32 v, w, c, cc, ufs, br, ll, rr, lca, bel, sum, type, xx, yy;
bool appr[100005]; int64 ans, anss[100005];
int n, m, Q, B, tot, mt, qt, bt, hehe, haha;

int find(int x) { return ufs[x] == x ? x : (ufs[x] = find(ufs[x])); }

void dfs(int u, int fa)
{
	edge *e;
	br[ll[u] = ++tot] = u;
	for (e = adj[u]; e; e = e->n)
		if (e->t != fa) dfs(e->t, u);
	br[rr[u] = ++tot] = u;
}

void tarjan(int u, int fa)
{
	edge *e; info *i; ufs[u] = u;
	for (e = adj[u]; e; e = e->n)
		if (e->t != fa)
			tarjan(e->t, u), ufs[e->t] = u;
	for (i = list[u]; i; i = i->n)
		if (ufs[i->t])
			lca[i->f] = find(i->t);
}

void trans(int p)
{
	if (appr[p])
		appr[p] = 0, ans -= (int64) v[c[p]] * w[sum[c[p]]--];
	else
		appr[p] = 1, ans += (int64) v[c[p]] * w[++sum[c[p]]];
}

int main()
{
	freopen("park.in", "r", stdin);
	freopen("park.out", "w", stdout);

	int i, j, k;
	get(&n), get(&m), get(&Q);
	for (i = 1; i <= m; ++i)
		get(v + i);
	for (i = 1; i <= n; ++i)
		get(w + i);

	for (i = 1; i < n; ++i) {
		int a, b;
		get(&a), get(&b);
		*adjc = (edge) {b, adj[a]}, adj[a] = adjc++;
		*adjc = (edge) {a, adj[b]}, adj[b] = adjc++;
	}

	for (i = 1; i <= n; ++i)
		get(c + i), cc[i] = c[i];

	/* get brackets sequence */
	dfs(1, 0);
	/* n ^ (2 / 3) */
	for (B = 1; B * B * B < tot; ++B); B *= B;

	for (i = j = bt = 1; i <= tot; ++i, ++j) {
		if (j > B) j = 1, ++bt;
		bel[i] = bt;
	}

	for (i = 0; i < Q; ++i) {
		int x, y;
		get(type + i), get(&x), get(&y);

		if (!type[i])
			*me = (elem) {x, y, i}, modify[mt++] = me++;
		else {
			/* for LCA queries */
			*memt = (info) {y, me - memo, list[x]}, list[x] = memt++;
			*memt = (info) {x, me - memo, list[y]}, list[y] = memt++;

			/* asked intervals */
			if (ll[x] > ll[y]) swap(x, y);
			xx[i] = x, yy[i] = y;
			x = rr[x] < rr[y] ? rr[x] : ll[x]; y = ll[y];
			*me = (elem) {x, y, i}; que[qt++] = me++;
		}
	}

	/* divide queries into groups */
	for (i = qt; i--; ) {
		elem *j = que[i];
		j->n = ask[bel[j->x]][bel[j->y]], ask[bel[j->x]][bel[j->y]] = j;
	}

	/* LCA */
	tarjan(1, 0);

	/* answer */
	for (i = 1; i <= bt; ++i)
		for (j = i; j <= bt; ++j)
			if (ask[i][j]) {
				int l = (i - 1) * B + 1, r = l, f;
				elem *e, *d;
				memset(sum, 0, (m + 1) << 2);
				memset(appr, 0, (n + 1));
				memcpy(c, cc, (n + 1) << 2);
				ans = k = 0; trans(br[l]);

				for (e = ask[i][j]; e; e = e->n) {
					if (l < e->x) for (; l != e->x; ++l) trans(br[l]);
					else if (l > e->x) do --l, trans(br[l]); while (l != e->x);
					if (r > e->y) for (; r != e->y; --r) trans(br[r]);
					else if (r < e->y) do ++r, trans(br[r]); while (r != e->y);

					for (; k < mt && modify[k]->t < e->t; ++k) {
						d = modify[k];
						bool flag = (l <= ll[d->x] && ll[d->x] <= r) ^ (l <= rr[d->x] && rr[d->x] <= r);
						if (flag) trans(d->x);
						c[d->x] = d->y;
						if (flag) trans(d->x);
					}

					anss[e->t] = ans;

					if (f = lca[e - memo], f != xx[e->t] && f != yy[e->t])
						anss[e->t] += (int64) v[c[f]] * w[sum[c[f]] + 1];
				}
			}

	for (i = 0; i < Q; ++i)
		if (type[i])
			printf(fmt64 "\n", anss[i]);

	return 0;
}



70分树上莫队算法：

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

#define uns unsigned
#define int64 long long
#ifdef WIN32
#define fmt64 "%I64d"
#else
#define fmt64 "%lld"
#endif
#define oo 0x13131313
#define REP(i, n) for (i = 0; i < (n); ++i)
#define maxn 200005

using namespace std;

int n, m, Q, Br;
struct edge { int t; edge *n; } edges[maxn * 2], *adj = edges, *lst[maxn];
typedef int array[maxn];
array v, w, c, x, y, p, xx, yy, br, ll, rr, hehe, ufs, lca, sum, pa;
struct elem { int t, f; elem *n; } elems[maxn * 2], *eptr = elems, *stk[maxn];
int64 result, ans[maxn]; bool appr[maxn];

void link(int a, int b)
{
	*adj = (edge){b, lst[a]}, lst[a] = adj++;
	*adj = (edge){a, lst[b]}, lst[b] = adj++;
}

void dfs(int u, int fa)
{
	br[ll[u] = ++Br] = u;
	for (edge *e = lst[u]; e; e = e->n)
		if (e->t != fa) dfs(e->t, u);
	br[rr[u] = ++Br] = u;
}

void add(int a, int b, int c)
{
	*eptr = (elem){b, c, stk[a]}, stk[a] = eptr++;
	*eptr = (elem){a, c, stk[b]}, stk[b] = eptr++;
}

int find(int x) { return ufs[x] == x ? x : ufs[x] = find(ufs[x]); }

void tarjan(int u, int fa)
{
	ufs[u] = u;
	for (elem *e = stk[u]; e; e = e->n)
		if (ufs[e->t])
			lca[e->f] = find(e->t);
	for (edge *e = lst[u]; e; e = e->n)
		if (e->t != fa)
			tarjan(e->t, u), ufs[e->t] = u;
}

bool nicer(int a, int b)
{
	return hehe[xx[a]] < hehe[xx[b]] || (hehe[xx[a]] == hehe[xx[b]] && yy[a] < yy[b]);
}

void trans(int x)
{
	if (appr[x]) {
		appr[x] = 0;
		result -= (int64)v[c[x]] * w[sum[c[x]]--];
	} else {
		appr[x] = 1;
		result += (int64)v[c[x]] * w[++sum[c[x]]];
	}
}

int64 ask(int x, int y)
{
	int i, j, f; int64 res = 0;
	static int Mark, tot;
	static array mark, a;
	++Mark, tot = 0;
	for (i = x; i; i = pa[i])
		mark[i] = Mark;
	for (f = y; mark[f] < Mark; f = pa[f])
		a[++tot] = c[f];
	a[++tot] = c[f];
	for (i = x; i != f; i = pa[i])
		a[++tot] = c[i];
	sort(a + 1, a + tot + 1);
	for (i = 1; i <= tot; )
		for (j = 0, f = a[i]; a[i] == f && i <= tot; ++i)
			res += (int64)v[f] * w[++j];
	return res;
}

void dfs1(int u, int fa)
{
	edge *e; pa[u] = fa;
	for (e = lst[u]; e; e = e->n)
		if (e->t != fa) dfs1(e->t, u);
}

int main()
{
	freopen("park.in", "r", stdin);
	freopen("park.out", "w", stdout);

	int i, j, k;
	scanf("%d%d%d", &n, &m, &Q);
	for (i = 1; i <= m; ++i)
		scanf("%d", v + i);
	for (i = 1; i <= n; ++i)
		scanf("%d", w + i);
	for (i = 1; i < n; ++i) {
		int a, b;
		scanf("%d%d", &a, &b);
		link(a, b);
	}
	for (i = 1; i <= n; ++i)
		scanf("%d", c + i);

	if (n <= 20000 && m <= 20000) {
		for (dfs1(1, 0); Q--; ) {
			int t, x, y;
			scanf("%d%d%d", &t, &x, &y);
			t ? printf(fmt64"\n", ask(x, y)) : c[x] = y;
		}
		exit(0);
	}

	dfs(1, 0);
	for (i = 1, j = k = 0; i <= Br; ++i) {
		if (i > j) j += 400, ++k;
		hehe[i] = k;
	}
	REP(i, Q) {
		int a, b;
		scanf("%d%d%d", &j, &a, &b);
		if (ll[a] > ll[b]) swap(a, b);
		if (rr[a] < ll[b])
			xx[i] = rr[a], yy[i] = ll[b];
		else
			xx[i] = ll[a], yy[i] = ll[b];
		x[i] = a, y[i] = b, p[i] = i;
		add(x[i], y[i], i);
	}
	tarjan(1, 0);

	sort(p, p + Q, nicer);
	int ll = 0, rr = 0;
	REP(i, Q) {
		int u = p[i];
		int l = xx[u], r = yy[u];
		if (ll < l)
			for (j = ll; j < l; ++j) trans(br[j]);
		else if (ll > l)
			for (j = l; j < ll; ++j) trans(br[j]);
		if (rr > r)
			for (j = rr; j > r; --j) trans(br[j]);
		else if (rr < r)
			for (j = r; j > rr; --j) trans(br[j]);
		ans[u] = result;
		if (lca[u] != x[u] && lca[u] != y[u])
			ans[u] += (int64)v[c[lca[u]]] * w[sum[c[lca[u]]] + 1];
		ll = l, rr = r;
	}
	REP(i, Q)
		printf(fmt64"\n", ans[i]);
}

70分树分块：

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

#define REP(i, n) for (i = 0; i < (n); ++i)
#define FER(i, j) for (i = lst[j]; i; i = i->n)
#define int64 long long
#ifdef WIN32
#define fmt64 "%I64d"
#else
#define fmt64 "%lld"
#endif
#define oo 0x13131313
#define maxn 90002
#define BLOCK 300

using namespace std; double now;

template<class T> void read(T &x)
{
	char c = getchar();
	for (; '0' > c || c > '9'; c = getchar());
	x = c - '0', c = getchar();
	for (; '0' <= c && c <= '9'; c = getchar())
		x = x * 10 + c - '0';
}

int n, m, Q, w[maxn], c[maxn]; short Mod[maxn]; int64 v[maxn];
int pa[maxn], size[maxn], ufs[maxn], dep[maxn], dfn[maxn], Dfn, ca[maxn];
int F, f, mark[maxn], tot, a[maxn], Mark;
int64 buf[maxn * BLOCK], *buft = buf, *ans[maxn], *Ans;

struct edge { int t; edge *n; } edges[maxn * 2], *adj = edges, *lst[maxn], *fr[maxn];
struct block { int a[BLOCK]; } blocks[maxn + BLOCK], *btot = blocks;
struct array { block *a[BLOCK]; int operator[](int); } sum[maxn];

int array::operator[](int b) { return --b, a[b / BLOCK]->a[Mod[b]]; }

void inherit(array &a, array &b, int pos)
{
	block *&p = a.a[--pos / BLOCK];
	memcpy(&a, &b, sizeof(array)), memcpy(btot, p, sizeof(block));
	p = btot++, ++p->a[Mod[pos]];
}

int find(int x)
{
	int f, g;
	for (f = x; ufs[f] != f; f = ufs[f]);
	for (; ufs[x] != x; x = g) g = ufs[x], ufs[x] = f;
	return f;
}

void dfs(int u, int fa)
{
	edge *e; int f = -1;
	inherit(sum[u], sum[fa], c[u]), dep[u] = dep[fa] + 1, dfn[u] = ++Dfn;
	FER(e, u) if (e->t != fa)
	{
		dfs(e->t, u), fr[e->t] = e, pa[e->t] = u;
		if (!~f || size[f] + size[e->t] > BLOCK << 1)
			f = e->t;
		else
			size[f] += size[e->t], ca[f] = u, ufs[e->t] = f;
	}
	ca[u] = ufs[u] = u, size[u] = 1;
	if (~f && size[f] < BLOCK)
		size[u] += size[f], ufs[f] = u;
}

void bfs(int S)
{
	static int q[maxn]; int h, t; edge *e;
	for (q[h = t = S] = 0; h; h = q[h])
	{
		Ans[h] = Ans[pa[h]] + v[c[h]] * w[sum[F][c[h]] - (sum[f][c[h]] << 1) + sum[h][c[h]] + (c[f] == c[h])];
		FER(e, h) if (e->t != pa[h]) q[t = q[t] = e->t] = 0;
	}
}

void init()/*pretreat for the answers between blocks*/
{
	int i, j; edge *e;
	REP(i, BLOCK) sum->a[i] = btot++;
	dfs(1, 0);
	fprintf(stderr, "%.2lf\n", (clock() - now) / CLOCKS_PER_SEC);
	REP(i, n) if (find(i + 1) == i + 1)
	{
		F = f = ca[i + 1];
		if (ans[f]) continue;
		buft += n, Ans = ans[f] = buft - n - 1;
		Ans[f] = v[c[f]] * w[1];
		FER(e, f) if (e->t != pa[f]) bfs(e->t);
		for (j = f; fr[j]; j = f)
		{
			f = pa[j];
			Ans[f] = Ans[j] + v[c[f]] * w[sum[F][c[f]] - sum[f][c[f]] + 1];
			for (e = fr[j]->n; e; e = e->n)
				if (e->t != pa[f]) bfs(e->t);
		}
	}
}

int64 ask(int x, int y)
{
	int i, j, f; int64 res = 0; ++Mark, tot = 0;
	for (i = x; i; i = pa[i]) mark[i] = Mark;
	for (f = y; mark[f] < Mark; f = pa[f]) a[++tot] = c[f];
	a[++tot] = c[f];
	for (i = x; i != f; i = pa[i]) a[++tot] = c[i];
	sort(a + 1, a + tot + 1);
	for (i = 1; i <= tot; )
		for (j = 0, f = a[i]; a[i] == f && i <= tot; ++i)
			res += v[f] * w[++j];
	return res;
}

void Dfs(int u, int fa)
{
	edge *e; pa[u] = fa;
	for (e = lst[u]; e; e = e->n)
		if (e->t != fa) Dfs(e->t, u);
}

void input()
{
	int i; scanf("%d%d%d", &n, &m, &Q);
	REP(i, m) read(v[i + 1]);
	REP(i, n) read(w[i + 1]), Mod[i] = i % BLOCK;
	REP(i, n - 1)
	{
		int a, b; read(a), read(b);
		*adj = (edge){b, lst[a]}, lst[a] = adj++;
		*adj = (edge){a, lst[b]}, lst[b] = adj++;
	}
	REP(i, n) read(c[i + 1]);
	if (n <= 20000 && m <= 20000)
	{
		for (Dfs(1, 0); Q--; )
		{
			int t, x, y; read(t), read(x), read(y);
			t ? printf(fmt64"\n", ask(x, y)) : c[x] = y;
		}
		exit(0);
	}
}

int LCA(int x, int y)
{
	for (; x != y; )
		ufs[x] == ufs[y] ?
			dep[x] > dep[y] ? x = pa[x] : y = pa[y] :
			dep[ufs[x]] > dep[ufs[y]] ? x = pa[ufs[x]] : y = pa[ufs[y]];
	return x;
}

int main()
{
	freopen("park.in", "r", stdin);
	freopen("park.out", "w", stdout);

	now = clock();
	input();
	init();
	fprintf(stderr, "%.2lf\n", (clock() - now) / CLOCKS_PER_SEC);
	for (; Q--; )
	{
		int t, x, y; read(t), read(x), read(y);
		if (!t) exit(0); if (dfn[y] < dfn[x]) swap(x, y);
		int f = ca[ufs[x]], g = LCA(x, y);
		int64 Ans = ans[f][y];
		if (dep[f] < dep[g])
		{
			for (t = pa[g]; t != pa[f]; t = pa[t])
				Ans -= v[c[t]] * w[sum[y][c[t]] - sum[t][c[t]] + 1];
			f = g;
		}
		for (t = x; t != f; t = pa[t])
			Ans += v[c[t]] * w[sum[y][c[t]] - (sum[g][c[t]] << 1) + sum[t][c[t]] + (c[g] == c[t])];
		printf(fmt64"\n", Ans);
	}
	fprintf(stderr, "%.2lf\n", (clock() - now) / CLOCKS_PER_SEC);
}


JerryDung
关注
专栏目录
#58. 【WC2013】糖果公园
二次元的coding生活
04-20 144
给出一棵n个节点的树，每个节点都有一种颜色c[i]。 q次询问[l,r]路径上的点的权值和vjwi。每一个节点的权值就是当前节点的颜色值v[c[i]]和从l到该节点经过该颜色的次数num[c[i]]对应的w值w[num[c[i]]之间的乘积（很绕，看题目描述吧，懒得描述了) 这是树上莫队。分块是对子树进行。如果一个某一个子树的size满足块大小，则分成一块。 void dfs1(int t, int f){ sz[t]=1; fa[t] = f; dp[t] = dp[f]+1; ...
洛谷 P4047 [WC2013] 糖果公园 题解
glorious_dream的博客
09-21 438
洛谷 P4047 [WC2013] 糖果公园 题解
[WC2013]糖果公园
weixin_33811961的博客
03-24 162
#include<bits/stdc++.h> #define il inline #define reg register int #define numb (ch^'0') using namespace std; typedef long long ll; il void rd(int &x){ char ch;bool fl=false; ...
UOJ #58 糖果公园
weixin_33737134的博客
04-21 165
Candyland 有一座糖果公园，公园里不仅有美丽的风景、好玩的游乐项目，还有许多免费糖果的发放点，这引来了许多贪吃的小朋友来糖果公园玩。 糖果公园的结构十分奇特，它由n个游览点构成，每个游览点都有一个糖果发放处，我们可以依次将游览点编号为1至n。有n−1条双向道路连接着这些游览点，并且整个糖果公园都是连通的，即从任何一个游览点出发都可以通过这些道路到达公园里的所有其它游览点。 ...
BZOJ3052: [wc2013]糖果公园
wxh010910
02-28 769
Description Input Output Sample Input Sample Input Sample Output 84 131 27 84 HINT Source 树上带修莫队 树上莫队?用类似于括号序列的东西搞到序列上 注意分类讨论x和y互为祖先的情况 带修莫队?
2013NOI冬令营试卷
03-27
本文是对2013年全国青少年信息学奥林匹克冬令营试卷的介绍，该试卷中包含两个主要问题：平面区域划分问题和糖果公园问题。在平面区域划分问题中，需要处理与图论相关的算法设计，而糖果公园问题则涉及图的遍历以及...
树上莫队算法
KuribohG
11-24 1万+
继续回来写博客……记录点有意思的题目什么的。
根号算法杂谈_杨志灿.ppt
09-14
例如THUSC2012的“森林旅店”，WC2013的“糖果公园”，SDOI2013的“森林”等，都是可以通过根号算法解决的实例。这些题目可能涉及到查找序列中的众数、计算区间内幸运数的数量，或者处理线性规划问题等。 对于无...
【BZOJ 3052】 [wc2013]糖果公园
Regina8023
01-28 1471
带修改的树上莫队~
[bzoj3052] [WC2013]糖果公园
weixin_30673715的博客
01-21 128
Description Input Output Sample Input 4 3 5 1 9 2 7 6 5 1 2 3 3 1 3 4 1 2 3 2 1 1 2 1 4 2 0 2 1 1 1 2 1 4 2 Sample Output 84 131 27 84 Solution 前置：浅谈莫队 带修改莫队+树上莫队模板题。 我这里的分块方法是在欧拉序上分块，块的大小为\(n^{\fr...
[bzoj3052][WC2013]糖果公园
不来也不去的一只失忆蝴蝶
05-09 2130
题目大意给定一颗n个结点的树。每个结点有一种颜色。颜色种类为m。 一条路径的价值定义为 ∑i=1mw[cnt[i]]∗v[i]\sum_{i=1}^mw[cnt[i]]*v[i] 其中cnt[i]表示这条路径上颜色i出现的次数。 现有q个操作，每个操作要么是询问一条路径的价值，要么是将一个结点的颜色种类修改。带修改莫队这是树上莫队，我们接下来只讨论序列莫队，树上莫队可以转化为序列莫队。 带
「BZOJ3052」「WC2013」糖果公园
infinity_edge的博客
12-26 359
DescriptionCandyland 有一座糖果公园，公园里不仅有美丽的风景、好玩的游乐项目，还有许多免费糖果的发放点，这引来了许多贪吃的小朋友来糖果公园玩。糖果公园的结构十分奇特，它由 nn 个游览点构成，每个游览点都有一个糖果发放处，我们可以依次将游览点编号为 11 至 nn 。有 n−1n−1 条双向道路连接着这些游览点，并且整个糖果公园都是连通的，即从任何一个游览点出发都可以通过这些道路
BZOJ 3052 [wc2013]糖果公园 树上莫队
-Claude
08-06 2094
BZOJ 3052 [wc2013]糖果公园 树上莫队
【BZOJ】【P3052】【wc2013】【糖果公园】【题解】【树上莫队】
退役狗的专栏
12-24 2016
传送门:http://www.lydsy.com/JudgeOnline/problem.php?id=3052 学长好强啊！！感觉学长的代码比vfk的代码可读性好多了 http://hzwer.com/5250.html Code: #include using namespace std; const int maxn=1e5+5; typedef long long LL; int n
P4074-[WC2013]糖果公园【树上带修莫队】
QuantAsk
08-10 194
正题 题目链接:https://www.luogu.com.cn/problem/P4074 题目大意 nnn个点的一颗数，第iii个点有一颗cic_ici​种类的糖。 第iii次获得jjj种类的糖可以产生价值wi∗vjw_i*v_jwi​∗vj​。 每次操作 修改一个点的糖果种类 询问一个路径的价值和 解题思路 用欧拉序可以做到在树上进行莫队，然后带修即可。 codecodecode #include<cstdio> #include<cstring> #include&
[斜率优化] 特别行动队 commando
热门推荐
drj
10-18 1万+
特别行动队 【问题描述】 你有一支由 n 名预备役士兵组成的部队，士兵从 1 到 n 编号，要将他们拆分成若干特别行动队调入战场。出于默契的考虑，同一支特别行动队中队员的编号应该连续，即为形如(i, i + 1, …, i + k)的序列。 编号为 i 的士兵的初始战斗力为 xi ，一支特别行动队的初始战斗力 x 为队内士兵初始战斗力之和，即 x = xi + xi+1 + … + xi+k。 通
wc2013 刘汝佳 课件
最新发布
01-01
wc2013 刘汝佳 课件是指2013年网络编程世界杯亚搏手机app下载大赛中刘汝佳选手的课件。刘汝佳是中国顶尖的亚搏手机app下载选手，他在网络编程方面有着卓越的能力和经验。 在这个赛事中，刘汝佳的课件展示了他对于网络编程的理解和实践经验。这些课件通常包括技术原理、代码示例、实际案例等内容，以帮助其他亚搏手机app下载选手更好地学习和应用他的编程技术。 wc2013 刘汝佳 课件可能包含了以下方面的内容： 1. 网络编程基础知识：介绍网络编程的基础概念、通信协议、Socket编程等内容。 2. 高级网络编程技术：讲解网络编程的高级技术，如多线程编程、异步编程、并发处理等。 3. 网络安全和防护：分享网络编程中的安全问题和解决方案，如防火墙、加密通信等。 4. 实战案例分享：分享刘汝佳在实际项目中应用网络编程的案例，帮助其他选手理解如何将网络编程应用到实际项目中。 通过学习刘汝佳的课件，亚搏手机app下载选手可以获得更深入的网络编程知识和实践经验，提升自己的编程水平。wc2013 刘汝佳 课件不仅是亚搏手机app下载学习的宝贵资料，也是其他亚搏手机app下载选手相互交流和学习的重要资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值