【图论07】线段树 1001 敌兵布阵

本文探讨了在算法优化过程中,输出、输入操作相较于字符串比较在性能上的影响,并提供了树状数组和线段树两种解决方法的代码实现,帮助开发者在细节上提升算法效率。

第一次提交的时候TLE,最后改成C输入输出成功AC,耗时156ms。

通过尝试用不同格式的代码提交之后,发现一个问题,性能影响:输出 > 输入 > 字符串比较(这里更多的是char* 和 string的性能差异)。所以在细节上进行性能优化的时候,应该优先考虑输出、输入。

算法思路:(两种方法)

<1>考察树状数组,区间信息的维护和查询方法。

<2>线段树


树状数组代码: 

//模板开始
#include <string>   
#include <vector>   
#include <algorithm>   
#include <iostream>   
#include <sstream>   
#include <fstream>   
#include <map>   
#include <set>   
#include <cstdio>   
#include <cmath>   
#include <cstdlib>   
#include <ctime>
#include<iomanip>
#include<string.h>
#define SZ(x) (int(x.size()))
using namespace std;

int toInt(string s){
	istringstream sin(s); 
	int t; 
	sin>>t; 
	return t;
}
template<class T> string toString(T x){
	ostringstream sout; 
	sout<<x; 
	return sout.str();
}
typedef long long int64;
int64 toInt64(string s){
	istringstream sin(s); 
	int64 t; 
	sin>>t;
	return t;
}
template<class T> T gcd(T a, T b){ 
	if(a<0) 
		return gcd(-a, b);
	if(b<0) 
		return gcd(a, -b);
	return (b == 0)? a : gcd(b, a % b);
}

#define ifs cin
//模板结束(通用部分)

#define N 50005
int C[N];
int A[N];

int lowbit(int x)
{
	return x & (-x);
}

int sum(int x)
{
	int ret = 0;
	while(x > 0)
	{
		ret += C[x];
		x -= lowbit(x);
	}
	return ret;
}

void add(int x, int d, int n)
{
	while(x <= n)
	{
		C[x] += d;
		x += lowbit(x);
	}
}

void sub(int x, int d, int n)
{
	while(x <= n)
	{
		C[x] -= d;
		x += lowbit(x);
	}
}

//hdoj 1166 敌兵布阵
int main()
{
	//ifstream ifs("shuju.txt", ios::in);
	int n;
	int m;
	int data;
	int op1, op2;
	char s1[10];
	//ifs>>m;
	scanf("%d", &m);
	for(int i = 0; i < m; i++)
	{
		//cout<<"Case "<<i + 1<<":"<<endl;
		printf("Case %d:\n", i + 1);
		//ifs>>n;
		scanf("%d", &n);
		memset(C, 0, sizeof(C));
		memset(A, 0, sizeof(A));
		for(int j = 1; j <= n; j++)
		{
			//ifs>>data;
			scanf("%d", &data);
			A[j] = data;
			add(j, data, n);
		}
		while(scanf("%s", s1))
		{
			if(s1[0] == 'E')
			{
				break;
			}
			//ifs>>op1>>op2;
			scanf("%d%d", &op1, &op2);
			if(s1[0] == 'Q')
			{
				//cout<<sum(op2) - sum(op1 - 1)<<endl;
				printf("%d\n", sum(op2) - sum(op1 - 1));
			}
			else if(s1[0] == 'A')
			{
				A[op1] += op2;
				add(op1, op2, n);
			}
			else if(s1[0] == 'S')
			{
				A[op1] -= op2;
				sub(op1, op2, n);
			}
		}
	}

	return 0;
}

 

线段树代码:

//模板开始
#include <string>   
#include <vector>   
#include <algorithm>   
#include <iostream>   
#include <sstream>   
#include <fstream>   
#include <map>   
#include <set>   
#include <cstdio>   
#include <cmath>   
#include <cstdlib>   
#include <ctime>
#include <iomanip>
#include <queue>
#include <string.h>
#define SZ(x) (int(x.size()))
using namespace std;

int toInt(string s){
	istringstream sin(s); 
	int t; 
	sin>>t; 
	return t;
}
template<class T> string toString(T x){
	ostringstream sout; 
	sout<<x; 
	return sout.str();
}
typedef long long int64;
int64 toInt64(string s){
	istringstream sin(s); 
	int64 t; 
	sin>>t;
	return t;
}
template<class T> T gcd(T a, T b){ 
	if(a<0) 
		return gcd(-a, b);
	if(b<0) 
		return gcd(a, -b);
	return (b == 0)? a : gcd(b, a % b);
}

#define LOCAL
//模板结束(通用部分)

#define MAXN 2000200

int sum[MAXN];
int ql, qr;
int p, v;
int N;
int zhishu;

int query(int o, int L, int R)
{
	int M = L + (R - L) / 2, ans = 0;
	if(ql <= L && R <= qr)
	{
		return sum[o];
	}
	if(ql <= M)
	{
		ans += query(o * 2, L, M);
	}
	if(M < qr)
	{
		ans += query(o * 2 + 1, M + 1, R);
	}
	return ans;
}

void update1(int o, int L, int R)
{
	int M = L + (R - L) / 2;
	if(L == R)
	{
		sum[o] += v;
	}
	else
	{
		if(p <= M)
		{
			update1(o * 2, L, M);
		}
		else
		{
			update1(o * 2 + 1, M + 1, R);
		}
		sum[o] = sum[o * 2] + sum[o * 2 + 1]; 
	}
}

void update2(int o, int L, int R)
{
	int M = L + (R - L) / 2;
	if(L == R)
	{
		sum[o] -= v;
	}
	else
	{
		if(p <= M)
		{
			update2(o * 2, L, M);
		}
		else
		{
			update2(o * 2 + 1, M + 1, R);
		}
		sum[o] = sum[o * 2] + sum[o * 2 + 1]; 
	}
}

void init()
{
	zhishu = 0;
	//cin>>N;
	scanf("%d", &N);
	while((1<<zhishu) < N)
	{
		zhishu++;
	}
	int up_max = (1<<(zhishu + 1)) - 1;
	int chuzhi = 1<<(zhishu);
	for(int i = chuzhi; i <= chuzhi + N - 1; i++)
	{
		//cin>>sum[i];
		scanf("%d", &sum[i]);
	}
	for(int i = chuzhi + N; i <= up_max; i++)
	{
		sum[i] = 0;
	}
	for(int i = (1<<zhishu) - 1; i >= 1; i--)
	{
		sum[i] = sum[i * 2] + sum[i * 2 + 1];
	}
}

int main()
{
#ifdef LOCAL
	//freopen("shuju.txt", "r", stdin);
#endif

	char a[10];
	int b, c;
	int T;
	//cin>>T;
	scanf("%d", &T);
	for(int tt = 1; tt <= T; tt++)
	{
		cout<<"Case "<<tt<<":"<<endl;
		init();		
		while(scanf("%s", a) == 1 && strcmp(a, "End") != 0)
		{
			//cin>>b>>c;
			scanf("%d%d", &b, &c);
			if(!strcmp(a, "Query"))
			{
				ql = b;
				qr = c;
				cout<<query(1, 1, 1<<zhishu)<<endl;
			}
			if(!strcmp(a, "Add"))
			{
				p = b;
				v = c;
				update1(1, 1, 1<<zhishu);
			}
			if(!strcmp(a, "Sub"))
			{
				p = b;
				v = c;
				update2(1, 1, 1<<zhishu);
			}
		}
	}

	return 0;
}


<think>嗯,用户想了解图论线段树的应用和实现。首先,我需要确认线段树的基本概念以及它在图论中的具体应用场景。根据引用[3]和[4],线段树主要用于处理区间查询和更新操作,时间复杂度为$O(\log N)$,这在图论中可能用于处理某些需要高效区间操作的问题。 接下来,我需要思考线段树图论中的常见应用。比如,图的最短路径问题中,如果涉及到动态更新的边权重,线段树可能用来维护某些区间的最小值,从而加速Dijkstra算法的过程。另外,在图的连通性问题中,线段树可能用于维护并查集结构,或者处理区间覆盖的情况。 然后,实现方面需要考虑线段树的结构如何与图的数据结构结合。例如,使用线段树来维护邻接表的某些属性,或者在处理图的区间查询时,构建线段树来快速获取信息。可能需要举一个具体的例子,比如使用线段树优化最短路径算法中的优先队列操作。 还需要注意用户提供的引用中提到的平衡树与区间树的结合应用[^1],这可能暗示线段树在处理动态区间管理时的高效性,可以借鉴到图论的动态问题中。同时,引用[2]提到线段树的变种和优化策略,可能需要讨论不同的线段树结构如何适应图论中的特定需求。 最后,生成相关问题时,要确保覆盖应用场景、实现方法、性能优化以及与其他数据结构的结合,这样用户能全面了解线段树图论中的使用。</think>### 图论线段树的应用与实现 线段树图论中的应用主要集中于**高效处理动态图问题**和**区间化图结构查询**,尤其适合需要频繁更新边权重或节点属性,并快速查询特定区间内信息的场景。 --- #### 1. **应用场景** - **动态最短路径维护** 当图中边的权重动态变化时,线段树可维护路径权重的区间最小值,加速松弛操作。例如,在稀疏图中,通过线段树记录节点到源点的最短距离,实现$O(\log N)$时间复杂度的更新和查询[^2]。 - **区间覆盖与连通性判断** 在图的连通性问题中,线段树可管理节点间的连通状态。例如,动态维护区间内节点是否形成连通分支,或在图分割问题中快速判断子图的连通性[^3]。 - **网络流优化** 线段树可辅助最大流算法,如在分层图的构建过程中快速定位增广路径的可行区间,减少冗余搜索。 --- #### 2. **实现方法** 以**动态最短路径维护**为例,线段树可结合Dijkstra算法优化优先级队列: ##### 数据结构设计 - **线段树节点**:存储区间内节点的当前最短距离最小值。 - **懒标记**:记录距离更新操作,支持批量传递。 ##### 关键代码片段(C++) ```cpp struct SegmentTreeNode { int left, right; int min_dist; // 区间内最小距离 int lazy; // 懒标记(距离更新值) }; void update(int node, int l, int r, int val) { if (当前节点区间完全包含于[l, r]) { tree[node].min_dist += val; // 更新最小值 tree[node].lazy += val; // 标记延迟传递 return; } push_down(node); // 传递懒标记到子节点 update(left_child, l, r, val); update(right_child, l, r, val); tree[node].min_dist = min(tree[left_child].min_dist, tree[right_child].min_dist); } int query(int node, int l, int r) { if (当前节点区间完全包含于[l, r]) return tree[node].min_dist; push_down(node); return min(query(left_child, l, r), query(right_child, l, r)); } ``` ##### 与Dijkstra结合 - 初始化时将所有节点距离设为无穷大,源点设为0。 - 每次从线段树中提取当前最小距离的节点进行松弛操作。 - 更新相邻节点距离时,调用线段树的区间更新接口。 --- #### 3. **性能分析** - **时间复杂度**: 线段树的更新和查询均为$O(\log N)$,结合Dijkstra算法的总时间复杂度为$O((E + N) \log N)$,优于传统堆实现的$O(E \log N)$(在稀疏图中更高效)[^4]。 - **空间复杂度**: 线段树需要$O(4N)$空间(N为节点数),可能需离散化优化。 --- #### 4. **与其他数据结构的结合** - **平衡树(如AVL树)**:管理动态区间边界,支持更复杂的区间合并/分裂操作[^1]。 - **并查集**:在连通性问题中,线段树可辅助维护区间内的连通状态,结合路径压缩优化查询效率。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值