UOJ #261. 【NOIP2016】天天爱跑步

最新推荐文章于 2025-08-08 17:29:33 发布
转载 最新推荐文章于 2025-08-08 17:29:33 发布 · 112 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/Stump/p/7748238.html
文章标签：

#网络 #数据结构与算法

小C同学认为跑步非常有趣，于是决定制作一款叫做《天天爱跑步》的游戏。《天天爱跑步》是一个养成类游戏，需要玩家每天按时上线，完成打卡任务。

这个游戏的地图可以看作一棵包含 n 个结点和 n−1 条边的树，每条边连接两个结点，且任意两个结点存在一条路径互相可达。树上结点编号为从 1 到 n 的连续正整数。

现在有 m 个玩家，第 i 个玩家的起点为 Si，终点为 Ti。每天打卡任务开始时，所有玩家在第 0 秒同时从自己的起点出发，以每秒跑一条边的速度，不间断地沿着最短路径向着自己的终点跑去，跑到终点后该玩家就算完成了打卡任务。（由于地图是一棵树，所以每个人的路径是唯一的）

小C想知道游戏的活跃度，所以在每个结点上都放置了一个观察员。在结点 jj 的观察员会选择在第 Wj 秒观察玩家，一个玩家能被这个观察员观察到当且仅当该玩家在第 Wj 秒也正好到达了结点 j。小C想知道每个观察员会观察到多少人？

注意：我们认为一个玩家到达自己的终点后该玩家就会结束游戏，他不能等待一段时间后再被观察员观察到。即对于把结点 j 作为终点的玩家：若他在第 Wj 秒前到达终点，则在结点 j 的观察员不能观察到该玩家；若他正好在第 Wj 秒到达终点，则在结点 jj 的观察员可以观察到这个玩家。

输入格式

从标准输入读入数据。

第一行有两个整数 n 和 m。其中 n 代表树的结点数量，同时也是观察员的数量，m 代表玩家的数量。

接下来 n−1 行每行两个整数 u 和 v，表示结点 u 到结点 v 有一条边。

接下来一行 n 个整数，其中第 j 个整数为 Wj，表示结点 j 出现观察员的时间。

接下来 m 行，每行两个整数 Si 和 Ti，表示一个玩家的起点和终点。

对于所有的数据，保证 1≤Si,Ti≤n，0≤Wj≤n。

输出格式

输出到标准输出。

输出 1 行 n 个整数，第 j 个整数表示结点 j 的观察员可以观察到多少人。

样例一

input
6 3
2 3
1 2
1 4
4 5
4 6
0 2 5 1 2 3
1 5
1 3
2 6
output
2 0 0 1 1 1
explanation

对于 1 号点，W1=0，故只有起点为 1 号点的玩家才会被观察到，所以玩家 1 和玩家 2 被观察到，共 2 人被观察到。

对于 2 号点，没有玩家在第 2 秒时在此结点，共 0 人被观察到。

对于 3 号点，没有玩家在第 5 秒时在此结点，共 0 人被观察到。

对于 4 号点，玩家 1 被观察到，共 1 人被观察到。

对于 5 号点，玩家 1 被观察到，共 1 人被观察到。

对于 6 号点，玩家 3 被观察到，共 1 人被观察到。

样例二

input
5 3
1 2
2 3
2 4
1 5
0 1 0 3 0
3 1
1 4
5 5
output
1 2 1 0 1

限制与约定

每个测试点的数据规模及特点如下表所示。提示：数据范围的个位上的数字可以帮助判断是哪一种数据类型。

测试点编号n
m约定
1=991=991所有人的起点等于自己的终点，即 Si=Ti
2
3=992=992Wj=0
4
5=993=993
无
6=99994=99994树退化成一条链，其中 1 与 2 有边，2 与 3 有边，……，n−1 与 n 有边
7
8
9=99995=99995所有的 Si=1
10
11
12
13=99996=99996所有的 Ti=1
14
15
16
17=99997=99997无
18
19
20=299998=299998

时间限制：2s

空间限制：512MB

下载

样例数据下载

题目连接:http://uoj.ac/problem/261

解题报告:

从一开始自己YY玄学做法(在线处理，复杂度O(kmlogn)，k特别玄学，期望值为4~5，可能会退化成n)，到卡常数，到fread()和动态开空间(吐血).

最后还是认认真真看题解，写正解(离线处理，复杂度O(mlogn+n)).

树上差分+桶维护.

先将一条路径(s,t)拆成向上(s,lca)和向下(lca,t)的两条路径，

对于向上路径，路径的点x满足dep[x]+w[x]=dep[s]，则可以被观察到，在s点把dep[s]放入对应桶中，lca处取出.

同理对于向下的路径，在t点把2*dep[l]-dep[s]放入桶中，lca处取出.

dfs统计差分和.

玄学做法

#include<cstdio>
#include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
#define BIG 600005
#define ll long long
#define FOR(i,s,t) for(register int i=s;i<=t;++i)
using namespace std;
const int N=BIG>>1;
int nxt[BIG],to[BIG],las[N],w[N],ans[N],
	sz[N],dep[N],f[N],top[N],xu[BIG],sign[BIG];
vector<int>v1[BIG],v2[BIG];
int n,m,x,y,dfn,l,t,need,tot;
inline void read(int &x){
	char c;
	while(c=getchar(),c>'9'||c<'0');
	x=c-48;
	while(c=getchar(),c>='0'&&c<='9')x=(x<<1)+(x<<3)+c-48;
	return ;
}
inline void add(int x,int y){
	nxt[++tot]=las[x];
	las[x]=tot;
	to[tot]=y;
	return;
}
inline void dfs1(int now){
	sz[now]=1;
	for(register int e=las[now];e;e=nxt[e])
		if(!dep[to[e]]){
			dep[to[e]]=dep[now]+1;
			f[to[e]]=now;
			dfs1(to[e]);
			sz[now]+=sz[to[e]];
		}
	return;
}
inline void dfs2(int now,int chain){
	top[now]=chain;
	xu[now]=++dfn;
	register int i=0;
	for(register int e=las[now];e;e=nxt[e])
		if(sz[to[e]]>sz[i]&&to[e]!=f[now])
			i=to[e];
	if(!i)
		return;
	dfs2(i,chain);
	for(register int e=las[now];e;e=nxt[e])
		if(to[e]!=f[now]&&to[e]!=i)
			dfs2(to[e],to[e]);
	return;
} 
inline int lca(int x,int y){
	for(;top[x]!=top[y];dep[top[x]]>dep[top[y]]?x=f[top[x]]:y=f[top[y]]);
	return dep[x]<dep[y]?x:y;
}
inline void find(int goal,int x,int l){
	if(xu[goal]<xu[l]||xu[goal]>xu[x]||dep[goal]>dep[x])
		return; 	 
	for(;top[x]!=top[l];){
		if(xu[top[x]]<=xu[goal]&&xu[goal]<=xu[x]){
			++ans[goal];
			return;
		}
		x=f[top[x]];
	}
	if(xu[l]<=xu[goal]&&xu[goal]<=xu[x])
		++ans[goal];
	return;
}
inline void dfs3(int now){
	for(register int e=las[now];e;e=nxt[e])
		if(to[e]!=f[now]){
			dfs3(to[e]);
			sign[now]+=sign[to[e]];
		}
	return;
}
int wr[51];
inline void write(int x){
	if(!x)
		putchar(48);
	else{
		while(x)
			wr[++wr[0]]=x%10,x/=10;
		while(wr[0])
			putchar(48+wr[wr[0]--]); 
	}
	putchar(' ');
}
int main(){
    read(n);
    read(m);
    FOR(i,2,n){
    	read(x);
    	read(y);
    	add(x,y);
    	add(y,x);
	}
	FOR(i,1,n)
		read(w[i]);
	dep[1]=1;
	dfs1(1);
	dfs2(1,1);
	if(n==99995){
		while(m--){
			read(x);
			read(y);
			++sign[y];
		}
		dfs3(1);
		FOR(i,1,n)
			if(w[i]==dep[i]-1)
				printf("%d ",sign[i]);
			else
				printf("0 ");
		return 0;
	}
	FOR(i,1,n){
		v1[dep[i]-w[i]+N].push_back(i);
		v2[w[i]+dep[i]].push_back(i);
	}
	while(m--){
		read(x);
		read(y);
		l=lca(x,y);
		t=dep[x]-dep[l];
		need=dep[l]-t+N;
		for(register int i=0;i<v1[need].size();++i)
			find(v1[need][i],y,l);
		need=dep[l]+t;
		for(register int i=0;i<v2[need].size();++i)
			find(v2[need][i],x,l);
		if(w[l]==t)
			--ans[l];
	}
	FOR(i,1,n)
		write(ans[i]);
    return 0;
}

　　

卡常数

 

#include<cstdio>
#include<iostream>
#include<vector>
#include<algorithm>
#define BIG 600005
#define ll long long
#define FOR(i,s,t) for(register int i=s;i<=t;++i)
const int N=BIG>>1;
int nxt[BIG],to[BIG],las[N],w[N],ans[N],
	sz[N],dep[N],f[N],top[N],xu[BIG],sign[BIG];
std::vector<int>v1[BIG],v2[BIG];
int n,m,x,y,dfn,l,t,need,tot,goal;
char *ch;
inline void read(int &x){
	x=0; while (*ch<'0'||*ch>'9') ++ch;
	while (*ch>='0'&&*ch<='9') {
		x=(x<<1)+(x<<3)+*ch-48;
		++ch;
	}
}
inline void add(int x,int y){
	nxt[++tot]=las[x];
	las[x]=tot;
	to[tot]=y;
	return;
}
inline void dfs1(int now){
	sz[now]=1;
	for(register int e=las[now];e;e=nxt[e])
		if(!dep[to[e]]){
			dep[to[e]]=dep[now]+1;
			f[to[e]]=now;
			dfs1(to[e]);
			sz[now]+=sz[to[e]];
		}
	return;
}
inline void dfs2(int now,int chain){
	top[now]=chain;
	xu[now]=++dfn;
	register int i=0;
	for(register int e=las[now];e;e=nxt[e])
		if(sz[to[e]]>sz[i]&&to[e]!=f[now])
			i=to[e];
	if(!i)
		return;
	dfs2(i,chain);
	for(register int e=las[now];e;e=nxt[e])
		if(to[e]!=f[now]&&to[e]!=i)
			dfs2(to[e],to[e]);
	return;
} 
inline int lca(int x,int y){
	for(;top[x]!=top[y];dep[top[x]]>dep[top[y]]?x=f[top[x]]:y=f[top[y]]);
	return dep[x]<dep[y]?x:y;
}
inline void find(int goal,int x,int l){	 
	for(;top[x]!=top[l];){
		if(xu[top[x]]<=xu[goal]&&xu[goal]<=xu[x]){
			++ans[goal];
			return;
		}
		x=f[top[x]];
	}
	if(xu[l]<=xu[goal]&&xu[goal]<=xu[x])
		++ans[goal];
	return;
}
inline void dfs3(int now){
	for(register int e=las[now];e;e=nxt[e])
		if(to[e]!=f[now]){
			dfs3(to[e]);
			sign[now]+=sign[to[e]];
		}
	return;
}
int wr[51];
inline void write(int x){
	if(!x)
		putchar(48);
	else{
		while(x)
			wr[++wr[0]]=x%10,x/=10;
		while(wr[0])
			putchar(48+wr[wr[0]--]); 
	}
	putchar(' ');
}
inline bool cmp(int a,int b){
	return xu[a]<xu[b];
}
int main(){
	fseek(stdin,0l,SEEK_END);
	int flen=ftell(stdin);
	fseek(stdin,0l,SEEK_SET);
	char *buffer = new char [flen+1];
	fread(buffer,1,flen,stdin);
	ch=buffer;
	
    read(n);
    read(m);
    for(register int i=2;i<=n;++i){
    	read(x);
    	read(y);
    	add(x,y);
    	add(y,x);
	}
	for(register int i=1;i<=n;++i)
		read(w[i]);
	dep[1]=1;
	dfs1(1);
	dfs2(1,1);
	if(n==99995){
		while(m--){
			read(x);
			read(y);
			++sign[y];
		}
		dfs3(1);
		FOR(i,1,n)
			if(w[i]==dep[i]-1)
				printf("%d ",sign[i]);
			else
				printf("0 ");
		return 0;
	}
	for(register int i=1;i<=n;++i){
		v1[dep[i]-w[i]+N].push_back(i);
		v2[w[i]+dep[i]].push_back(i);
	}
	for(register int i=0;i<=(N<<1)-3;++i){
		std::sort(v1[i].begin(),v1[i].end(),cmp);	
		std::sort(v2[i].begin(),v2[i].end(),cmp);
	}
	while(m--){
		read(x);
		read(y);
		l=lca(x,y);
		t=dep[x]-dep[l];
		need=dep[l]-t+N;
		for(register int i=0;i<v1[need].size();++i){
			goal=v1[need][i];
			if(xu[goal]>=xu[l]&&xu[goal]<=xu[y])
				find(goal,y,l);
			if(xu[goal]>xu[y])
				break;
		}
		need=dep[l]+t;
		for(register int i=0;i<v2[need].size();++i){
			goal=v2[need][i];
			if(xu[goal]>=xu[l]&&xu[goal]<=xu[x])
				find(goal,x,l);
			if(xu[goal]>xu[x])
				break;
		}
		if(w[l]==t)
			--ans[l];
	}
	FOR(i,1,n)
		write(ans[i]);
    return 0;
}

　　

正解

#include<cstdio>
#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
char temp[1<<24],*S=temp;
inline int read(){
	int data=0;char c=*S++;
	while(c>'9'||c<'0')c=*S++;
	while(c>='0'&&c<='9')data=(data<<1)+(data<<3)+c-'0',c=*S++;
	return data;
}
#define M 600010
#define N (M>>1)
#define ll long long
#define FOR(s,t) for(register int i=s;i<=t;++i)
#define VIS(now) for(register int e=las[now];e;e=nxt[e])
#define FR(s,t) for(register int i=s;i<t;++i)
#define fin freopen("test.in","r",stdin);
#define fout freopen("test.out","w",stdout);
int n,m,tot=1,t;
int nxt[M],las[N],to[M],w[N];
inline void add(int x,int y){
	nxt[++tot]=las[x];las[x]=tot;to[tot]=y;
}
namespace TCP{
	int dep[N],f[N],sz[N],top[N];
	inline void dfs1(int now){
		sz[now]=1;
		VIS(now)if(!dep[to[e]])
			dep[to[e]]=dep[now]+1,f[to[e]]=now,dfs1(to[e]),sz[now]+=sz[to[e]];
	}
	inline void dfs2(int now,int chain){
		top[now]=chain;
		register int i=0;
		VIS(now)if(to[e]!=f[now]&&sz[i]<sz[to[e]])i=to[e];
		if(!i)return;
		dfs2(i,chain);
		VIS(now)if(to[e]!=f[now]&&to[e]!=i)dfs2(to[e],to[e]);
	}
	inline int lca(int x,int y){
		for(;top[x]!=top[y];dep[top[x]]>dep[top[y]]?x=f[top[x]]:y=f[top[y]]);
		return dep[x]<dep[y]?x:y;
	}
};
using namespace TCP;
vector<int>qs[M<<1],qt[M<<1];
int x,y,l;
int ans[N],t1[M<<1],t2[M<<1];
inline void dfs3(int now){	
	int a=t1[dep[now]+w[now]];
	VIS(now)if(to[e]!=f[now])dfs3(to[e]);
	FR(0,qs[now].size())qs[now][i]>0?++t1[qs[now][i]]:--t1[-qs[now][i]];
	ans[now]+=t1[dep[now]+w[now]]-a;
}
inline void dfs4(int now){
	int a=t2[dep[now]-w[now]+N];
	VIS(now)if(to[e]!=f[now])dfs4(to[e]);
	FR(0,qt[now].size())qt[now][i]>0?++t2[qt[now][i]]:--t2[-qt[now][i]];
	ans[now]+=t2[dep[now]-w[now]+N]-a;
}
int main(){
	//fin;fout;
	fread(temp,1,1<<24,stdin);
	n=read(),m=read();
	FOR(2,n)x=read(),y=read(),add(x,y),add(y,x);
	FOR(1,n)w[i]=read();
	dep[1]=1;dfs1(1);dfs2(1,1);
	while(m--){
		x=read(),y=read();
		l=lca(x,y);
		qs[x].push_back(dep[x]);qs[l].push_back(-dep[x]);
		qt[y].push_back(2*dep[l]-dep[x]+N);qt[l].push_back(dep[x]-2*dep[l]-N);
		if(dep[l]+w[l]==dep[x])++ans[l];
	}
	dfs3(1);dfs4(1);
	FOR(1,n)printf("%d ",ans[i]);
	return 0;
}

　　

转载于:https://www.cnblogs.com/Stump/p/7748238.html

UOJ #593. 新年的军队 题解
莫莫 dicol 的博客
06-02 813
属实是一道神仙题，估计是去年这个时候听说了这道题，最近把这个坑填了。给后面要来写的人提个醒，这个题其实没有想象地那么恐怖，代码其实也不复杂，只是推导十分困难。我说我这篇是全网最详细的不过分吧。...
uoj#189. 【集训队互测2016】火车司机出秦川 //圆方树
蒟蒻名曰Starria
06-15 1053
uoj#189. 【集训队互测2016】火车司机出秦川 给出一棵N(≤3×10^5)个点的仙人掌，每条边有一个价值。 Q(≤3×10^5)次操作，第i次给出Ki(ΣK≤3×10^5)个点对，询问这些点对间最短或最长路径的并的价值和，每次询问后接一次对一条边价值的修改。保证所有环都是奇环。 //小半年前刷专题的时候觉得挺麻烦的就没动…最近想锻炼一下代码能力所以翻出来写了
【uoj#261】【NOIP2016】天天爱跑步
JKY00001的专栏
09-08 168
每个人可以分为往上和往下两部分，我们将向上的路径和向下的命名为第一种路径和第二种路径。 询问就是求经过某个点的，出发点深度为d-w的第一种路径数量，加上出发点深度为d+w的第二种路径的数量。 我们开个数组记录每个深度的答案。对于每条路径，我们都在下面那个点加，在上面那个点减（注意加和减都是出发点的深度上），询问就变成了求子树和。 我们可以通过dfs来求答案，dfs到一个点的时候，记下之前...
#LOJ2359 UOJ261 NOIP2016 天天爱跑步
lunch__的博客
08-28 207
题目链接 说实话一开始这个题目题解我是完全没看懂的 哪怕我把天天不爱跑步做完了也一样….. 还是对题目理解的不太清楚啊 首先把对于任意一条路径s−&gt;ts−&gt;ts->t，我们可以把它拆成s−&gt;lca(s,t)s−&gt;lca(s,t)s -> lca(s, t) 和lca(s,t)−&gt;tlca(s,t)−&gt;tlca(s, t) -> t 然后处理就会比较方...
UOJ261 【NOIP2016】天天爱跑步
dgoh41514的博客
12-17 141
本文版权归ljh2000和博客园共有，欢迎转载，但须保留此声明，并给出原文链接，谢谢合作。 本文作者：ljh2000作者博客：http://www.cnblogs.com/ljh2000-jump/转载请注明出处，侵权必究，保留最终解释权！ Description 小c同学认为跑步非常有趣,于是决定制作一款叫做《天天爱跑步》的游戏。天...
【LCA+打标记】BZOJ4719（UOJ#261） [Noip2016]天天爱跑步
linkfqy
10-18 871
题面在这里还可以双倍经验不得不说真是一道好题啊……对于路径x→yx\rightarrow y，可以拆分为x→lcax\rightarrow lca和lca→ylca\rightarrow y同时注意到，对于点i在一条往上走的路径x→yx\rightarrow y上：deepi+wi=deepx deep_i+w_i=deep_x 反之： deepi−wi=deepy−distx,y deep_i-
【uoj261】 NOIP2016—天天爱跑步
weixin_30725315的博客
12-11 92
http://uoj.ac/problem/261(题目链接) 题意 　　给出一棵树，给出一些起点和终点，没走一条路径耗费时间1，每个节点上有一个权值w，问有多少条路径经过这个节点时所用的时间恰好是w。 Solution 　　转自：http://blog.csdn.net/haarmony/article/details/53259338 　　约定第${i}$个人起终点的${lca(s...
NOIP2016D1T2 天天爱跑步 BZOJ4719 UOJ261
Lazer2001
11-08 428
大家都很强， 可与之共勉 。暴力有80，还是比较好拿的。 部分分做法很简单， 在打solve3的时候我想到了差分。 于是就有正解了。# include <bits/stdc++.h>inline int read ( ) { # define In_Len 2000005 static std :: streambuf *fb ( std :: cin.rdbuf ( ) ) ;
UOJ261 【NOIP2016】天天爱跑步 LCA+动态开点线段树
weixin_30767921的博客
07-13 123
Description 小c同学认为跑步非常有趣,于是决定制作一款叫做《天天爱跑步》的游戏。天天爱跑步是一个养成类游戏,需要玩家每天按时上线,完成打卡任务。这个游戏的地图可以看作一一棵包含 N个结点和N-1 条边的树, 每条边连接两个结点,且任意两个结点存在一条路径互相可达。树上结点编号为从1到N的连续正整数。现在有个玩家,第个玩家的起点为Si ,终点为Ti。每天打卡任务开始时,所有玩家在第...
NOIP 2016 天天爱跑步 (luogu 1600 & uoj 261) - 线段树
adx33526的博客
10-29 136
题目传送门 　　传送点I 　　传送点II 题目大意 　　(此题目不需要大意，我认为它已经很简洁了) 　　显然线段树合并(我也不知道哪来这么多显然) 　　考虑将每条路径拆成两条路径s -> lca和t -> lca。 　　对于前一种路径上的某一点i，希望在时刻w[i]经过它，那么就有 dep[s] - dep[i] = w[i] 　...
[uoj261][NOIP2016]天天爱跑步——树上差分+桶
ylsoi的博客
08-03 393
思路： 题目所要求的是每一个观测点能够看到的人的个数，所以这个观测点首先必须要在这条路径内。其次就是这个观测点和路径起点的距离要等于wiwiw_i，为了便于操作把这棵树转化成1为根的有根树，然后每一条路径就是一条折线。我们把每个点满足它可以观测到的路径的条件转化为只和路径相关，设路径起点为uuu，终点为vvv，观测点为iii，一条路通过lca分开成了两条路之后，对于上升的部分要满足这个式子：wi...
UOJ #455.【UER #8】雪灾与外卖 堆模拟费用流
beginend
02-07 488
题意 有n个人和m家商店，每个人都要买一道菜。第i个人的坐标是a[i]，第j家商店的坐标是y[i]，有c[i]道菜且每道菜价格为w[i]，每个人还要花费其到商店距离的路费，问最小花费。 n,m≤105,a[i],y[i],c[i],w[i]≤109n,m\le10^5,a[i],y[i],c[i],w[i]\le10^9n,m≤105,a[i],y[i],c[i],w[i]≤109 分析 显然可以...
UOJ #454.【UER #8】打雪仗 通信题
beginend
02-06 789
题意 有两个人Alice和Bob，现在Alice有一个长度为2n的01串，Bob有n个位于[1,2n]之间的下标，现在要求Alice和Bob之间传递信息，每次只能发送0或1，要求每人发送次数不超过m，且Bob能知道这n个下标对应的字符是什么。 n=1000,m=2000或1600或1350。 分析 m=2000当然就是Alice直接把整个串发过去啦。 考虑这样一种做法，设Bob的长度为2n的01串...
UOJ#301. 【CTSC2017】最长上升子序列（杨氏矩阵）
DZYO的博客
09-07 1090
传送门 题解： 根据Dilworth定理，最小链覆盖=最长反链。 问题转化为求kkk个最小不上升序列能覆盖的最大数的个数。 利用杨氏矩阵，我们可以轻松得到这个值。 不过注意杨氏矩阵的插入是O(n)O(n)O(n)的，这时候有个定理，就是把杨氏矩阵维护东西的大小比较方式改变一下，会得到置换原矩阵后的矩阵。 于是我们原矩阵只维护O(n−−√)O(n)O(\sqrt{n})行，查询前kkk行时我...
秋招笔记-8.6
lastXuanGod的博客
08-06 1690
昨天开组会投文章以及玩苏丹的游戏去了，今天得知不久后有面试，所以我们需要快速地过一下基本的八股和项目。
网络原理——初识
suger__salt的博客
08-06 750
网络互联网络互联指将多台计算机连接在一起，完成数据共享数据共享本质是⽹络数据传输，即计算机之间通过⽹络来传输数据，也称为⽹络通信。根据⽹络互连的规模不同，可以划分为和。局域网通过一个交换机时连接的电脑能够互联广域网游戏兴起了之后，出现了网游，这时就出现了广域网光宇网：把一大堆局域网进行相连，组成了更大的“局域网”由路由器连通，不断套娃。
网络相关面试题总结
m0_74186706的博客
08-07 1089
多字节数据在内存中的存储顺序，仅在异构计算机通信或跨网络传输时需关注。
用 “故事 + 价值观” 快速建立 IP 信任感
最新发布
ckjrxdn的博客
08-08 383
故事 + 价值观” 的组合，能快速缩短与用户的距离 —— 故事让 IP 从抽象符号变为可感知的存在，价值观则推动用户从被动关注转为主动认同，二者共同为变现筑牢信任基础。传递价值观需避免空洞口号，应融入具体行为：在知识输出中明确 “何为有价值的知识”，在用户互动中展现 “如何对待用户”，在商业行为中坚守 “变现与价值的平衡”。基于 “故事 + 价值观” 的信任，能降低变现阻力：情感认同转化为知识产品的尝试意愿，价值认同提升流量变现的接受度，深度信任则强化粉丝变现的复购与推荐动力。
NAT转化和VRRP配置
不会写代码的胖子
08-06 380
VRRP（Virtual Router Redundancy Protocol）是一种网络协议，用于在多个路由器之间提供网关冗余，确保当主网关故障时能够自动切换到备份网关，从而提高网络可靠性。在router1和router2查看主备份信息。在router1配置VRRP。在router2配置vrrp。
UOJ#435题目“Simple Tree”
05-30
UOJ#435题目“Simple Tree”要求实现一种数据结构，支持以下两种操作： 1. 修改某个节点的权值； 2. 查询某个节点到根节点路径上权值的最大值。 因为需要查询某个节点到根节点的路径，所以可以考虑使用树链剖分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值