Yeahpeng's inequality

最新推荐文章于 2023-09-28 18:48:42 发布

HandsomeHow

最新推荐文章于 2023-09-28 18:48:42 发布

阅读量507

点赞数

分类专栏： 2016SWJTU校赛资格赛

本文链接：https://blog.csdn.net/HandsomeHow/article/details/51249600

版权

2016SWJTU校赛资格赛专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Yeahpeng's inequality

Time Limit:3000MS Memory Limit:65536K
Total Submit:35 Accepted:5

Description

Yeahpeng is not good at inequality. Unfortunately, there are many inequalities in his homework and they make him be in trouble. Cornered yeah wants your help.
There are n inequalities in total and the form is:
Op x
Op is one of {>=, >, =, <, <=}, x is an integer. What he wants to know is how many inequalities can be satisfied at most in the first i inequalities.

Input

Input contains multiple test cases.
In each test case, the first line is a integer n(1 <= n <= 50,000)
The following n line is the inequalities [op x].

Output

For each test case print n lines. An integer in each line, the maximum numbers can be satisfied in the first i inequalities.

Sample Input

5
<= 10
< 9
> 6
>= 7
= 8

Sample Output

题意：给定n个不等式，第i次询问前i个不等式中可以有几个共存。

思路：每个不等式对应了一个区间，即询问区间上被覆盖次数最多的点被覆盖了几次。

解法：先将所有的不等式读入，然后将x离散化一下，把>,<强制转化为>=,<=,然后把区间放到线段树上，每次更新一个区间,树根的max值即为整段区间上被覆盖次数最多的点的覆盖次数。因为每次都要覆盖，可以打一下lazy标记。

AC代码：

//************************************************************************//
//*Author : Handsome How                                                 *//
//************************************************************************//
//#pragma comment(linker, "/STA	CK:1024000000,1024000000")
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <ctime>
using namespace std;
typedef long long ll;
//----------------------------------------------------------
/*
	将不等式的x离散化一下，对于每一个出现的数，映射为2*他的排名  即i=rank[i]*2 
	那么 >=x 覆盖的区间为[2*rank[x],maxlen] 
	>x	覆盖的区间为[2*rank[x]+1,maxlen] 
	<=x	覆盖的区间为[0,2*rank[x]] 
	<x  覆盖的区间为[0,2*rank[x]-1] 
	建立线段树维护区间内覆盖点的次数 
	那么根结点的max值即为所有区间内被覆盖最多点的次数 
*/
const int maxn = 50000+5;
int n,maxlen;
map<ll,int>rk;
struct Node{
	ll v;
	char op[5];
}node[maxn+5],ori[maxn+5];//分别记录排序后的以及原来的不等式 

struct Tree{
	int l;
	int r;
	int max;
	int lazy;
}tree[maxn*4*4+5];

void build(int l,int r,int root){			 
	tree[root].l = l;tree[root].r=r;
	tree[root].max = 0;
	tree[root].lazy = 0;
	if(l==r) return;
	int mid = (l+r)>>1;
	build(l,mid,root<<1);
	build(mid+1,r,root<<1|1);
}

bool cmp(Node a,Node b){return a.v<b.v;}

void pushdown(int root){
	int lazy = tree[root].lazy ;
	tree[root].lazy = 0;
	tree[root<<1].max +=lazy;
	tree[root<<1].lazy +=lazy;
	tree[root<<1|1].max +=lazy;
	tree[root<<1|1].lazy +=lazy;
}

void init(){
	rk.clear();
	int count = 1;
	sort(node+1,node+1+n,cmp);						
	for(int i=1;i<=n;i++){
		if(rk[node[i].v]==0){		//离散化  将  >=a  的标记为偶数2n 这样如果>a 可强制转化为>=2n+1 
			rk[node[i].v]=count*2;	//将<a 强制转化为<=2n-a 
			count++;	
		}
	}
	maxlen=count*2+2;
	build(1,maxlen,1);	
}

void cover(int l,int r,int root){
	if(tree[root].l==tree[root].r){		 
		if(tree[root].l>=l&&tree[root].l<=r)		//找到最后单点的叶子 判断是否被区间覆盖
		tree[root].max++;
		return;
	}
	if(l>tree[root].r||r<tree[root].l)return;		//超出范围 不能覆盖 
	if(tree[root].l>=l&&tree[root].r<=r){			//打lazy标记 
		tree[root].max++;
		tree[root].lazy++;
		return;
	}
	pushdown(root);
	cover(l,r,root<<1);
	cover(l,r,root<<1|1);
	tree[root].max = max(tree[root<<1].max ,tree[root<<1|1].max); 
}

int main()
{
	while(scanf("%d",&n)!=EOF){
		for(int i=1;i<=n;i++){
			scanf("%s",node[i].op);
			strcpy(ori[i].op,node[i].op);
			scanf("%d",&node[i].v);
			ori[i].v=node[i].v;		//读入不等式并拷贝一份 
		}
		init();					
		for(int i=1;i<=n;i++){
			if(ori[i].op[0]=='=') cover(rk[ori[i].v],rk[ori[i].v],1);
			else if(ori[i].op[0]=='>'&&ori[i].op[1]=='=') cover(rk[ori[i].v],maxlen,1);
			else if(ori[i].op[0]=='<'&&ori[i].op[1]=='=') cover(0,rk[ori[i].v],1);
			else if(ori[i].op[0]=='>')	cover(rk[ori[i].v]+1,maxlen,1);
			else cover(0,rk[ori[i].v]-1,1);
			printf("%d\n",tree[1].max);
		}		
	}
	return 0;
}