当前位置： 首页 > news >正文

20260615 - 简单树上问题（直径重心dfn） 总结

news 2026/6/15 21:57:10

真的是简单吗？真的是简单吗？真的简单吗？？？

你们没人觉得，过题比例严重失衡吗，前四题都简单，后面的顺序完全乱啊？？

唉不是，这个 J 有 2000？这个 J 有 2000？这个 J 有 2000？这个 J 有 2000？我能切 2000？我能切 2000？我能切 2000？这个 J 我说评 1500 一点都不过分甚至还高了啊，诡异不。

嗯，由于我根本没听课所以，没有对知识点的讲解，直接上例题。（

并非，我稍微列一些常用的小 trick 或者比较常考的知识点：

  1. 一个子树内的 dfn 序是连续的！
  2. 可以利用类似 LCA 的做法倍增求出一个点的 \(k\) 阶祖先。
  3. 任意一个点在树上的最长距离，一定是其到树的直径的两端的距离之 \(\max\)。

好吧，也不多，但这些在后面的题目里都有体现喵。

会有算法标签 Tag 和时间复杂度，吃了罚时的题会有罚时原因总结 qwq。

A - 医院设置

Tag：DFS，树的遍历，树的深度，换根 DP。

如果 \(n\) 给到 \(10^5\) 左右就得换根了，但是这题 \(n\) 只有 \(100\)，所以暴力枚举根然后遍历树求出答案即可。注意要对深度乘上节点人数！！

时间复杂度：\(O(n^2)\)。

戳这里看代码 
#include<bits/stdc++.h>
#define LL long long
#define UInt unsigned int
#define ULL unsigned long long
#define LD long double
#define pii pair<int,int>
#define pLL pair<LL,LL>
#define pDD pair<LD,LD>
#define fr first
#define se second
#define pb push_back
#define isr insert
#define _i128 __int128
using namespace std;
const int N = 105;
int n,a[N],Ans,dep[N];
vector<int> g[N];
int read(){int su=0,pp=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')pp=-1;ch=getchar();}while(ch>='0'&&ch<='9'){su=su*10+ch-'0';ch=getchar();}return su*pp;
}
void DFS_count(int u,int fa){dep[u]=dep[fa]+1;for(int v:g[u])if(v^fa)DFS_count(v,u);return;
}
int main(){n=read();for(int i=1;i<=n;i++){a[i]=read();int x=read(),y=read();if(x)g[i].pb(x),g[x].pb(i);if(y)g[i].pb(y),g[y].pb(i);}Ans=0x3f3f3f3f;for(int rt=1;rt<=n;rt++){dep[0]=-1,DFS_count(rt,0);int res=0;for(int i=1;i<=n;i++)res+=dep[i]*a[i];Ans=min(Ans,res);}cout<<Ans<<"\n";return 0;
}

B - Apple Tree

Tag：DFS，树的遍历，叶子结点。

发现对于在 \(u\) 节点的苹果，最后一定是掉在以 \(u\) 为根的子树的叶子结点中的一个，所以跑个 DFS 遍历一下树求出以每个节点为根的子树下有多少个叶子结点，记为 \(sz_u\)，答案就是 \(sz_x \times sz_y\)。

时间复杂度：\(O(n+q)\)。

戳这里看代码 
#include<bits/stdc++.h>
#define LL long long
#define UInt unsigned int
#define ULL unsigned long long
#define LD long double
#define pii pair<int,int>
#define pLL pair<LL,LL>
#define pDD pair<LD,LD>
#define fr first
#define se second
#define pb push_back
#define isr insert
#define _i128 __int128
using namespace std;
const int N = 2e5+5;
LL T,n,Q,sz[N];
vector<int> g[N];
LL read(){LL su=0,pp=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')pp=-1;ch=getchar();}while(ch>='0'&&ch<='9'){su=su*10+ch-'0';ch=getchar();}return su*pp;
}
void DFS(int u,int fa){sz[u]=0;int tmp=1;for(int v:g[u])if(v^fa)tmp=0,DFS(v,u),sz[u]+=sz[v];sz[u]+=tmp;return;
}
int main(){T=read();while(T--){n=read();for(int i=1;i<=n;i++)g[i].clear();for(int i=1;i<n;i++){int x=read(),y=read();g[x].pb(y),g[y].pb(x);}DFS(1,0);Q=read();while(Q--){int x=read(),y=read();LL res=sz[x]*sz[y];cout<<res<<"\n";}}return 0;
}

C - Vertical Paths

Tag：DFS，树的遍历，叶子结点。

发现路径数量至少得是叶子结点数量，而又能构造出路径数量恰好为叶子结点数量的情况。具体构造就是，枚举每个叶子结点，往上沿着父亲爬，直到父节点已经被选入某条路径，那么剩下的部分也肯定已经被选入，就可以中断当前这条路径了。可以证明这样构造最终一定能完美覆盖所有节点。

时间复杂度：\(O(n)\)。

戳这里看代码 
#include<bits/stdc++.h>
#define LL long long
#define UInt unsigned int
#define ULL unsigned long long
#define LD long double
#define pii pair<int,int>
#define pLL pair<LL,LL>
#define pDD pair<LD,LD>
#define fr first
#define se second
#define pb push_back
#define isr insert
#define _i128 __int128
using namespace std;
const int N = 2e5+5;
int T,n,fa[N],Rt,sum,id;
bool vis[N],flag[N];
vector<int> g[N],ln[N];
int read(){int su=0,pp=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')pp=-1;ch=getchar();}while(ch>='0'&&ch<='9'){su=su*10+ch-'0';ch=getchar();}return su*pp;
}
void DFS_sol(int u){int add=1;for(int v:g[u])if(v^fa[u])add=0,DFS_sol(v);sum+=add;if(add)flag[u]=1;return;
}
int main(){T=read();while(T--){n=read();for(int i=1;i<=n;i++)g[i].clear(),flag[i]=0,vis[i]=0,ln[i].clear();for(int i=1;i<=n;i++){fa[i]=read();if(fa[i]==i)Rt=i;else g[fa[i]].pb(i),g[i].pb(fa[i]);}sum=0;DFS_sol(Rt);id=0;for(int st=1;st<=n;st++)if(flag[st]){int u=st;++id;while(!vis[u])vis[u]=1,ln[id].pb(u),u=fa[u];}cout<<sum<<"\n";for(int i=1;i<=sum;i++){cout<<ln[i].size()<<"\n";for(int j=ln[i].size()-1;j>=0;j--)cout<<ln[i][j]<<" ";cout<<"\n";}cout<<"\n\n";}return 0;
}

D - Brain Network (medium)

Tag：DFS，树的遍历，树的直径。

任意两个节点之间的最大距离，那不就是直径吗？两次 DFS 求出树的直径，长度便是答案。

题目前面没说清楚是树，我还以为是图，吓哭了。

时间复杂度：\(O(n)\)。

戳这里看代码 
#include<bits/stdc++.h>
#define LL long long
#define UInt unsigned int
#define ULL unsigned long long
#define LD long double
#define pii pair<int,int>
#define pLL pair<LL,LL>
#define pDD pair<LD,LD>
#define fr first
#define se second
#define pb push_back
#define isr insert
#define _i128 __int128
using namespace std;
const int N = 1e5+5;
int n,m,st,dis[N],res;
bool vis[N];
vector<int> g[N];
int read(){int su=0,pp=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')pp=-1;ch=getchar();}while(ch>='0'&&ch<='9'){su=su*10+ch-'0';ch=getchar();}return su*pp;
}
void DFS(int u){for(int v:g[u])if(!vis[v])vis[v]=1,dis[v]=dis[u]+1,DFS(v);return;
}
int main(){n=read(),m=read();for(int i=1;i<=m;i++){int x=read(),y=read();g[x].pb(y),g[y].pb(x);}for(int i=1;i<=n;i++)vis[i]=0;vis[1]=1,DFS(1);for(int i=1;i<=n;i++)if(dis[i]>dis[st])st=i;for(int i=1;i<=n;i++)vis[i]=0;dis[st]=0,vis[st]=1,DFS(st);for(int i=1;i<=n;i++)res=max(res,dis[i]);cout<<res<<"\n";return 0;
}

E - Count Descendants

Tag：DFS，树的遍历，dfn，二分查找。

罚时原因：

  1. 没对 dfn 排序。
  2. 没改过来。
  3. 没改过来。

感觉是很吃脑电波的一道题，想通了简单的要命，想不明白就难得要死。

首先需要转化题意，发现题目给的 \(u\) 和 \(k\) 本质上就是让我们求出以 \(u\) 为根的子树内有多少个深度为 \(k\) 的节点（可能为 \(0\) 且根节点深度为 \(0\)）。哦，此时你直接做就会发现完全无从下手，啊，是因为你句子的顺序问题，反过来看看，求深度为 \(k\) 的节点有多少个在以 \(u\) 为根的子树内。

啊？？这不就做完了吗？？你把各种深度的节点的编号存下来，发现一个子树内的 dfn 是连续的，那么存上节点的 dfn 值，排序，就可以二分查找找到这些深度的点中有多少个属于当前子树了。

所以我说想打好 OI 语文也是有必要的（？）关键时刻把句子反过来能救命。

时间复杂度：\(O(n \log n + Q \log n)\)。

戳这里看代码 
#include<bits/stdc++.h>
#define LL long long
#define UInt unsigned int
#define ULL unsigned long long
#define LD long double
#define pii pair<int,int>
#define pLL pair<LL,LL>
#define pDD pair<LD,LD>
#define fr first
#define se second
#define pb push_back
#define isr insert
#define _i128 __int128
using namespace std;
const int N = 2e5+5;
int n,Fa[N],Q,dep[N];
int Cnt,st[N],ed[N];
vector<int> g[N],d[N];
int read(){int su=0,pp=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')pp=-1;ch=getchar();}while(ch>='0'&&ch<='9'){su=su*10+ch-'0';ch=getchar();}return su*pp;
}
void DFS(int u,int fa){st[u]=++Cnt,dep[u]=dep[fa]+1;for(int v:g[u])DFS(v,u);ed[u]=Cnt;return;
}
int main(){n=read();for(int i=2;i<=n;i++)Fa[i]=read(),g[Fa[i]].pb(i);dep[0]=-1,DFS(1,0);for(int u=1;u<=n;u++)d[dep[u]].pb(st[u]);for(int i=0;i<=n;i++)sort(d[i].begin(),d[i].end());Q=read();while(Q--){int u=read(),k=read();int x=lower_bound(d[k].begin(),d[k].end(),st[u])-d[k].begin();int y=upper_bound(d[k].begin(),d[k].end(),ed[u])-d[k].begin();cout<<max(0,y-x)<<"\n";}return 0;
}

F - A Wide, Wide Graph

Tag：DFS，树的遍历，树的直径，树的直径的性质。

首先需要通过大眼观察法或者大力猜猜猜法或者直觉大法，发现分成的集合中，有且仅有一个含有多个元素，其他集合都只有一个点。证明太难了（？），跳过。

为什么一个点会被孤立呢，那当然是因为不存在节点与它的距离超过 \(k\) 啦。根据树的直径的性质「任意一个点在树上的最长距离，一定是其到树的直径的两端的距离之 \(\max\)」，我们可以把树的直径拉出来，分别从两头出发跑两次 DFS 求出两个 \(dis\) 数组，即可得到距离每个节点最远的长度是多少。简单开个桶记录一下，算个前缀和就结束了。

时间复杂度：\(O(n)\)，但是有 \(5\) 左右的常数。

戳这里看代码 
#include<bits/stdc++.h>
#define LL long long
#define UInt unsigned int
#define ULL unsigned long long
#define LD long double
#define pii pair<int,int>
#define pLL pair<LL,LL>
#define pDD pair<LD,LD>
#define fr first
#define se second
#define pb push_back
#define isr insert
#define _i128 __int128
using namespace std;
const int N = 1e5+5;
int n,X,Y,dis[N],dep[N],t[N];
vector<int> g[N];
int read(){int su=0,pp=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')pp=-1;ch=getchar();}while(ch>='0'&&ch<='9'){su=su*10+ch-'0';ch=getchar();}return su*pp;
}
void DFS(int u,int fa){dis[u]=dis[fa]+1;for(int v:g[u])if(v^fa)DFS(v,u);return;
}
void DFS_(int u,int fa){dep[u]=dep[fa]+1;for(int v:g[u])if(v^fa)DFS_(v,u);return;
}
int main(){n=read();for(int i=1;i<n;i++){int x=read(),y=read();g[x].pb(y),g[y].pb(x);}dis[0]=-1;DFS(1,0);for(int i=1;i<=n;i++)if(dis[i]>dis[X])X=i;dis[0]=-1;DFS(X,0);for(int i=1;i<=n;i++)if(dis[i]>dis[Y])Y=i;dep[0]=-1;DFS_(Y,0);for(int i=1;i<=n;i++)if(i!=Y)t[max(dis[i],dep[i])+1]++;for(int i=1;i<=n;i++)t[i]+=t[i-1];for(int i=1;i<=n;i++)cout<<t[i]+1<<" ";cout<<"\n";return 0;
}

G - Tree Queries

Tag：DFS，树的遍历，dfn。

依旧脑电波。所以那个性质你们是怎么观察出来的啊 T^T，根本不是鸭子能想到的东西啊 /dk。

首先是脑电波的操作，需要大力观察，发现想要距离每个 \(v_i\) 都不超过 \(1\) 的话，必须满足 \(v_i\) 的父节点（根的父节点是自己！）在路径上。

因为自己在路径上的话父节点也一定得在路径上，而距离为 \(1\) 也当且仅当对应路径上节点为自己的父节点、自己是路径上节点的儿子的情况。

哦，那就好做了，把它们的父节点拉出来，看能不能找到一条链串起来就行了。可以用子树 dfn 区间的包含关系来判断，按左端点升序排序，任何一个没包含上的就 NO，全能包含上就是 YES。

时间复杂度：\(O(n + \sum k \log \sum k)\)。

戳这里看代码 
#include<bits/stdc++.h>
#define LL long long
#define UInt unsigned int
#define ULL unsigned long long
#define LD long double
#define pii pair<int,int>
#define pLL pair<LL,LL>
#define pDD pair<LD,LD>
#define fr first
#define se second
#define pb push_back
#define isr insert
#define _i128 __int128
using namespace std;
const int N = 2e5+5;
int n,Q,Fa[N];
int Cnt,st[N],ed[N];
vector<int> g[N];
int read(){int su=0,pp=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')pp=-1;ch=getchar();}while(ch>='0'&&ch<='9'){su=su*10+ch-'0';ch=getchar();}return su*pp;
}
void DFS_dfn(int u,int fa){st[u]=++Cnt,Fa[u]=fa;for(int v:g[u])if(v^fa)DFS_dfn(v,u);ed[u]=Cnt;return;
}
bool cmp(int x,int y){return st[x]<st[y];}
int main(){n=read(),Q=read();for(int i=1;i<n;i++){int x=read(),y=read();g[x].pb(y),g[y].pb(x);}DFS_dfn(1,1);while(Q--){int k=read();vector<int> d;d.clear();for(int i=1;i<=k;i++)d.pb(Fa[read()]);sort(d.begin(),d.end(),cmp);bool flag=1;for(int i=1;i<d.size();i++){auto u=d[i-1],v=d[i];if(st[u]>st[v]||ed[u]<ed[v])flag=0;}if(flag)cout<<"YES\n";else cout<<"NO\n";}return 0;
}

H - Exactly K Steps

Tag：DFS，树的遍历，倍增，树的直径，树的直径的性质。

这道题确实没啥难的吧大概就是想起来树的直径的性质就可以过掉了。

直接做是非常麻烦的，此时我们需要回忆起树的直径的性质：任意一个点在树上的最长距离，一定是其到树的直径的两端的距离之 \(\max\)。把直径拉出来，从两端分别跑一次 DFS，类似求 LCA 那样倍增算两个 \(f\) 数组以便后续使用。查询的时候，直接从两个 \(f\) 数组开始都跳，只要其中一个得到了答案那么就输出，如果两边都没有答案说明不存在（根据性质），输出 -1 即可。

时间复杂度：\(O(n \log n + Q \log n)\)。

戳这里看代码 
#include<bits/stdc++.h>
#define LL long long
#define UInt unsigned int
#define ULL unsigned long long
#define LD long double
#define pii pair<int,int>
#define pLL pair<LL,LL>
#define pDD pair<LD,LD>
#define fr first
#define se second
#define pb push_back
#define isr insert
#define _i128 __int128
using namespace std;
const int N = 2e5+5;
int n,Q,dis[N],X,Y;
int f[2][N][20];
vector<int> g[N];
int read(){int su=0,pp=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')pp=-1;ch=getchar();}while(ch>='0'&&ch<='9'){su=su*10+ch-'0';ch=getchar();}return su*pp;
}
void DFS(int u,int fa){dis[u]=dis[fa]+1;for(int v:g[u])if(v^fa)DFS(v,u);return;
}
void DFS_(int u,int fa,int o){f[o][u][0]=fa;for(int i=0;f[o][u][i];i++)f[o][u][i+1]=f[o][f[o][u][i]][i];for(int v:g[u])if(v^fa)DFS_(v,u,o);return;
}
int main(){n=read();for(int i=1;i<n;i++){int x=read(),y=read();g[x].pb(y),g[y].pb(x);}dis[0]=0,DFS(1,0);for(int i=1;i<=n;i++)if(dis[i]>dis[X])X=i;dis[0]=0,DFS(X,0);for(int i=1;i<=n;i++)if(dis[i]>dis[Y])Y=i;DFS_(X,0,0);DFS_(Y,0,1);Q=read();while(Q--){int u=read(),v=u,k=read();for(int i=0;i<20;i++)if((k>>i)&1)u=f[0][u][i],v=f[1][v][i];int ans=max(u,v);if(ans)cout<<ans<<"\n";else cout<<"-1\n";}return 0;
}

I - Playing Tag on Tree

Tag：DFS，树的遍历，贪心，博弈。

披着博弈外壳的贪心，哦，感觉还是挺吃脑电波的啊。

把两个人的初始位置看作 \(A\) 和 \(B\)，那么将 \(B\) 作为根节点建出一棵树，\(A\) 的深度为 \(dep_A\)。最开始的回合，\(B\) 会往下跑去抓 \(A\)，但 \(A\) 先不用往下逃命，可以先往上跑去和 \(B\) 会和，直到 \(B\) 快抓到 \(A\) 的最后一步时掉头。

为什么要这么搞？因为如果你最开始就逃命的话，逃到最底下还是得折返上来，不优；而先跑上去挑衅（？）一下对面，之后能选择往下跑的路径长度可能还更长，一定是更优秀的。

随便跑个 DFS 求一下某个节点往下的最长链长度即可。

时间复杂度：\(O(n)\)。

戳这里看代码 
#include<bits/stdc++.h>
#define LL long long
#define UInt unsigned int
#define ULL unsigned long long
#define LD long double
#define pii pair<int,int>
#define pLL pair<LL,LL>
#define pDD pair<LD,LD>
#define fr first
#define se second
#define pb push_back
#define isr insert
#define _i128 __int128
using namespace std;
const int N = 1e5+5;
int n,A,B,dep[N];
int Fa[N],mxd[N],Ans;
vector<int> g[N];
int read(){int su=0,pp=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')pp=-1;ch=getchar();}while(ch>='0'&&ch<='9'){su=su*10+ch-'0';ch=getchar();}return su*pp;
}
void DFS_sol(int u,int fa){dep[u]=dep[fa]+1,Fa[u]=fa;for(int v:g[u])if(v^fa)DFS_sol(v,u),mxd[u]=max(mxd[u],mxd[v]+1);return;
}
int main(){n=read(),A=read(),B=read();for(int i=1;i<n;i++){int x=read(),y=read();g[x].pb(y),g[y].pb(x);}dep[0]=-1,DFS_sol(B,0);if(A==B){cout<<"0\n";return 0;}int dis=dep[A]-1,u=A;for(int i=1;i<=dis/2;i++)u=Fa[u];Ans=dis/2+(dis&1)+mxd[u];cout<<Ans<<"\n";return 0;
}

J - Propagating tree

Tag：DFS，树的遍历，dfn，树状数组（线段树）。

罚时原因：

  1. 查询时与查询节点 \(u\) 不同奇偶性的节点的赋值，使用了 \(u\) 的父节点，实际上只需要用 \(u\) 自身即可。

这个题放最后是没有任何道理的！呜呜老师这顺序坑人啊！！！

这个题 *2000 是没有任何道理的！呜呜 CF 这评级坑人啊！！！

还是 dfn 转化为区间操作，但是有加减传递效果，这个怎么做啊？？

显然只有分深度为奇数和偶数的有些不同，所以只要对其分别维护即可。开两个线段树就能做，因为是区间修改单点查询，所以也可以树状数组差分搞定。

哦，然后就结束了。

时间复杂度：\(O(n \log n + m \log n)\)。

戳这里看代码 
#include<bits/stdc++.h>
#define LL long long
#define UInt unsigned int
#define ULL unsigned long long
#define LD long double
#define pii pair<int,int>
#define pLL pair<LL,LL>
#define pDD pair<LD,LD>
#define fr first
#define se second
#define pb push_back
#define isr insert
#define _i128 __int128
using namespace std;
const int N = 2e5+5;
int n,Q,a[N],id[N],Fa[N];
int st[N],ed[N],Cnt;
int tree[N][2];
vector<int> g[N];
int read(){int su=0,pp=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')pp=-1;ch=getchar();}while(ch>='0'&&ch<='9'){su=su*10+ch-'0';ch=getchar();}return su*pp;
}
void upd(int u,int k,int o){while(u<=Cnt)tree[u][o]+=k,u+=u&-u;return;
}
void change(int l,int r,int k,int o){upd(r+1,-k,o),upd(l,k,o);return;
}
int ask(int u,int o){int sum=0;while(u)sum+=tree[u][o],u-=u&-u;return sum;
}
void DFS_init(int u,int fa){id[u]=1-id[fa],Fa[u]=fa;st[u]=++Cnt;for(int v:g[u])if(v^fa)DFS_init(v,u);ed[u]=Cnt;return;
}
int main(){n=read(),Q=read();for(int i=1;i<=n;i++)a[i+1]=read();for(int i=1;i<n;i++){int x=read()+1,y=read()+1;g[x].pb(y),g[y].pb(x);}g[1].pb(2);DFS_init(1,0);for(int i=2;i<=n+1;i++)change(st[i],st[i],a[i],id[i]);while(Q--){int opt=read();if(opt==1){int x=read()+1,k=read();change(st[x],ed[x],k,id[x]);change(st[x],ed[x],-k,1-id[x]);}else{int x=read()+1;cout<<ask(st[x],id[x])<<"\n";}}return 0;
}

总结

树的直径，主要就那个性质记牢吧，好像还有其他性质，比如加入一个点后的树的直径长度，只可能是原来的直径和新点匹配的结果。两棵树合并就是分别的直径端点匹配的结果。

树的重心，这个，不清楚，感觉今天也没咋涉及到，主要就是换根吧，换根处理好自己子树内盒子树外的情况，讨论好就简单了。

至于 dfn，其重要用途在于将树上问题转化为区间问题，以及一个子树内的节点的 dfn 是连续的，这个要记住，用树剖可以把链上的区间个数降到 \(\log\) 级别，也是很有用的。

Thanks reading.

http://www.jsqmd.com/news/1019294/

相关文章：

  • 自动驾驶货运网络：重塑物流的“钢铁驼队”
  • 从唐康林老师的NX8.5建模教程里，我总结出这5个新手最易踩的坑（附避坑指南）
  • 从零开始打造你的第一架Wi-Fi无人机：ESP-Drone开源飞控实战指南
  • 2026重庆GEO优化公司推荐推荐榜：AI搜索时代的品牌占位指南 - 信息热点
  • 2026最新自习室回本周期 3个关键因素直接影响你回本快慢
  • 通达信缠论自动化分析终极指南：三步实现智能交易可视化
  • JavaMail连接163邮箱报错‘Unsafe Login‘？手把手教你配置IMAP ID信息搞定它
  • 告别Office订阅烦恼：Ohook让你永久解锁完整功能的3个步骤
  • 大模型 API 接入与 Token 经济学实战指南
  • 终极暗黑2现代化补丁：3分钟让经典游戏焕发新生的d2dx优化方案
  • 智能抢票解决方案：Python自动化工具实战应用
  • Windows 11终极瘦身指南：Win11Debloat一键清理预装软件与隐私保护
  • 2026太原卫生间免砸砖防水、楼顶漏水、外墙渗水、地下室阳光房渗漏；专业防水公司为您排忧解难，线上质保，售后无忧。房屋漏水不再愁，24小时一站式快速维修。 - 企业资讯
  • 2026洋浦代理记账优选代办榜单，跨境供应链进出口账务专业财税机构 - 信息热点
  • Unlock Music终极指南：浏览器内音乐格式转换实战
  • 2026最新推荐 英语教师群体广泛使用的实用英语听说软件
  • 除了清北，中科院自动化所还偏爱哪些学校的保研生？一份近三年的生源地图
  • 嵌入式ADC转换流控制：触发与重启模式详解与应用实践
  • 大麦网自动抢票脚本终极教程：三步搞定热门演出票
  • 光伏支架紧固件抗风防腐选型分析_2026 上海紧固件展
  • 际连集团：印尼公司注册代办一站式服务
  • 2026：中山坦洲镇专业除甲醛怎么选？甲醛检测治理商家避坑指南，实测对比推荐中山佰家环保 - 专注室内空气检测治理
  • PyCharm手动创建虚拟环境
  • 2026年手工聚脲源头厂家推荐榜单：防水防腐耐磨性能与施工口碑深度解析 - 品牌发掘
  • 重新定义Windows桌面边界：TranslucentTB如何重塑你的数字工作空间
  • CUDA环境配置踩坑记：手把手教你修复libcudnn_cnn_train.so.8动态库链接错误
  • VRCT：打破VRChat语言壁垒的实时翻译与语音转文字解决方案
  • LinkSwift网盘直链下载助手：九大平台免费加速终极方案
  • GHelper：华硕笔记本的轻量级性能管家，如何从系统层面释放硬件潜能
  • 嵌入式DCU图形控制器：透明度、亮度与平铺模式硬件加速解析