树链剖分(合集)

最新推荐文章于 2019-10-12 14:33:18 发布
最新推荐文章于 2019-10-12 14:33:18 发布
阅读量261 收藏
点赞数
分类专栏： 数据结构 ------ 树链剖分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/noone0/article/details/77451374
版权

参考链接 点击打开链接

树链剖分通常用于处理树的形态不变 但点权/边权需要修改查询的题目


树链剖分就是把树拆成一系列链，然后用数据结构对链进行维护。

通常的剖分方法是轻重链剖分，所谓轻重链就是对于节点u的所有子结点v，size[v]最大的v与u的边是重边，其它边是轻边，其中size[v]是以v为根的子树的节点个数，全部由重边组成的路径是重路径，


性质:任意一点到根的路径上存在不超过logn条轻边和logn条重路径.

dfs时优先访问重儿子 得到dfs序.此时每条重链都是是某段区间,某个重链上的点都一一映射到该区间上.

由剖分的性质,两点间的路径上,不会超过logn条重链.则用线段树来维护这些重链.单次查询复杂度即可达到O(log^2n).


例题1:BZOJ 1036

题意:n个结点的树,每个结点有权值wi,Q次询问.n<=3e4,q<=2e5.
op1:改变结点u权值.op2:询问u-v路径中权值最大的是多少.op3:询问u-v路径权值和.

修改u,根据u的dfs序编号直接修改即可.
查询:当x-y处于不同的链中时,每次跳到链顶深度较大那一个.直到x-y处于同一条链为止.

#include <bits/stdc++.h>
using namespace std;
const int N=5e5+20;
const int M=6e5+20;
const int inf=0x3f3f3f3f;
int n,cnt,sz;
int v[N],dep[N],size[N],head[N],fa[N];
int pos[N],bl[N];
struct edge{int to,next;}e[M];
struct node{int l,r,mx,sum;}t[N];
void add_edge(int u,int v){e[++cnt].to=v,e[cnt].next=head[u],head[u]=cnt;}
void init()
{
	memset(head,-1,sizeof(head));
	scanf("%d",&n);
	int x,y;
	for(int i=1;i<=n-1;i++)
	{
		scanf("%d%d",&x,&y);
		add_edge(x,y),add_edge(y,x);
	}
	for(int i=1;i<=n;i++)	scanf("%d",&v[i]);
}
void dfs(int u)
{
	size[u]=1;
	for(int i=head[u];i!=-1;i=e[i].next)
	{
		int v=e[i].to;
		if(v==fa[u])	continue;
		dep[v]=dep[u]+1,fa[v]=u;
		dfs(v);
		size[u]+=size[v];
	}
}
void dfs(int x,int chain)
{
	int k=0;sz++;
	pos[x]=sz;//time
	bl[x]=chain;
	for(int i=head[x];i!=-1;i=e[i].next)//find heavy son
	{
		int v=e[i].to;
		if(dep[v]>dep[x]&&size[v]>size[k])
			k=v;
	}
	if(k==0)	return;
	dfs(k,chain);
	for(int i=head[x];i!=-1;i=e[i].next)
		if(dep[e[i].to]>dep[x]&&k!=e[i].to)
			dfs(e[i].to,e[i].to);//ÆäÓà¶ù×ÓÖØ¿ªÐÂÁ´. 
}
///segment tree.
void build(int o,int l,int r)
{
	t[o].l=l,t[o].r=r;
	if(l==r)	return;
	int m=l+r>>1;
	build(o<<1,l,m),build(o<<1|1,m+1,r);
}
void push_up(int o){t[o].mx=max(t[o<<1].mx,t[o<<1|1].mx),t[o].sum=t[o<<1].sum+t[o<<1|1].sum;}
void change(int o,int x,int y)
{
	int l=t[o].l,r=t[o].r,mid=l+r>>1;
	if(l==r){t[o].sum=t[o].mx=y;return;}
	if(x<=mid)	change(o<<1,x,y);
	else	change(o<<1|1,x,y);
	push_up(o);
}
int querysum(int o,int ql,int qr)
{
	int l=t[o].l,r=t[o].r,mid=l+r>>1;
	if(l>=ql&&r<=qr)	return t[o].sum;
	int res=0;
	if(ql<=mid)	res+=querysum(o<<1,ql,qr);
	if(qr>mid)	res+=querysum(o<<1|1,ql,qr);
	return res;
}
int querymx(int o,int ql,int qr)
{
	int l=t[o].l,r=t[o].r,mid=l+r>>1;
	if(l>=ql&&r<=qr)	return t[o].mx;
	int res=-inf;
	if(ql<=mid)	res=max(res,querymx(o<<1,ql,qr));
	if(qr>mid)	res=max(res,querymx(o<<1|1,ql,qr));
	return res;
}
//
int solvesum(int x,int y)
{
	int sum=0;
	while(bl[x]!=bl[y])//x,y´¦ÔÚ²»Í¬µÄÁ´ÖÐ. 
	{
		if(dep[bl[x]]<dep[bl[y]]) swap(x,y);
		sum+=querysum(1,pos[bl[x]],pos[x]);
		x=fa[bl[x]];
	}
	if(pos[x]>pos[y])	swap(x,y);
	sum+=querysum(1,pos[x],pos[y]);
	return sum;
}
int solvemx(int x,int y)
{
	int mx=-inf;
	while(bl[x]!=bl[y])
	{
		if(dep[bl[x]]<dep[bl[y]]) swap(x,y);
		mx=max(mx,querymx(1,pos[bl[x]],pos[x]));
		x=fa[bl[x]];
	}
	if(pos[x]>pos[y]) swap(x,y);
	mx=max(mx,querymx(1,pos[x],pos[y]));
	return mx;
}
void solve()
{
	build(1,1,n);
	for(int i=1;i<=n;i++)
		change(1,pos[i],v[i]);//dfs-num
	int x,y,Q;
	char ch[10];
	scanf("%d",&Q);
	while(Q--)
	{
		scanf("%s%d%d",ch,&x,&y);
		if(ch[0]=='C'){v[x]=y,change(1,pos[x],v[x]);}
		else
		{
			if(ch[1]=='M')
				printf("%d\n",solvemx(x,y));
			else
				printf("%d\n",solvesum(x,y));
		}
	}
}
int main()
{
	init();
	dfs(1);
	dfs(1,1);
	solve();
	return 0;
}

SPOJ QTREE

题意:n个结点的树,每个条边有权值wi,Q次询问.n<=3e4,q<=2e5.

op1:改变第i条边权值.op2:询问u-v路径中边权值最大的是多少


dfs序映射的是点的编号.现在修改的是边的权值.

因为是树只有n-1条边,将边(x,fa[x])用点x代替就好了.(每条边一一映射到每个点上).

ps:注意最后查询到同一条链时,此时最低点x维护的边不在路径上,需要将x跳到它的重儿子上.

#include <bits/stdc++.h>
using namespace std;
const int N=5e5+20;
const int M=6e5+20;
const int inf=0x3f3f3f3f;
int n,cnt,sz;
int w[N],dep[N],size[N],head[N],fa[N];
int pos[N],bl[N],son[N];
struct edge{int to,next,w;}e[M];
struct Edge{int u,v,w;}a[M];
struct node{int l,r,mx;}t[M];
void add_edge(int u,int v,int w){e[++cnt].to=v,e[cnt].w=w,e[cnt].next=head[u],head[u]=cnt;}
void init()
{
	sz=cnt=0;
	memset(head,-1,sizeof(head));
	scanf("%d",&n);
	int x,y,w;
	for(int i=1;i<=n-1;i++)
	{
		scanf("%d%d%d",&x,&y,&w);
		add_edge(x,y,w),add_edge(y,x,w);
		a[i].u=x,a[i].v=y,a[i].w=w;
	}
}
void dfs(int u)
{
	size[u]=1;
	for(int i=head[u];i!=-1;i=e[i].next)
	{
		int v=e[i].to;
		if(v==fa[u])	continue;
		w[v]=e[i].w;//w[v]:v-fa[v]'scost 
		dep[v]=dep[u]+1,fa[v]=u;
		dfs(v);
		size[u]+=size[v];
	}
}
void dfs(int x,int chain)
{
	int k=0;sz++;
	pos[x]=sz;//time
	bl[x]=chain;
	for(int i=head[x];i!=-1;i=e[i].next)//find heavy son
	{
		int v=e[i].to;
		if(dep[v]>dep[x]&&size[v]>size[k])
			k=v;
	}
	son[x]=k;
	if(k==0){son[x]=x;return;}
	dfs(k,chain);
	for(int i=head[x];i!=-1;i=e[i].next)
		if(dep[e[i].to]>dep[x]&&k!=e[i].to)
			dfs(e[i].to,e[i].to);//ÆäÓà¶ù×ÓÖØ¿ªÐÂÁ´. 
}
///segment tree.
void build(int o,int l,int r)
{
	t[o].l=l,t[o].r=r;
	if(l==r)	return;
	int m=l+r>>1;
	build(o<<1,l,m),build(o<<1|1,m+1,r);
}
void push_up(int o){t[o].mx=max(t[o<<1].mx,t[o<<1|1].mx);}
void change(int o,int x,int y)
{
	int l=t[o].l,r=t[o].r,mid=l+r>>1;
	if(l==r){t[o].mx=y;return;}
	if(x<=mid)	change(o<<1,x,y);
	else	change(o<<1|1,x,y);
	push_up(o);
}
int querymx(int o,int ql,int qr)
{
	int l=t[o].l,r=t[o].r,mid=l+r>>1;
	if(l>=ql&&r<=qr)	return t[o].mx;
	int res=-inf;
	if(ql<=mid)	res=max(res,querymx(o<<1,ql,qr));
	if(qr>mid)	res=max(res,querymx(o<<1|1,ql,qr));
	return res;
}
//
int solvemx(int x,int y)
{
	int mx=-inf;
	while(bl[x]!=bl[y])
	{
		if(dep[bl[x]]<dep[bl[y]]) swap(x,y);
		mx=max(mx,querymx(1,pos[bl[x]],pos[x]));
		x=fa[bl[x]];
	}
	if(pos[x]>pos[y]) swap(x,y);
	mx=max(mx,querymx(1,pos[son[x]],pos[y]));//
	return mx;
}
void solve()
{
	build(1,1,n);
	w[1]=-inf;
	for(int i=1;i<=n;i++)
		change(1,pos[i],w[i]);//dfsÐò ͬһÌõÁ´ÔÚ±àºÅÁ¬ÐøµÄÇø¼ä. 
	int x,y,Q;
	char ch[100];
	while(~scanf("%s",ch)&&ch[0]!='D')
	{
		scanf("%d%d",&x,&y);
		if(ch[0]=='C')
		{
			int u=a[x].u,v=a[x].v;
			int son=fa[v]==u?v:u;
			change(1,pos[son],y);
		}
		else
			printf("%d\n",solvemx(x,y));
	}
}
int main()
{
	int T;
	scanf("%d",&T);
	while(T--)
	{
		init();
		dfs(1);
		dfs(1,1);
		solve();
	}
	return 0;
}

POJ 3237

修改边值,
查询x-y路径边的最大值.
将x-y路径上的边变号.
第3个操作用线段树区间修改维护一下就好了,其余部分是一样的.

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int N=5e5+20;
const int M=6e5+20;
const int inf=0x3f3f3f3f;
int n,cnt,sz;
int w[N],dep[N],size[N],head[N],fa[N];
int pos[N],bl[N],son[N];
struct edge{int to,next,w;}e[M];
struct Edge{int u,v,w;}a[M];
struct node{int l,r,mx,mn,lz;}t[M];
void add_edge(int u,int v,int w){e[++cnt].to=v,e[cnt].w=w,e[cnt].next=head[u],head[u]=cnt;}
void init()
{
	sz=cnt=0;
	memset(head,-1,sizeof(head));
	scanf("%d",&n);
	int x,y,w;
	for(int i=1;i<=n-1;i++)
	{
		scanf("%d%d%d",&x,&y,&w);
		add_edge(x,y,w),add_edge(y,x,w);
		a[i].u=x,a[i].v=y,a[i].w=w;
	}
}
void dfs(int u)
{
	size[u]=1;
	for(int i=head[u];i!=-1;i=e[i].next)
	{
		int v=e[i].to;
		if(v==fa[u])	continue;
		w[v]=e[i].w;//w[v]:v-fa[v]'scost 
		dep[v]=dep[u]+1,fa[v]=u;
		dfs(v);
		size[u]+=size[v];
	}
}
void dfs(int x,int chain)
{
	int k=0;sz++;
	pos[x]=sz;//time
	bl[x]=chain;
	for(int i=head[x];i!=-1;i=e[i].next)//find heavy son
	{
		int v=e[i].to;
		if(dep[v]>dep[x]&&size[v]>size[k])
			k=v;
	}
	son[x]=k;
	if(k==0){son[x]=x;return;}
	dfs(k,chain);
	for(int i=head[x];i!=-1;i=e[i].next)
		if(dep[e[i].to]>dep[x]&&k!=e[i].to)
			dfs(e[i].to,e[i].to);//ÆäÓà¶ù×ÓÖØ¿ªÐÂÁ´. 
}
///segment tree.
void build(int o,int l,int r)
{
	t[o].lz=1;
	t[o].l=l,t[o].r=r;
	if(l==r)	return;
	int m=l+r>>1;
	build(o<<1,l,m),build(o<<1|1,m+1,r);
}
void rev(int o)
{
	int tmp=t[o].mx;
	t[o].mx=-t[o].mn;
	t[o].mn=-tmp;
}
void push_up(int o){t[o].mx=max(t[o<<1].mx,t[o<<1|1].mx),t[o].mn=min(t[o<<1].mn,t[o<<1|1].mn);}
void push_down(int o)
{
	if(t[o].lz%2)
	{
		t[o<<1].lz++,t[o<<1|1].lz++;
		rev(o<<1),rev(o<<1|1);
	}
	t[o].lz=0;
}

void change(int o,int x,int y)
{
	int l=t[o].l,r=t[o].r,mid=l+r>>1;
	if(l==r){t[o].mx=t[o].mn=y;return;}
	push_down(o);
	if(x<=mid)	change(o<<1,x,y);
	else	change(o<<1|1,x,y);
	push_up(o);
}
void update(int o,int ql,int qr)
{
	int l=t[o].l,r=t[o].r,mid=l+r>>1;
	if(l>=ql&&r<=qr)
	{
		t[o].lz++;
		rev(o);
		return;
	}
	push_down(o);
	if(ql<=mid)	update(o<<1,ql,qr);
	if(qr>mid)	update(o<<1|1,ql,qr);
	push_up(o);
}
int querymx(int o,int ql,int qr)
{
	int l=t[o].l,r=t[o].r,mid=l+r>>1;
	if(l>=ql&&r<=qr)	return t[o].mx;
	push_down(o);
	int res=-inf;
	if(ql<=mid)	res=max(res,querymx(o<<1,ql,qr));
	if(qr>mid)	res=max(res,querymx(o<<1|1,ql,qr));
	return res;
}
//
int solvemx(int x,int y)
{
	int mx=-inf;
	while(bl[x]!=bl[y])
	{
		if(dep[bl[x]]<dep[bl[y]]) swap(x,y);
		mx=max(mx,querymx(1,pos[bl[x]],pos[x]));
		x=fa[bl[x]];
	}
	if(pos[x]>pos[y]) swap(x,y);
	mx=max(mx,querymx(1,pos[son[x]],pos[y]));//
	return mx;
}
void Negate(int x,int y)
{
	while(bl[x]!=bl[y])
	{
		if(dep[bl[x]]<dep[bl[y]]) swap(x,y);
		update(1,pos[bl[x]],pos[x]);
		x=fa[bl[x]];
	}
	if(pos[x]>pos[y])swap(x,y);
	update(1,pos[son[x]],pos[y]);
}
void solve()
{
	build(1,1,n);
	w[1]=-inf;
	for(int i=1;i<=n;i++)
		change(1,pos[i],w[i]);//dfsÐò ͬһÌõÁ´ÔÚ±àºÅÁ¬ÐøµÄÇø¼ä. 
	int x,y,Q;
	char ch[100];
	while(~scanf("%s",ch)&&ch[0]!='D')
	{
		scanf("%d%d",&x,&y);
		if(ch[0]=='Q')
			printf("%d\n",solvemx(x,y));
		else
		{
			int u=a[x].u,v=a[x].v;
			int son=fa[v]==u?v:u;
			if(ch[0]=='C')
				change(1,pos[son],y);
			else
				Negate(x,y);
		}
	
	}
}
int main()
{
	int T;
	scanf("%d",&T);
	while(T--)
	{
		init();
		dfs(1);
		dfs(1,1);
		solve();
	}
	return 0;
}


orz11111111
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树链剖分（轻重链剖分）
zixiangzhan的博客
10-25 627
树链剖分（轻重链剖分） 简介 树链剖分，简称”树剖“，顾名思义，就是将树“解剖”，将其转化成可用线段树维护的形式。由于线段树仅能进行区间上的操作，故需要通过一种划分方式，使得树链转化成区间，再用线段树维护。而“轻重儿子”的划分方式，不仅将树链转化成区间，还保证了该算法的复杂度。该算法可以用小常数n*log2 (n)的时间复杂度，维护一颗形态固定的树的树上路径信息，如对一段路径上的点进行修改，询问一段路径上所有点的权值和等等。值得一提的是，该算法还顺便可以用于求出两点之间的LCA.复杂度也为log，并且求L
树链剖分
Sunshine_cfbsl
08-08 670
我们有时候需要一种方法快速地求出树上任意两点之间路径的权值和（或者路径上边权的最大最小值）。这时，我们就可以用到树链剖分。所谓树链剖分，就是将一棵树分为许多条链，然后将这些链连起来，用线段树来维护区间的和（或者最大最小值）。 下面定义几个术语及数组：size[i]：以i为根结点的子树的节点个数 son[i]：i的子节点中size最大的子节点编号（若不存在则为-1） 重儿子：son[i]即为i的
树链剖分学习笔记
weixin_30684743的博客
07-28 69
树链剖分，简称树剖，用来解决一类维护静态树上路径信息的问题。就是对树进行一些操作，使其变成线性的结构，从而用线段树进行维护。 树链剖分的方法是轻重边剖分。我们将树上的边分成两种——轻边和重边。如果我们记siz[u]表示节点u的子树大小，在u的所有儿子之中，节点v的siz最大，则将边(u,v)称为重边，v称为u的重儿子。u到其他儿子的边就是轻边，其他的儿子就是轻儿子。 对于轻重边有这样...
BZOJ1036树的统计Count
DCrusher's blog
02-03 665
1036: [ZJOI2008]树的统计Count Time Limit: 10 Sec Memory Limit: 162 MB Submit: 10566 Solved: 4261 [Submit][Status][Discuss] Description 一棵树上有n个节点，编号分别为1到n，每个节点都有一个权值w。我们将以下面的形式来要求你对这棵树完成一些操作： I. CHAN
OI树上问题 简单学习笔记
weixin_30381317的博客
01-17 408
判断链 每个点的度数不超过2 判断树 n个点，n-1条边 每两个点之间的路径唯一 多叉树转换成二叉树 第一个孩子作为左孩子，第一个孩子的兄弟作为它的右孩子。 最小生成树 切割性质 假定所有边权均不相同。设S为既非空集也非全集的V的子集，边e是满足一个端点在S内，另一个端点不再S内的所有边中权值权值最小的一个，则图G的所有生成树均包含e。 回路性质。假定所有边权均不相同。设C...
树链剖分模板题汇总
r_clover的博客
03-02 1656
记录几个树链剖分的模板题，包括点操作，边操作和带方向的操作。点操作HDU 3966#include <cstdio> #include <cstring> #include <iostream> #include <algorithm> #include <cmath> #include <vector> #include <queue> #include <stack> #include <set
LCA(最近公共祖先) & 树链剖分 学习笔记
NPU_SXY的博客
08-17 563
LCA(最近公共祖先) 什么是LCA？ 顾名思义自然 就是对于树上两个节点，  距离它们最近的公共祖先 比如上图中，3和4、2和5的最近公共祖先都是1，5和6的最近公共祖先是3。 当然并没有什么题会让你直接打模板求两个点的最近公共祖先除非出题人喝了假酒，更多的时候都是：给你一棵树才怪一个图求出MST之类的东西，然后在MST上求两个点之间权值之和或者极值或者别的什么东西。 如何求L...
NOIP 树链剖分 NOIP 树链剖分
10-30
NOIP 树链剖分 NOIP 树链剖分
树链剖分算法.pptx
09-03
树链剖分，计算机术语，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链
树链剖分模板题
05-19
#include #include #include #define N 30003 #define INF 2147483647 using namespace std; int n,f[N][20],dep[N],siz[N],son[N],top[N],tot,pos[N],w[N]; int Max[N*4],Sum[N*4];...vector <int> to[N];...
第5章 树链剖分 测试数据.rar
12-02
树链剖分是一种高效处理树型结构的算法，尤其在解决与树的边查询和修改有关的问题时，它能提供显著的效率提升。这一技术在信息学奥赛中经常被用到，帮助参赛者快速解决复杂的树形问题。在本章的测试数据中，你将有...
树链剖分题集
帅比王的博客
10-12 1456
树链剖分常用于处理静态树上操作，效率很高，写起来也就是固定的轻重边拆分+线段树，但是代码一般都是100行+，容易出错。 本题集中的树链剖分练习题，在解决思路上没什么难点，主要是如何设计线段树以及如何更新+询问，也就是说要想好怎么维护线段树，其它地方没什么太难的，但是代码长就容易出bug，多写写就好了。最后一题是线段树动态开点，这和可持久化权值线段树（动态主席树）一样的思想，只需要将普通的线段树给稍...
树链剖分题集【已经建立好，点开即可】
既然弱小，就只顾变强就是了
11-27 216
题目链接   密码：MyAcmLife
树链剖分习题
tangzhide123yy的博客
10-17 276
树链剖分习题
树链剖分题库
Facico的博客
04-02 650
不断更新中…… 最初学习树链剖分时只找到一道题，现在又找到了几道练手的题目，类似模板题，拿出来堆在一起。 难度为升序的。 【ZJOI2008】树的统计 要求会打树链剖分。 【GDOI模拟】数树数 要求会打树链剖分。需要线段树的动态开空间或用离线大法。需要会用c++的map或者打哈希加离散化。 【SDOI2014】旅行 要求会打树链剖分。需要线段树的动态开空间或用离线大法。操作复杂
树链剖分题目汇总+板子
永远鲜红の幼月的博客
04-29 1334
辣鸡的我终于开始学树链剖分了，而ly聚聚早都会了QAQ..... 首先是一个板子题，就是板子 洛谷-P3384-【模板】树链剖分 题目链接：https://www.luogu.org/problemnew/show/P3384 题目大意：四种操作，板子。 思路：板子。线段树维护分出来的链。 ACCode（板子）： //#pragma comment(linker, "/STACK:...
树链剖分小结及题目
每一次AC都是一种感动
08-04 3673
我们经常会遇到这样一类题目：给出一棵树，询问树上u,v两点路径间的最值，合值，更新u，v路径上的点权或边权，或者区间更新etc，此时如果单纯的用线段树或者树状数组去搞，很明显问题不能够得到完美解决，此时就需要更高级的数据结构去对树进行重新构造，也就是通常说的树链剖分。 一．树链剖分 树链剖分，顾名思义，也就是对树的每一条链进行剖分，将一棵树拆分成若干条链，对其进行重新编号，在进行了重新编
ArcGIS Engine编程初学至精通指南
最新发布
07-23
《ArcGIS Engine开发从入门到精通》是一套全面讲解GIS技术与ArcGIS Engine应用的教程。ArcGIS Engine是由Esri公司推出的强大地理信息系统开发平台，它允许开发者利用.NET、Java等编程语言创建桌面、Web及移动GIS应用程序。本教程旨在帮助初学者和有一定经验的GIS从业者快速掌握ArcGIS Engine的核心技术和实际应用。 1. **GIS基础概念**：我们需要理解什么是GIS（Geographic Information System，地理信息系统），它是如何整合地理位置数据和属性数据，以及如何通过地图进行数据的可视化和分析。 2. **ArcGIS Engine介绍**：ArcGIS Engine是Esri GIS技术栈的一部分，提供了丰富的GIS组件，包括地图显示、图层管理、地理处理工具、查询功能等，用于构建自定义的GIS应用。 3. **开发环境配置**：讲解如何设置开发环境，包括安装ArcGIS Engine SDK，集成开发环境（如Visual Studio）的配置，以及必要的开发工具和库的添加。 4. **基础控件与组件
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值