【地狱副本】数据结构之线段树Ⅲ——区间最值/赋值/修改/历史值操作（HDU5306，Tyvj 1518，【清华集训2015】V，HDU6315，HDU1828，POJ3162）

最新推荐文章于 2021-11-03 23:02:08 发布
最新推荐文章于 2021-11-03 23:02:08 发布
阅读量730 收藏 3
点赞数 3
分类专栏： # 扫描线 # 普通/值域/势能/李超/可持久化线段树 文章标签： 数据结构 线段树 扫描线 dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Emm_Titan/article/details/119921058
版权

文章目录

Gorgeous Sequence

HDU5306

操作

  • 区间与 x x x取 m i n \rm min min
  • 查询区间最大值
  • 查询区间和

比较暴力的线段树维护区间

  • Max : 区间最大值
  • sub_max : 严格小于最大值的区间次大值
  • cnt_max : 最大值个数
  • sum : 区间和
  • tag : 区间取 m i n \rm min min的标记记录值

考虑取 m i n \rm min min操作走到一个区间上

  • 最大值都不大于取 m i n \rm min min的对象，说明操作没用，return

  • 如果小于最大值却严格大于次大值

    此时的操作相当于区间加，打标记 sum-=(Max-x)*max_cnt;Max=x

  • 否则暴力走两边

利用势能分析时间复杂度

  • 定义势能函数为 ∑ i d i \sum_i d_i ∑i​di​， i i i是线段树上的节点， d i d_i di​是这个节点对应的区间中，互不相同的元素个数
  • 初始时，显然势能是 O ( n l o g n ) O(\rm nlogn) O(nlogn)
  • 暴力对长度为 n n n的区间做 m i n \rm min min，消耗的时间是 O ( n ) O(n) O(n)，势能也会减少 O ( n ) O(n) O(n)
#include <cstdio>
#include <iostream>
using namespace std;
#define int long long
#define maxn 1000005
#define lson num << 1
#define rson num << 1 | 1
struct node {
	int Max, sub_max, cnt_max, sum, tag;
}t[maxn << 2];
int a[maxn];

void pushup( int num ) {
	if( t[lson].Max > t[rson].Max ) {
		t[num].Max = t[lson].Max;
		t[num].cnt_max = t[lson].cnt_max;
		t[num].sub_max = max( t[lson].sub_max, t[rson].Max );
	}
	else if( t[lson].Max < t[rson].Max ) {
		t[num].Max = t[rson].Max;
		t[num].cnt_max = t[rson].cnt_max;
		t[num].sub_max = max( t[rson].sub_max, t[lson].Max );
	}
	else {
		t[num].Max = t[lson].Max;
		t[num].cnt_max = t[lson].cnt_max + t[rson].cnt_max;
		t[num].sub_max = max( t[lson].sub_max, t[rson].sub_max );
	}
	t[num].sum = t[lson].sum + t[rson].sum;
}

void build( int num, int l, int r ) {
	t[num].Max = t[num].sub_max = t[num].cnt_max = t[num].sum = 0, t[num].tag = -1;
	if( l == r ) {
		t[num].Max = t[num].sum = a[l];
		t[num].sub_max = -1;
		t[num].cnt_max = 1;
		return;
	}
	int mid = l + r >> 1;
	build( lson, l, mid );
	build( rson, mid + 1, r );
	pushup( num );
}

void pushdown( int num ) {
	if( ! ~ t[num].tag ) return;
	int val = t[num].tag;
	if( t[lson].Max > val ) {
		t[lson].sum -= ( t[lson].Max - val ) * t[lson].cnt_max;
		t[lson].Max = t[lson].tag = val;
	}
	if( t[rson].Max > val ) {
		t[rson].sum -= ( t[rson].Max - val ) * t[rson].cnt_max;
		t[rson].Max = t[rson].tag = val;
	}
	t[num].tag = -1;
}

void modify( int num, int l, int r, int L, int R, int val ) {
	if( R < l or r < L or t[num].Max <= val ) return;
	if( L <= l and r <= R and t[num].sub_max < val ) {
		t[num].sum -= ( t[num].Max - val ) * t[num].cnt_max;
		t[num].Max = t[num].tag = val;
		return;
	}
	pushdown( num );
	int mid = l + r >> 1;
	modify( lson, l, mid, L, R, val );
	modify( rson, mid + 1, r, L, R, val );
	pushup( num );
}

int query_max( int num, int l, int r, int L, int R ) {
	if( r < L or R < l ) return -1;
	if( L <= l and r <= R ) return t[num].Max;
	pushdown( num );
	int mid = l + r >> 1;
	return max( query_max( lson, l, mid, L, R ), query_max( rson, mid + 1, r, L, R ) );
}

int query_sum( int num, int l, int r, int L, int R ) {
	if( r < L or R < l ) return 0;
	if( L <= l and r <= R ) return t[num].sum;
	pushdown( num );
	int mid = l + r >> 1;
	return query_sum( lson, l, mid, L, R ) + query_sum( rson, mid + 1, r, L, R );
}

signed main() {
	int n, m, T, opt, l, r, x;
	scanf( "%lld", &T );
	while( T -- ) {
		scanf( "%lld %lld", &n, &m );
		for( int i = 1;i <= n;i ++ ) scanf( "%lld", &a[i] );
		build( 1, 1, n );
		while( m -- ) {
			scanf( "%lld %lld %lld", &opt, &l, &r );
			switch ( opt ) {
				case 0 : { scanf( "%lld", &x ); modify( 1, 1, n, l, r, x );break; }
				case 1 : { printf( "%lld\n", query_max( 1, 1, n, l, r ) ); break; }
				case 2 : { printf( "%lld\n", query_sum( 1, 1, n, l, r ) ); break; }
			}
		}
	}
	return 0;
}

Tyvj 1518 CPU监控

BZOJ3064

操作

  • 区间加
  • 区间赋值
  • 查询区间最大值
  • 查询区间历史最大值

线段树维护

  • Max : 区间最大值
  • Hmax : 区间历史最大值
  • add : 区间加标记
  • Hadd : 区间历史最大加标记
  • tag : 区间赋值标记
  • Htag : 区间历史最大赋值标记

假想不合并标记，每个节点上有一个队列（按照时间先进先出），放着所有曾经推过来的标记

下推标记时，将该节点上所有的标记推到两个儿子处，并清空队列

对于每个节点，每次有一个区间加add标记推来时，令Max←Max+add 然后Hmax←max(Hmax,Max)

设推来的加法标记分别为 a d d [ 1... k ] add[1...k] add[1...k]，其前缀和为 S [ 1... k ] S[1...k] S[1...k]

则打上第 i i i个标记之后，Max的值为Max+S[i]

所以，Hmax的值为 max ⁡ i = 1 k M a x + S [ i ] = M a x + max ⁡ i = 1 k S [ i ] \max_{i=1}^k Max+S[i]=Max+\max_{i=1}^k S[i] maxi=1k​Max+S[i]=Max+maxi=1k​S[i]

因此只需记录 max ⁡ i = 1 k S [ i ] \max_{i=1}^k S[i] maxi=1k​S[i]，就能得知该标记队列对节点的影响

合并加法标记时简单求和，前 i i i个标记合并后恰好等于 S [ i ] S[i] S[i]，那么 max ⁡ i = 1 k S [ i ] \max_{i=1}^k S[i] maxi=1k​S[i]可以表述为标记的历史最大值Hadd

此题含有赋值操作，赋值操作优先级更高，做法略有不同

赋值一次相当于前面所有的加标记和当前最大值都会被改变

所以赋值的时候，先下放所有的加标记，然后清空（包括历史）

同时，在加标记的时候如果已经有了赋值标记，直接把加标记叠加在赋值标记上

同时记录赋值历史的最大值，其很有可能成为历史最大值

#include <cstdio>
#include <iostream>
using namespace std;
#define inf 1e18
#define maxn 100005
#define int long long
#define lson num << 1
#define rson num << 1 | 1
struct node {
	int Max, Hmax, add, Hadd, tag, Htag;
}t[maxn << 2];
int a[maxn];

void build( int num, int l, int r ) {
	t[num].Max = t[num].Hmax = t[num].tag = t[num].Htag = -inf;
	t[num].add = t[num].Hadd = 0;
	if( l == r ) { t[num].Max = t[num].Hmax = a[l]; return; }
	int mid = ( l + r ) >> 1;
	build( lson, l, mid );
	build( rson, mid + 1, r );
	t[num].Max = t[num].Hmax = max( t[lson].Max, t[rson].Max );
}

void pushup( int num ) {
	t[num].Max = max( t[lson].Max, t[rson].Max );
	t[num].Hmax = max( t[lson].Hmax, t[rson].Hmax );
}

void down( int num, int add, int Hadd ) {
	if( t[num].Htag != -inf )
		t[num].Htag = max( t[num].Htag, t[num].tag + Hadd ), t[num].tag += add;
	else
		t[num].Hadd = max( t[num].Hadd, t[num].add + Hadd ), t[num].add += add;
}

void pushdown( int num, int l, int r ) {
	if( t[num].tag == -inf and ! t[num].add ) return;
	t[num].Hmax = max( t[num].Hmax, max( t[num].Htag, t[num].Max + t[num].Hadd ) );
	if( t[num].add ) {
		t[num].Max += t[num].add;
		if( l ^ r ) {
			down( lson, t[num].add, t[num].Hadd );
			down( rson, t[num].add, t[num].Hadd ); 
		} 
	}
	if( t[num].tag != -inf ) {
		t[num].Max = t[num].tag;
		if( l ^ r ) {
			t[lson].tag = t[rson].tag = t[num].tag;
			t[lson].Htag = max( t[lson].Htag, t[num].Htag );
			t[rson].Htag = max( t[rson].Htag, t[num].Htag );
		}
	}
	t[num].add = t[num].Hadd = 0;
	t[num].tag = t[num].Htag = -inf;
}

void add( int num, int l, int r, int L, int R, int val ) {
	pushdown( num, l, r );
	if( R < l or r < L ) return;
	if( L <= l and r <= R ) {
		if( t[num].tag != -inf ) 
			t[num].tag += val, t[num].Htag = max( t[num].Htag, t[num].tag );
		else 
			t[num].add += val, t[num].Hadd = max( t[num].Hadd, t[num].add );
		pushdown( num, l, r );
		return;
	}
	pushdown( num, l, r );
	int mid = ( l + r ) >> 1;
	add( lson, l, mid, L, R, val );
	add( rson, mid + 1, r, L, R, val );
	pushup( num );
}

void modify( int num, int l, int r, int L, int R, int val ) {
	pushdown( num, l, r );
	if( R < l or r < L ) return;
	if( L <= l and r <= R ) {
		t[num].tag = val;
		t[num].Htag = max( t[num].Htag, val );
		pushdown( num, l, r );
		return;
	}
	pushdown( num, l, r );
	int mid = ( l + r ) >> 1;
	modify( lson, l, mid, L, R, val );
	modify( rson, mid + 1, r, L, R, val );
	pushup( num );
}

int query_max( int num, int l, int r, int L, int R ) {
	if( R < l or r < L ) return -inf;
	pushdown( num, l, r );
	if( L <= l and r <= R ) return t[num].Max;
	int mid = ( l + r ) >> 1;
	return max( query_max( lson, l, mid, L, R ), query_max( rson, mid + 1, r, L, R ) );
}

int queryHmax( int num, int l, int r, int L, int R ) {
	if( R < l or r < L ) return -inf;
	pushdown( num, l, r );
	if( L <= l and r <= R ) return t[num].Hmax;
	int mid = ( l + r ) >> 1;
	return max( queryHmax( lson, l, mid, L, R ), queryHmax( rson, mid + 1, r, L, R ) );
}

signed main() {
	int n, m, l, r, x; char opt[5];
	scanf( "%lld", &n );
	for( int i = 1;i <= n;i ++ ) scanf( "%lld", &a[i] );
	build( 1, 1, n );
	scanf( "%lld", &m );
	while( m -- ) {
		scanf( "%s %lld %lld", opt, &l, &r );
		switch ( opt[0] ) {
			case 'Q' : { printf( "%lld\n", query_max( 1, 1, n, l, r ) ); break; }
			case 'A' : { printf( "%lld\n", queryHmax( 1, 1, n, l, r ) ); break; }
			case 'P' : { scanf( "%lld", &x ); add( 1, 1, n, l, r, x );   break; }
			case 'C' : { scanf( "%lld", &x ); modify( 1, 1, n, l, r, x );break; }
		}
	}
	return 0;
}

【清华集训2015】V

UOJ164

整那么高大上的物理电阻屁用没有

操作

  • 区间加
  • 区间减
  • 区间赋值
  • 查询单点值
  • 查询单点历史最大值

这题很巧的转化将多个操作合并成了一种形式

将标记改写成(a,b)形式，标记对值的贡献转移形式改写成x←max(x+a,b)

  • 区间加：(val,-inf)
  • 区间减：(-val,-inf)
  • 区间赋值：(-inf,val)

标记的合并可以推出来，因为加法对取最大值满足分配率

  • 假设原来的标记为(a1,b1)，新来标记为(a2,b2)
  • max ⁡ ( x + a 1 , b 1 ) ← ( a 2 , b 2 ) ⇒ max ⁡ ( max ⁡ ( x + a 1 , b 1 ) + a 2 , b 2 ) ⇒ max ⁡ ( max ⁡ ( x + a 1 + a 2 , b 1 + a 2 ) , b 2 ) \max(x+a_1,b_1)\leftarrow (a_2,b_2)\Rightarrow \max\Big(\max(x+a_1,b_1)+a_2,b_2\Big)\Rightarrow \max\Big(\max(x+a_1+a_2,b_1+a_2),b_2\Big) max(x+a1​,b1​)←(a2​,b2​)⇒max(max(x+a1​,b1​)+a2​,b2​)⇒max(max(x+a1​+a2​,b1​+a2​),b2​)
  • 新来标记合并最后即为 x ← max ⁡ ( x + a 1 + a 2 , max ⁡ ( a 2 + b 1 , b 2 ) ) x\leftarrow \max\Big(x+a_1+a_2,\max(a_2+b_1,b_2)\Big) x←max(x+a1​+a2​,max(a2​+b1​,b2​))

考虑当前最大值的更新

两个标记取 m a x \rm max max相当于两个分段一次函数取 m a x \rm max max

m a x ( ( a 1 , b 1 ) , ( a 2 , b 2 ) ) = ( m a x ( a 1 , a 2 ) , m a x ( b 1 , b 2 ) ) \rm max\Big((a_1,b_1),(a_2,b_2))=(max(a_1,a_2),max(b_1,b_2)\Big) max((a1​,b1​),(a2​,b2​))=(max(a1​,a2​),max(b1​,b2​))

在这里插入图片描述

再考虑历史最大值的更新

(a0,b0)表示当前，(a1,b1)表示历史最大值，(c0,d0)表示传递点当前，(c1,d1)表示传递点历史最大

合并(a0,b0)和(c0,d0)： ( a 0 + c 0 , max ⁡ ( b 0 + c 0 , d 0 ) ) \Big(a_0+c_0,\max(b_0+c_0,d_0)\Big) (a0​+c0​,max(b0​+c0​,d0​))

合并(a1,b1)和(c1,d1)，先把(c1,d1)作用在(a0,b0)上， ( a 0 + c 1 , max ⁡ ( b 0 + c 1 , d 1 ) ) \Big(a_0+c_1,\max(b_0+c_1,d_1)\Big) (a0​+c1​,max(b0​+c1​,d1​))

再和(a1,b1)取max： ( max ⁡ ( a 1 , a 0 + c 1 ) , max ⁡ ( b 1 , b 0 + c 1 , d 1 ) ) \Big(\max(a_1,a_0+c_1),\max(b_1,b_0+c_1,d_1)\Big) (max(a1​,a0​+c1​),max(b1​,b0​+c1​,d1​))

（a,b相当于儿子，c,d代表父亲的信息）

#include <cstdio>
#include <iostream>
using namespace std;
#define maxn 500005
#define int long long
#define lson num << 1
#define rson num << 1 | 1
struct node {
	int a, b, maxa, maxb;
}t[maxn << 2];
int w[maxn];
const int inf = 1e18;

void build( int num, int l, int r ) {
	t[num].a = t[num].maxa = 0;
	t[num].b = t[num].maxb = -inf;
	if( l == r ) return;
	int mid = l + r >> 1;
	build( lson, l, mid );
	build( rson, mid + 1, r );
}

void pushdown( int num ) {
	if( ! t[num].a and t[num].b == -inf ) return;
	t[lson].maxa = max( t[lson].maxa, t[lson].a + t[num].maxa );
	t[lson].maxb = max( t[lson].maxb, max( t[lson].b + t[num].maxa, t[num].maxb ) );
	t[rson].maxa = max( t[rson].maxa, t[rson].a + t[num].maxa );
	t[rson].maxb = max( t[rson].maxb, max( t[rson].b + t[num].maxa, t[num].maxb ) );
	t[lson].a = max( t[lson].a + t[num].a, -inf );
	t[lson].b = max( t[lson].b + t[num].a, t[num].b );
	t[rson].a = max( t[rson].a + t[num].a, -inf );
	t[rson].b = max( t[rson].b + t[num].a, t[num].b );
	t[num].a = t[num].maxa = 0;
	t[num].b = t[num].maxb = -inf;
}

void modify( int num, int l, int r, int L, int R, int a, int b ) {
	if( r < L or R < l ) return;
	if( L <= l and r <= R ) {
		t[num].a = max( t[num].a + a, -inf );
		t[num].b = max( t[num].b + a, b );
		t[num].maxa = max( t[num].a, t[num].maxa );
		t[num].maxb = max( t[num].b, t[num].maxb );
		return;
	}
	pushdown( num );
	int mid = l + r >> 1;
	modify( lson, l, mid, L, R, a, b );
	modify( rson, mid + 1, r, L, R, a, b );
}

int query( int num, int l, int r, int pos, int k ) {
	if( l == r ) {
		if( ! k ) return max( w[l] + t[num].a, t[num].b );
		else return max( w[l] + t[num].maxa, t[num].maxb );
	}
	pushdown( num );
	int mid = l + r >> 1;
	if( pos <= mid ) return query( lson, l, mid, pos, k );
	else return query( rson, mid + 1, r, pos, k );
}

signed main() {
	int n, m;
	scanf( "%lld %lld", &n, &m );
	for( int i = 1;i <= n;i ++ ) scanf( "%lld", &w[i] );
	build( 1, 1, n );
	for( int i = 1, opt, l, r, x;i <= m;i ++ ) {
		scanf( "%lld", &opt );
		switch ( opt ) {
			case 1 : { scanf( "%lld %lld %lld", &l, &r, &x ), modify( 1, 1, n, l, r, x, 0 ); break; }
			case 2 : { scanf( "%lld %lld %lld", &l, &r, &x ), modify( 1, 1, n, l, r, -x, 0 ); break; }
			case 3 : { scanf( "%lld %lld %lld", &l, &r, &x ), modify( 1, 1, n, l, r, -inf, x ); break; }
			case 4 : { scanf( "%lld", &x ), printf( "%lld\n", query( 1, 1, n, x, 0 ) ); break; }
			case 5 : { scanf( "%lld", &x ), printf( "%lld\n", query( 1, 1, n, x, 1 ) ); break; }
		}
	}
	return 0;
}

Naive Operations

HDU6315

刚开始区间全为 0 0 0，每次区间只 + 1 +1 +1

记录区间的最小值，

当最小值为 0 0 0的时候，说明多叠加了一个 b i b_i bi​的倍数

答案增加 1 1 1，然后重新把最小值置位 b i b_i bi​ （这俩操作要走到叶子节点后再实行）

否则就打上整体 − 1 -1 −1的标记

#include <cstdio>
#include <iostream>
using namespace std;
#define maxn 100005
#define int long long
#define lson num << 1
#define rson num << 1 | 1
struct node {
	int sum, tag, Min;
}t[maxn << 2];
int b[maxn];

void build( int num, int l, int r ) {
	t[num].tag = t[num].sum = 0;
	if( l == r ) { t[num].Min = b[l]; return; }
	int mid = l + r >> 1;
	build( lson, l, mid );
	build( rson, mid + 1, r );
	t[num].Min = min( t[lson].Min, t[rson].Min );
}

void pushdown( int num ) {
	if( ! t[num].tag ) return;
	t[lson].tag += t[num].tag;
	t[rson].tag += t[num].tag;
	t[lson].Min -= t[num].tag;
	t[rson].Min -= t[num].tag;
	t[num].tag = 0;
}

void modify( int num, int l, int r, int L, int R ) {
	if( R < l or r < L ) return;
	if( L <= l and r <= R ) {
		t[num].Min --;
		if( t[num].Min ) { t[num].tag ++; return; }
		else if( l == r ) { t[num].sum ++, t[num].Min = b[l]; return; }
	}
	pushdown( num );
	int mid = l + r >> 1;
	modify( lson, l, mid, L, R );
	modify( rson, mid + 1, r, L, R );
	t[num].sum = t[lson].sum + t[rson].sum;
	t[num].Min = min( t[lson].Min, t[rson].Min );
}

int query( int num, int l, int r, int L, int R ) {
	if( r < L or R < l ) return 0;
	if( L <= l and r <= R ) return t[num].sum;
	pushdown( num );
	int mid = l + r >> 1;
	return query( lson, l, mid, L, R ) + query( rson, mid + 1, r, L, R );
}

signed main() {
	int n, Q, l, r; char opt[10];
	while( ~ scanf( "%lld %lld", &n, &Q ) ) {
		for( int i = 1;i <= n;i ++ ) scanf( "%lld", &b[i] );
		build( 1, 1, n );
		for( int i = 1;i <= Q;i ++ ) {
			scanf( "%s %d %d", opt, &l, &r );
			if( opt[0] == 'a' ) modify( 1, 1, n, l, r );
			else printf( "%lld\n", query( 1, 1, n, l, r ) );
		}
	}
	return 0;
}

Picture

HDU1828

扫描线求矩阵周长模板题

img

从下往上扫描线扫，横线长度：现在这次总区间被覆盖的长度和上一次总区间被覆盖的长度之差的绝对值

而竖线长度为，区间的段数*2，乘以 2 2 2是因为一段区间左右各一条

e.g. 段数 c n t cnt cnt的计算

  • 若区间[0,10]被[1,2][4,5]覆盖，则cnt=2
  • 若区间[0,10]被[1,3][4,5]覆盖，则cnt=1（两区间刚好连在一起）
  • 若区间[0,10]被[1,5][2,6]覆盖，则cnt=1（两区间连起来还是一段）

扫描线中的线段树的一个节点代表一个单位长度线段

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
#define maxn 200005
#define lson num << 1
#define rson num << 1 | 1
struct node {
	int l, r, h, op;
	node(){}
	node( int L, int R, int H, int Op ) {
		l = L, r = R, h = H, op = Op;
	}
}E[maxn];
struct tree {
	int l, r, len, cnt, tag, flag_l, flag_r;
}t[maxn << 2];

bool cmp( node x, node y ) { return x.h < y.h; }

void build( int num, int l, int r ) {
	t[num].l = l, t[num].r = r;
	t[num].len = t[num].cnt = t[num].tag = t[num].flag_l = t[num].flag_r = 0;
	if( l == r ) return;
	int mid = l + r >> 1;
	build( lson, l, mid );
	build( rson, mid + 1, r );
}

void pushup( int num ) {
	if( t[num].tag ) {
		t[num].len = t[num].r - t[num].l + 1;
		t[num].cnt = t[num].flag_l = t[num].flag_r = 1;
	}
	else if( t[num].l == t[num].r )
		t[num].len = t[num].cnt = t[num].flag_l = t[num].flag_r = 0;
	else {
		t[num].len = t[lson].len + t[rson].len;
		t[num].cnt = t[lson].cnt + t[rson].cnt - ( t[lson].flag_r and t[rson].flag_l );
		t[num].flag_l = t[lson].flag_l, t[num].flag_r = t[rson].flag_r;
	}
}

void modify( int num, int l, int r, int val ) {
	if( t[num].r < l or r < t[num].l ) return;
	if( l <= t[num].l and t[num].r <= r ) {
		t[num].tag += val;
		pushup( num );
		return;
	}
	modify( lson, l, r, val );
	modify( rson, l, r, val );
	pushup( num );
}

int Fabs( int x ) { return x < 0 ? -x : x; }

int main() {
	int n, x1, y1, x2, y2;
	while( ~ scanf( "%d", &n ) ) {
		int L = 1e9, R = -1e9;
		for( int i = 1;i <= n;i ++ ) {
			scanf( "%d %d %d %d", &x1, &y1, &x2, &y2 );
			E[i] = node( x1, x2, y1, 1 );
			E[i + n] = node( x1, x2, y2, -1 );
			L = min( L, x1 );
			R = max( R, x2 );
		}
		n <<= 1; R --;
		sort( E + 1, E + n + 1, cmp );
		build( 1, L, R );
		int ans = 0, lst = 0;
		for( int i = 1;i <= n;i ++ ) {
			modify( 1, E[i].l, E[i].r - 1, E[i].op );
			ans += Fabs( t[1].len - lst ) + 2 * t[1].cnt * ( E[i + 1].h - E[i].h );
			lst = t[1].len;
		}
		printf( "%d\n", ans );
	}
	return 0;
}

Walking Race

POJ3162

用两次栈模拟 d p dp dp求出以每个点为端点的最长路径

用线段树维护区间内的路径最大值/最小值

尺取法，双指针判断区间 [ l , r ] [l,r] [l,r]是否在 m m m限制内

#include <stack>
#include <cstdio>
#include <vector>
#include <iostream>
using namespace std;
#define maxn 1000005
#define lson num << 1
#define rson num << 1 | 1
const int inf = 1e9;
int n, m;
bool vis[maxn];
int maxlen[maxn];
stack < int > sta;
vector < pair < int, int > > G[maxn];

struct node { 
	int fa, d, Max, id, sub_max, sub_id;
	void clear( int f, int dis ) { fa = f, d = dis, Max = id = sub_max = sub_id = 0; }	
}MS[maxn];

void dfs1() {
	for( int i = 1;i <= n;i ++ ) vis[i] = 0;
	sta.push( 1 ), MS[1].clear( 0, 0 );
	while( ! sta.empty() ) {
		int u = sta.top();
		if( ! vis[u] )
			for( int i = 0;i < G[u].size();i ++ ) {
				int v = G[u][i].first, dis = G[u][i].second;
				if( v == MS[u].fa ) continue;
				else MS[v].clear( u, dis ), sta.push( v );
			}
		else {
			sta.pop();
			for( int i = 0;i < G[u].size();i ++ ) {
				int v = G[u][i].first, dis = G[u][i].second;
				int len = MS[v].Max + dis;
				if( len > MS[u].Max ) {
					MS[u].sub_max = MS[u].Max;
					MS[u].sub_id = MS[u].id;
					MS[u].Max = len;
					MS[u].id = v;
				}
				else if( len > MS[u].sub_max ) {
					MS[u].sub_max = len;
					MS[u].sub_id = v;
				}
			}
		}
		vis[u] = 1;
	}
}

void dfs2() {
	sta.push( 1 );
	while( ! sta.empty() ) {
		int u = sta.top(); sta.pop();
		for( int i = 0;i < G[u].size();i ++ ) {
				int v = G[u][i].first;
			if( v == MS[u].fa ) continue;
			else sta.push( v );
		}
		maxlen[u] = MS[u].Max;
		if( u == 1 ) continue;
		else {
			int fa = MS[u].fa, len;
			if( MS[fa].id == u ) len = MS[fa].sub_max + MS[u].d;
			else len = MS[fa].Max + MS[u].d;
			maxlen[u] = max( maxlen[u], len );
			if( len > MS[u].Max ) {
				MS[u].sub_max = MS[u].Max;
				MS[u].sub_id = MS[u].id;
				MS[u].Max = len;
				MS[u].id = fa;
			}
			else if( len > MS[u].sub_max ) {
				MS[u].sub_max = len;
				MS[u].sub_id = fa;
			}
		}
	}
}

struct tree { int Min, Max; }t[maxn << 2];

void build( int num, int l, int r ) {
	if( l == r ) { t[num].Min = t[num].Max = maxlen[l]; return; }
	int mid = l + r >> 1;
	build( lson, l, mid );
	build( rson, mid + 1, r );
	t[num].Max = max( t[lson].Max, t[rson].Max );
	t[num].Min = min( t[lson].Min, t[rson].Min );
}

int query_min( int num, int l, int r, int L, int R ) {
	if( r < L or R < l ) return inf;
	if( L <= l and r <= R ) return t[num].Min;
	int mid = l + r >> 1;
	return min( query_min( lson, l, mid, L, R ), query_min( rson, mid + 1, r, L, R ) );
}

int query_max( int num, int l, int r, int L, int R ) {
	if( r < L or R < l ) return -inf;
	if( L <= l and r <= R ) return t[num].Max;
	int mid = l + r >> 1;
	return max( query_max( lson, l, mid, L, R ), query_max( rson, mid + 1, r, L, R ) );
}

int main() {
	int l, r, minn, maxx;
	while( ~ scanf( "%d %d", &n, &m ) ) {
		for( int i = 1;i <= n;i ++ ) G[i].clear();
		for( int i = 2, fa, d;i <= n;i ++ ) {
			scanf( "%d %d", &fa, &d );
			G[fa].push_back( make_pair( i, d ) );
		}
		dfs1(), dfs2(), build( 1, 1, n );
		l = r = 1, minn = maxx = maxlen[1];
		int ans = 0;
		while( l <= r and r <= n ) {
			if( maxx - minn <= m ) {
				ans = max( ans, r - l + 1 );
				r ++;
				minn = min( minn, maxlen[r] );
				maxx = max( maxx, maxlen[r] );
			}
			else {
				l ++;
				minn = query_min( 1, 1, n, l, r );
				maxx = query_max( 1, 1, n, l, r );
			}
			if( ans > n - l ) break;
		}
		printf( "%d\n", ans );
	}
	return 0;
}
ikrvxt
关注
专栏目录
[高级数据结构C++] 线段树（区间合并）
qq_73928885的博客
09-11 212
`线段树` 的**兄弟节点之间有相邻关系**
小A的题 线段树区间赋值
咸鱼
08-11 340
#include<bits/stdc++.h> using namespace std; const int inf=0x3f3f3f3f,mod=1e9+7,MAXN=1e6+4,MAXM=2e1+8; #define lowbit(x) ((x)&(-x)) #define Init(arr,val) memset(arr,val,sizeof(arr)) #define ...
模板：线段树 & 线段树区间赋值
SZTU_ZJB的博客
06-19 781
基础线段树 & 线段树区间赋值 struct SegmentTree{ // 线段树的结构体 int l, r; int dat, lazy; }t[maxn*4 + 2]; void Build(int p,int l,int r){ t[p].l = l, t[p].r = r; if (l == r) { t[p].dat = a[l]; return; } int mid = (l + r) >> 1; Build(lson, l, mid); // p*2 Bui
hihocoder 1080 线段树：区间加法&赋值
cww97的博客
08-19 587
题面蛮好玩的，，也行是因为我玩模拟城市的缘故 修模板了带两个操作的话，注意set和tag的顺序 每次down的时候先放set标记，再放tag标记 每次更新set的时候要把tag清空#include<cstdio> #include<cstring> #include<iostream> #include<algorithm> using namespace std; const int N =
线段树之区间赋值-帕吉的肉钩
077CYW的博客
04-18 574
#include&lt;iostream&gt;using namespace std;/*调试了好久才找出问题所在*/const int MAX_N=100010;struct node{ int l,r; int detal; int sum;}hook[MAX_N&lt;&lt;2];void pushup(int p){ hook[p].sum=hook[p&lt...
线段树区间赋值+区间和查询
CAOSHUCAOSHU的博客
11-03 780
如题，代码如下： #include<bits/stdc++.h> using namespace std; const int maxn=1e5+50; struct node{ int l,r,sum,lazy; }tree[maxn<<2]; void build(int p,int l,int r) { tree[p].l=l; tree[p].r=r; if(l==r){ tree[p].sum=1,tree[p].la
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
03-05
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
hdu5306(线段树＋区间取最值)jls线段树
bjfu170203101的博客
02-07 736
jls论文： 根据上面论文我们就可以做这题了。 终于学会了jls线段树。 手敲了下，看懂理论1h，写+bug就花了不到1h。 果然线段树我还是比较熟练的 马上搞下camp树套jls树。。。 #include<bits/stdc++.h> using namespace std; #define ls o*2 #define rs o*2+1 typedef long ...
hdu5306(线段树＋区间取最值)
llmxby
05-29 899
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5306 思路：这是１６年国家集训队jls的论文 #include <cstdio> #include <cstdlib> #include <cassert> #include <cstring> #include <bitset> ...
Gym - 101911E Painting the Fence(线段树-区间赋值)
小衣同学的博客
04-05 407
题目 n个数，以下输入a1-an m次操作，以下输入c1-cn ci表明找到还没有被覆盖的原序列ci这个数出现的最左和最右位置 然后把这段区间都赋成ci这个值， m次操作后，要求输出最后的序列 n,m,ai,cj<=3e5 思路来源 马老师 题解 每个颜色只会更新一次，用vis[]数组标记一下有没有覆盖过 即使被它覆盖的颜色再反过来把它覆盖，如1 2 1 2 1，先2后...
hdu1198 Just a Hook 线段树区间赋值
lych的博客
01-09 963
继续补线段树>_ AC代码如下： #include #include #include #define N 500005 using namespace std; int n,m,c[N][2],sum[N],val[N]; int read(){ int x=0; char ch=getchar(); while (ch'9') ch=getchar(); while (ch>='0
hdu1698 Just a Hook(线段树/区间赋值)
小衣同学的博客
03-22 333
题目 1-n个数，初始全为1， m个操作，第i次操作把[li,ri]赋成xi，1<=xi<=3 求m次操作后这n个数的和 1<=n<=1e5,0<=m<=1e5 思路来源 https://blog.csdn.net/zhouzi2018/article/details/81089816 题解 区间赋值 近乎裸的线段树板子，但之前没写过区间赋值，...
Just a Hook---线段树--区间赋值--区间查询
Leo_zehualuo的博客
04-07 374
题目描述 In the game of DotA, Pudge’s meat hook is actually the most horrible thing for most of the heroes. The hook is made up of several consecutive metallic sticks which are of the same length. Now Pu...
Recycle Rubbish 区间修改/赋值 线段树
NExPlain的专栏
12-12 1721
大连海事大学第一届编程马拉松挑战赛多校联赛DIV1 第一场1007，由于是private的比赛而且题目没有放出来，所以就不放题目连接了 题目大意就是一个数列实现区间值修改，区间值清零和区间查询，显然是线段树实现... 之前写的带Lazy标记的线段树只支持区间修改没有区间赋值，区间赋值跟修改还不太一样，相当于又打了一个标记，这个标记就是说：这个区间的值被清成了多少。 由于这道题的所有区间赋值都
动态开点线段树 区间加，区间赋值，区间询问
Love_xyh的博客
11-11 697
个人感觉，动态开点线段树，就是在普通线段树上套一个开点操作。（就是把原来的#define中的lson和rson，换一下即可） 区间加，区间询问 #include <bits/stdc++.h> #define int long long using namespace std; const int N=1e5+5; int n,m,x,y,v,now,cnt; int a[N],add...
加帕里的聚会 树链剖分 + 线段树(区间加 、区间赋值)
Le Petit Prince
09-27 564
加帕里的聚会 256MB / 1s ; japari.cpp / c /pas / in / out 【题目描述】 加帕里公园里有n个区域，n-1条道路将它们连接到了一起，形成了一个树的结构。开始时，第i个区域有Ai个friends，但是由于砂之星的作用，有时从x区域到y区域的简单路径上的所有区域的friends数量都会增加v，有时从x区域到y区域的简单路径上所有区域的friends数量都会
UVA 11992 Fast MatrixOperations(线段树:区间查询+区间赋值+区间增值）
pxlsdz的博客
01-13 391
  题目描述 PDF 输入输出格式 输入格式：     输出格式：     输入输出样例 输入样例#1： 复制 4 4 8 1 1 2 4 4 5 3 2 1 4 4 1 1 1 3 4 2 3 1 2 4 4 3 1 1 3 4 2 2 1 4 4 2 3 1 2 4 4 1 1 1 4 3 3 输出样例#1： 复制 45 0 5 78 5 7 69 ...
hdu1698 线段树区间赋值
weixin_33980459的博客
07-23 136
1 #include<stdio.h> 2 #include<iostream> 3 #include<string.h> 4 #include<algorithm> 5 #include<math.h> 6 using namespace std; 7 int yy2,yy1,v,fsum; 8 int...
Mex HDU - 4747 (线段树区间赋值更新/递推dp)
肘子的博客
01-16 301
传送门 题意：给出一个数组，求出这个数组每个区间的mex()和 题解：第一种解法参考了bin巨的传送门 附上代码： #include&lt;bits/stdc++.h&gt; using namespace std; const int MAXN = 200010; struct Node { int l,r; long long sum;//区间和 int...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值