Codeforces-1199D-Welfare State + HDU-4306-Gorgeous Sequence（线段树）

最新推荐文章于 2020-07-27 20:42:15 发布
原创 最新推荐文章于 2020-07-27 20:42:15 发布 · 459 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#线段树 #CF #HDU

本文探讨了线段树在区间更新与查询中的应用，包括单点更新、区间更新及求最大值与和的复杂操作。通过Codeforces与HDU两道题目，详细解析了线段树的构建、更新及查询过程，展示了如何处理区间内的最大值、最小值及求和等问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Codeforces-1199D-Welfare State:

There is a country with nn citizens. The ii-th of them initially has aiai money. The government strictly controls the wealth of its citizens. Whenever a citizen makes a purchase or earns some money, they must send a receipt to the social services mentioning the amount of money they currently have.

Sometimes the government makes payouts to the poor: all citizens who have strictly less money than xx are paid accordingly so that after the payout they have exactly xx money. In this case the citizens don't send a receipt.

You know the initial wealth of every citizen and the log of all events: receipts and payouts. Restore the amount of money each citizen has after all events.

Input

The first line contains a single integer nn (1≤n≤2⋅1051≤n≤2⋅105) — the numer of citizens.

The next line contains nn integers a1a1, a2a2, ..., anan (0≤ai≤1090≤ai≤109) — the initial balances of citizens.

The next line contains a single integer qq (1≤q≤2⋅1051≤q≤2⋅105) — the number of events.

Each of the next qq lines contains a single event. The events are given in chronological order.

Each event is described as either 1 p x (1≤p≤n1≤p≤n, 0≤x≤1090≤x≤109), or 2 x (0≤x≤1090≤x≤109). In the first case we have a receipt that the balance of the pp-th person becomes equal to xx. In the second case we have a payoff with parameter xx.

Output

Print nn integers — the balances of all citizens after all events.

Examples

input

4
1 2 3 4
3
2 3
1 2 2
2 1

output

3 2 3 4

input

5
3 50 2 1 10
3
1 2 0
2 8
1 3 20

output

8 8 20 8 10

题意：1操作把p位置的值更改为x，2操作把整个序列中小于x的位置的值更改为x，输出最终的整个序列

题意分析：线段树题目，记录一个最小值，当我当前的最小值都要大于x的时候，那么我就不需要操作；否则，把当前更改的值lazytag标记下来，等之后的查询和1操作进行pushdown操作，把之前需要更改的值记录下来递归到子树中，在子树中碰到那些最小值大于当前的x的那么就直接return，有小于的就继续递归直到找到最终位置，这题目值得学习，加深了对线段树的理解和查询整个区间的方法

代码：

#include<bits/stdc++.h>
#define N 200005
using namespace std;
int n,m;
int a[N];
struct ljh
{
    int l,r,mn,lazy;
}e[4*N];
inline void makelazy(int node)
{
    if(e[node].lazy)
    {
        if(e[node<<1].mn<e[node].lazy)
        {
            e[node<<1].mn=e[node].lazy;
            e[node<<1].lazy=e[node].lazy;
        }
        if(e[node<<1|1].mn<e[node].lazy)
        {
            e[node<<1|1].mn=e[node].lazy;
            e[node<<1|1].lazy=e[node].lazy;
        }
    }
    e[node].lazy=0;
}
void Build(int node,int left,int right)
{
    e[node].l=left;
    e[node].r=right;
    e[node].lazy=0;
    if(left==right)
    {
        e[node].mn=a[left];
        return;
    }
    int m=(left+right)>>1;
    Build(node<<1,left,m);
    Build(node<<1|1,m+1,right);
    e[node].mn=min(e[node<<1].mn,e[node<<1|1].mn); 
}
void Update(int node,int pos,int y)
{
    if(e[node].l==pos&&e[node].r==pos)
    {
        // cout<<"ys\n";
        e[node].mn=y;
        // cout<<node<<" "<<e[node].mn<<endl;
        return;
    }
    makelazy(node);
    int m=(e[node].l+e[node].r)>>1;
    if(pos<=m)Update(node<<1,pos,y);
    else Update(node<<1|1,pos,y);
    e[node].mn=min(e[node<<1].mn,e[node<<1|1].mn);
}
void Update1(int node,int x)
{
    if(e[node].mn>=x)return;
    if(e[node].mn<x)
    {
        // cout<<node<<endl;
        e[node].lazy=x;
        e[node].mn=x;
        return;
    }
    /*makelazy(node);
    int m=(e[node].l+e[node].r)>>1;
    Update1(node<<1,x);
    Update1(node<<1|1,x);
    e[node].mn=min(e[node<<1].mn,e[node<<1|1].mn);*/
}
void Query(int node)
{
    if(e[node].l==e[node].r)
    {
        printf("%d ",e[node].mn);
        return;
    }
    makelazy(node);
    Query(node<<1);
    Query(node<<1|1);
    e[node].mn=min(e[node<<1].mn,e[node<<1|1].mn);
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    Build(1,1,n);
    scanf("%d",&m);
    while(m--)
    {
        int op,x,y;
        scanf("%d",&op);
        if(op==1)
        {
            scanf("%d%d",&x,&y);
            Update(1,x,y);
            // Query(1);
            // cout<<endl;
        }
        else
        {
            scanf("%d",&x);
            Update1(1,x);
            // Query(1);
            // cout<<endl;
        }
    }
    Query(1);
    return 0;
}

HDU-5306-Gorgeous Sequence：

There is a sequence a of length n . We use ai to denote the i -th element in this sequence. You should do the following three types of operations to this sequence.
0 x y t : For every x≤i≤y , we use min(ai,t) to replace the original ai 's value.
1 x y : Print the maximum value of ai that x≤i≤y .
2 x y : Print the sum of ai that x≤i≤y .

Input

The first line of the input is a single integer T , indicating the number of testcases.
The first line contains two integers n and m denoting the length of the sequence and the number of operations.
The second line contains n separated integers a1,…,an (∀1≤i≤n,0≤ai<231 ).
Each of the following m lines represents one operation (1≤x≤y≤n,0≤t<231 ).
It is guaranteed that T=100 , ∑n≤1000000, ∑m≤1000000 .

Output

For every operation of type 1 or 2 , print one line containing the answer to the corresponding query.

Sample Input

1

5 5

1 2 3 4 5

1 1 5

2 1 5

0 3 5 3

1 1 5

2 1 5

Sample Output

5 15 3 12

 题意：跟上面的差不多，不过这里的是把所有区间改成了从x到y内，所以大于z的就改为z，查询x到y最大值，再求x到y的和

题意分析：这个题目我最开始稍微改一下就好了，后面发现求sum是一个麻烦，因为更改最大值，只需要在父节点树中更改，但是求和不好怎么更改啊。。。必须要递归到子树，后来想，如果我在更改时加上一个最小值，当最小值也大于等于z时，那么他的子树的sum就直接全部更改为(r-l+1)*z了，顺利过了样例，交上去WA了，后来实在不会，看了这篇博客，因为临近省赛选拔也就没有自己再写了，理解了一下求法，在最大值的基础上加上最大值的个数，跟次大值的数，碰到当 次大值<z<最大值 时只需要对最大值进行更改，sum+=最大值个数*最大值就好了，然后把最大值当成lazytag标记，每次都是求取的最大值的sum在慢慢递归下去，进行剪枝

AC代码：

#include<cstdio>
#include<iostream>
#define lc k<<1
#define rc k<<1|1
#define EF if(ch==EOF) return x;
using namespace std;
typedef long long ll;
inline int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;EF;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int N=1e6+5;
const int M=N<<2;
int n,m,a[N];
ll sum[M];int mx[M],se[M],mc[M];
//最大值，次大值，最大值个数
inline void updata(int k){
    sum[k]=sum[lc]+sum[rc];
    mx[k]=max(mx[lc],mx[rc]);//最大值
    se[k]=max(se[lc],se[rc]);//次大值
    mc[k]=0;//最大值个数
    if(mx[lc]!=mx[rc]) 
        se[k]=max(se[k],min(mx[lc],mx[rc]));//选择次大值
    if(mx[k]==mx[lc]) mc[k]+=mc[lc];
    //如果左边有最大值，那么加上左边最大值的个数
    if(mx[k]==mx[rc]) mc[k]+=mc[rc];
    //如果右边有最大值，加上右边最大值个数
}
inline void dec_tag(int k,int v){
    if(v>=mx[k]) return ;
    sum[k]+=1LL*(v-mx[k])*mc[k];
    mx[k]=v;
}
inline void pushdown(int k){
    dec_tag(lc,mx[k]);
    //采用最大值来更新,其实最大值也就可以相当于是lazytag标记，其实就是每次对最大值的那些地方进行更改，但是我个人甚至认为会T
    dec_tag(rc,mx[k]);
}

void build(int k,int l,int r){
    if(l==r){
        sum[k]=mx[k]=a[l];
        mc[k]=1;
        se[k]=-1;
        return ;
    }
    int mid=(l+r)>>1;
    build(lc,l,mid);
    build(rc,mid+1,r);
    updata(k);
}

void change(int k,int l,int r,int x,int y,int v){
    if(v>=mx[k]) return ;
    if(l==x&&r==y&&v>se[k]){
        dec_tag(k,v);return ;//只需要更改最大值
    }
    pushdown(k);
    int mid=(l+r)>>1;
    if(y<=mid) change(lc,l,mid,x,y,v);
    else if(x>mid) change(rc,mid+1,r,x,y,v);
    else change(lc,l,mid,x,mid,v),change(rc,mid+1,r,mid+1,y,v);
    updata(k);    
}

int query_max(int k,int l,int r,int x,int y){
    if(l>=x&&r<=y) return mx[k];
    pushdown(k);
    int mid=l+r>>1;
    if(y<=mid) return query_max(lc,l,mid,x,y);
    else if(x>mid) return query_max(rc,mid+1,r,x,y);
    else return max(query_max(lc,l,mid,x,mid),query_max(rc,mid+1,r,mid+1,y));
}
ll query_sum(int k,int l,int r,int x,int y){
    if(l==x&&r==y) return sum[k];
    pushdown(k);
    int mid=l+r>>1;
    if(y<=mid) return query_sum(lc,l,mid,x,y);
    else if(x>mid) return query_sum(rc,mid+1,r,x,y);
    else return query_sum(lc,l,mid,x,mid)+query_sum(rc,mid+1,r,mid+1,y);
}
inline void work(){
    n=read();m=read();
    for(int i=1;i<=n;i++) a[i]=read();
    build(1,1,n);
    for(int i=1,opt,x,y,z;i<=m;i++){
        opt=read();x=read();y=read();
        if(opt==0) z=read(),change(1,1,n,x,y,z);
        if(opt==1) printf("%d\n",query_max(1,1,n,x,y));
        if(opt==2) printf("%lld\n",query_sum(1,1,n,x,y));
    }
}
int main(){
    for(int T=read();T--;) work();
    return 0;
}

TLE代码：

#include<bits/stdc++.h>
#define N 1000005
#define LL long long
using namespace std;
int t,n,m;
LL a[N],ans;
struct ljh
{
	int l,r;
	LL lazy,sum,mx,mn;
}e[N*4];
inline void make(int node)
{
	e[node].sum=e[node<<1].sum+e[node<<1|1].sum;
	e[node].mx=max(e[node<<1].mx,e[node<<1|1].mx);
	e[node].mn=min(e[node<<1].mn,e[node<<1|1].mn);
}
inline void makelazy(int node)
{
	if(e[node].lazy)
	{
		if(e[node<<1].mx>e[node].lazy)
		{
			e[node<<1].lazy=e[node].lazy;
			e[node<<1].mx=e[node].lazy;
		}
		if(e[node<<1].mn>e[node].lazy)
		{
			e[node].mn=e[node].lazy;
		}
		if(e[node<<1|1].mx>e[node].lazy)
		{
			e[node<<1|1].lazy=e[node].lazy;
			e[node<<1|1].mx=e[node].lazy;
		}
		if(e[node<<1|1].mn>e[node].lazy)
		{
			e[node<<1|1].mn=e[node].lazy;
		}
		e[node].lazy=0;
	}
}
void Build(int node,int left,int right)
{
	e[node].l=left;
	e[node].r=right;
	e[node].lazy=0;
	if(left==right)
	{
		e[node].mn=a[left];
		e[node].mx=a[left];
		e[node].sum=a[left];
		return;
	}
	makelazy(node);
	int m=(left+right)>>1;
	Build(node<<1,left,m);
	Build(node<<1|1,m+1,right);
	make(node);
}
void Update(int node,int x,int y,LL z)
{
	if(e[node].mx<=z)return;
	if(x<=e[node].l&&e[node].r<=y&&e[node].mn>=z)
	{
		e[node].lazy=z;
		e[node].mx=z;
		e[node].mn=z;
		e[node].sum=(e[node].r-e[node].l+1)*z;
		return;
	}
	makelazy(node);
	int m=(e[node].l+e[node].r)>>1;
	if(x<=m)Update(node<<1,x,y,z);
	if(y>m)Update(node<<1|1,x,y,z);
	make(node);
}
LL Querymax(int node,int x,int y)
{
	LL Max=0;
	if(x<=e[node].l&&e[node].r<=y)
	{
		return e[node].mx;
	}
	makelazy(node);
	int m=(e[node].l+e[node].r)>>1;
	if(x<=m)
	Max=max(Max,Querymax(node<<1,x,y));
	if(y>m)
	Max=max(Max,Querymax(node<<1|1,x,y));
	return Max;
}
void Querysum(int node,int x,int y)
{
	if(x<=e[node].l&&e[node].r<=y)
	{
		ans+=e[node].sum;
		return;
	}
	makelazy(node);
	int m=(e[node].l+e[node].r)>>1;
	if(m>=x)Querysum(node<<1,x,y);
	if(m<y)Querysum(node<<1|1,x,y);
}
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;i++)scanf("%lld",&a[i]);
		Build(1,1,n);
		while(m--)
		{
			int op,x,y;
			LL z;
			scanf("%d",&op);
			if(op==0)
			{
				scanf("%d%d%lld",&x,&y,&z);
				Update(1,x,y,z);
			}
			if(op==1)
			{
				scanf("%d%d",&x,&y);
				printf("%lld\n",Querymax(1,x,y));
			}
			if(op==2)
			{
				ans=0;
				scanf("%d%d",&x,&y);
				Querysum(1,x,y);
				printf("%lld\n",ans);
			}
		}
	}
}

 

CodeForces---787D：Legacy【线段树优化建图+最短路】
KobeDuu
06-16 597
题目： 戳这里啊~~~ 题意： 给你三种操作：（1）点到点建边；（2）点到区间建边；（3）区间到点建边；最后求起点到其他点的最短距离 分析： 最短距离无非建边跑Dijkstra即可，考虑如何对区间建边，如果直接对区间的每一点建边，那N^2的复杂度是行不通的，考虑将区间映射到线段树上的一个点： （1）建两颗线段树，一颗表示出度的点，一颗表示入度的点 （2）对于表示出度的树，对每一节点和...
Codeforces-1354D-Multiset（权值线段树+二分+内存优化）
qq_43461168的博客
09-03 301
D. Multiset Note that the memory limit is unusual. You are given a multiset consisting of n integers. You have to process queries of two types: add integer k into the multiset; find the k-th order statistics in the multiset and remove it. k-th order statis
Welfare State CodeForces - 1199D（线段树）
starlet_kiss的博客
08-02 368
There is a country with n citizens. The i-th of them initially has ai money. The government strictly controls the wealth of its citizens. Whenever a citizen makes a purchase or earns some money, they ...
CodeForces - 1199D
Autumn_ghost的博客
08-19 246
yan奇奇是个大傻傻(づ￣ 3￣)づ #include<iostream> #include<cstdio> #include<algorithm> #include<cstring> #include<map> typedef long long ll; const int maxn = 4e5+20; using namespace ...
Codeforces 1199D-Welfare State【思维】
weixin_43895356的博客
07-27 203
题目链接 题意 给一个大小n的数组，有q次操作，操作有两种： 1 p x，将第p个数变成x； 2 x，将数组中小于x的数变成x，大于x的数不变 思路 用last[i]数组记录一下第i个数的最后一次1操作是总操作的第几次操作； lastX数组记录第i个数最后一次1操作改变的的数（或者原本的数） lastAllToX数组记录第i次操作后面（包括i）的2操作最大的x lastAllToX数组的构建就是先...
【题解】CodeForces - 1199D Welfare State 线段树
替这位空想家惊讶
08-18 201
题目链接：http://codeforces.com/problemset/problem/1199/D 题目大意：对一个数组进行
hdu - 4306 - Mahjong - 2 -sat
Julyana_Lin_夜
10-14 915
题意： 给定原矩阵和目标矩阵。http://acm.hdu.edu.cn/showproblem.php?pid=4306 两种操作： 选一横行的两元素交换（花费ca）。 选一列的两元素交换（cb）。 连续一个操作只花费一次。 问：从原矩阵到目标矩阵最小花费。 官方解法： 我就随便看看吧。 这道题目需要用2-sat解决，但要成功转化出模型需要一些巧妙的构造和基础图论知识的证明，
codeforces-cli：使用CLI的简单解析和检查工具，可解决来自Codeforce的问题
02-04
codeforces-cli 在python和bash中使用简单的解析和检查实现，以解决Codeforce中的竞赛。\ 安装 git clone " https://github.com/siddharth17196/codeforces-cli.git " cd codeforces-cli/scripts bash install.sh ...
Codeforces-Solution
05-03
Codeforces是一个知名的在线编程竞赛平台，它吸引了众多程序员和编程爱好者参与解决各种算法问题，以提升编程技能和逻辑思维能力。"Codeforces-Solution"很可能是一个包含针对Codeforces上问题的解题代码库，主要...
PDF-CodeForces-Problems:PDF文件中的CodeForces问题
05-12
PDF-CodeForces问题 PDF文件中的CodeForces问题 利用CodeForces提取在这个库中的文件 ，文件夹名代表来自CodeForces网址contests`的ID，每个文件夹包含比赛的问题。 有关CodeForces竞赛的疯狂事实 CodeForces上有937...
Codeforces 1199 简要题解
苟为蒟蒻又何妨
07-31 483
文章目录A题B题C题D题E题F题 比赛传送门 A题 传送门 模拟 代码： #include<bits/stdc++.h> #define ri register int #define fi first #define se second using namespace std; inline int read(){ #define gc getchar int ans=0; c...
kuangbin带你飞 KMP专题
默的博客
05-03 394
Given two sequences of numbers : a[1], a[2], … , a[N], and b[1], b[2], … , b[M] (1 <= M <= 10000, 1 <= N <= 1000000). Your task is to find a number K which make a[K] = b[1], a[K + 1] = b[2...
关于简单的字符串Hash
_C9的博客
06-27 241
字符串Hash（KMP）属于哈希算法的一种，主要用于解决字符串匹配问题，就以前碰到这类题目我一定会去直接暴力模拟，但是这样就会超时，用字符串Hash就可以很好的解决这一种问题，他是把一段字符串转化成一种具体的数值，我们成为哈希值，通过匹配数值来判断字符串是否匹配，配上一道例题直观解决一下，这是一道我觉得很典型的例题，就可以当作KMP算法的模板 The French author Georges Perec (1936–1982) once wrote a book, La disparition, wit
第二次习题2020.5.22
xiaoxu778的博客
05-26 1908
A - Candies Recently Vova found nn candy wrappers. He remembers that he bought xx candies during the first day, 2x2x candies during the second day, 4x4x candies during the third day, ……, 2k−1x2k−1x candies during the kk-th day. But there is an issue: Vova
Kuangbin专题十六KMP & 扩展KMP & Manacher(A~L)
叶子心情你不懂
09-29 655
  A - Number Sequence  HDU - 1711 Given two sequences of numbers : a[1], a[2], ...... , a[N], and b[1], b[2], ...... , b[M] (1 &lt;= M &lt;= 10000, 1 &lt;= N &lt;= 1000000). Your task is to find a ...
cf1198B B. Welfare State（线段树单点修改加区间修改）
dream_it_的博客
08-01 329
B. Welfare State time limit per test2 seconds memory limit per test256 megabytes inputstandard input outputstandard output There is a country with n citizens. The i-th of them initially has ai money. ...
[kuangbin专题] KMP POJ 3461 Oulipo
Double__E的博客
04-09 301
题目链接 The French author Georges Perec (1936–1982) once wrote a book, La disparition, without the letter 'e'. He was a member of the Oulipo group. A quote from the book: Tout avait Pair normal, mais ...
"巴卡斯杯" 中国大学生程序设计竞赛 - 女生专场（重现）解题思路
热门推荐
queuelovestack的专栏
05-28 1万+
"巴卡斯杯" 中国大学生程序设计竞赛 - 女生专场（重现）解题思路
Codeforces 736D
visit_world的博客
04-06 1807
题意给出一个 n×nn\times n 的 0-1方阵 MM，MM 中恰有 mm 个位置为 1，其它为 0。保证有：det(M)≡1mod2\det(M)\equiv 1\mod 2对 MM 中的每个 1，回答：把这个 1 修改为 0 后，det(M′)mod2\det(M')\mod 2 约定：n≤2000n\leq 2000，m≤min(n2,500000)m\leq min(n^2,5000
Codeforces-cli：一个高效的命令行工具来解析和检查Codeforces问题
在详细说明知识点之前，需要明确“codeforces-cli”是一个为Codeforces用户提供的命令行界面（CLI）工具，它能够辅助用户在Codeforces的编程竞赛中解析问题并检查测试用例的输出。Codeforces是一个面向程序员的在线...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值