2018牛客多校第6场 I Team Rocket

最新推荐文章于 2018-08-27 23:03:23 发布
最新推荐文章于 2018-08-27 23:03:23 发布
阅读量169 收藏
点赞数
分类专栏： 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liufengwei1/article/details/81448390
版权

考场上用的set存储，然后就case:60%超时了。。。。用vector存可以少一个log，2900ms过得，常数还是不太好。。。我们对每个区间的左端点进行离散化，然后线段树每个叶子节点表示为左端点离散化后的值，每个点存一个vector，里面存储区间左端点在当前节点表示区间中的区间的右端点的值，那么我们对于每一个摧毁的位置pos，二分找到比pos小或等于的最近的左区间端点离散化后的值x，那么我们就去1-x这个区间中找其中存储的区间中右端点大于等于pos的那些区间，把他们删掉。我们对每个节点的vector排个序后，再进行二分操作，一个区间只在logn个节点中出现，每个点也只被删除一次，所以vector的二分复杂度是越来越小的，总复杂度就可以近似nlogn

#include<cstdio>
#include<cstring>
#include<set>
#include<algorithm>
#include<vector>
#define maxl 200010
#define mod 998244353

using namespace std;

int n,m,cas,res,tot,cnt,L,R,tm;
struct nb
{
	int num,id,f;
	bool operator < (const nb &b) const
	{
		return num<b.num;
	}
}b[maxl];
struct ddd
{
	int r,id;
	bool operator < (const ddd &b) const
	{
		if(r==b.r)
			return id<b.id;
		return r<b.r;
	}
};
struct dddd
{
	int l,r,id;
	bool operator < (const ddd &b) const
	{
		if(r==b.r)
			return id<b.id;
		return r<b.r;
	}
}
a[maxl];
struct node
{
	int l,r;
	vector <ddd> s;
}tree[maxl<<2];
int ans[maxl];
set <ddd> ::iterator it;

bool cmp(const nb &x,const nb &y)
{
	return x.num<y.num;
}

inline void build(int k,int l,int r)
{
	tree[k].l=l;tree[k].r=r;tree[k].s.clear();
	if(l==r)
		return;
	int mid=(l+r)>>1;
	build(k<<1,l,mid);
	build(k<<1|1,mid+1,r);
}

inline void add(int k,ddd d)
{
	tree[k].s.push_back(d);
	if(tree[k].l==tree[k].r)
		return;
	int mid=(tree[k].l+tree[k].r)>>1;
	if(L<=mid)
		add(k<<1,d);
	else
		add(k<<1|1,d);
}

inline void sorttree(int k)
{
	if(tree[k].l==tree[k].r)
		return;
	sort(tree[k].s.begin(),tree[k].s.end());
	sorttree(k<<1);sorttree(k<<1|1);
}

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while(ch<'0' || ch>'9') {if(ch=='-') f=-1;ch=getchar();}
	while(ch>='0' &&ch<='9') x=x*10+ch-'0',ch=getchar();
	return x*f;
}

inline void prework()
{
	//scanf("%d%d",&n,&m);
	n=read();m=read();
	for(register int i=1;i<=n;++i)
	{
		//scanf("%d%d",&a[i].l,&a[i].r);
		a[i].l=read();a[i].r=read();
		a[i].id=i;
		b[i].num=a[i].l;b[i].id=i;
		ans[i]=0;
	}
	sort(b+1,b+1+n,cmp);
	cnt=1;b[1].f=cnt;
	a[b[1].id].l=cnt;
	for(register int i=2;i<=n;++i)
	if(b[i].num==b[i-1].num)
	{
		a[b[i].id].l=cnt;
		b[i].f=cnt;
	}
	else
	{
		++cnt;
		a[b[i].id].l=cnt;
		b[i].f=cnt;
	}
	build(1,1,cnt);
	ddd d;
	for(register int i=1;i<=n;++i)
	{
		d.r=a[i].r;d.id=a[i].id;
		L=a[i].l;
		add(1,d);
	}
	sorttree(1);
}

inline void query(int k,int pos)
{
	if(L<=tree[k].l && tree[k].r<=R)
	{
		ddd d;d.id=0;d.r=pos;
		int ind=lower_bound(tree[k].s.begin(),tree[k].s.end(),d)-tree[k].s.begin();
		for(int i=ind;i<tree[k].s.size();i++)
		{
			int idx=tree[k].s[i].id;
			if(!ans[idx])
				tot++,res=(1ll*res*idx)%mod,ans[idx]=tm;
		}
		tree[k].s.erase(tree[k].s.begin()+ind,tree[k].s.end());
		return;
	}
	int mid=(tree[k].l+tree[k].r)>>1;
	if(R<=mid)
		query(k<<1,pos);
	else
	if(L>mid)
		query(k<<1|1,pos);
	else
	{
		query(k<<1,pos);
		query(k<<1|1,pos);
	}
}

inline void mainwork()
{
	printf("Case #%d:\n",cas);
	int pos,x;b[0].f=0;res=0;tot=0;
	for(register int i=1;i<=m;++i)
	{
		scanf("%d",&pos);
		pos=pos^res;
		nb d;d.num=pos;
		x=lower_bound(b+1,b+1+n,d)-b;
		if(b[x].num==pos)
			x=b[x].f;
		else
			x=b[x-1].f;
		if(x==0)
		{
			res=0;tot=0;
			printf("%d\n",tot);
			continue;
		}
		res=1;tot=0;
		ddd desd;
		tm=i;L=1;R=x;
		query(1,pos);
		printf("%d\n",tot);
		if(tot==0)
			res=0;
	}
}

inline void print()
{
	for(register int i=1;i<=n;++i)
		printf("%d%c",ans[i],i==n?'\n':' ');
}

int main()
{
	int t;
	freopen("9.in","r",stdin);
	freopen("9.out","w",stdout);
	scanf("%d",&t);
	for(cas=1;cas<=t;++cas)
	{
		prework();
		mainwork();
		print();
	}
	return 0;
}
#include<cstdio>
#include<cstring>
#include<set>
#include<algorithm>
#define maxl 200010
#define mod 998244353
 
using namespace std;
 
int n,m,cas,res,tot,cnt,L,R;
struct nb
{
    int num,id,f;
    bool operator < (const nb &b) const
    {
        return num<b.num;
    }
}b[maxl];
struct ddd
{
    int r,id;
    bool operator < (const ddd &b) const
    {
        if(r==b.r)
            return id<b.id;
        return r<b.r;
    }
};
struct dddd
{
    int l,r,id;
    bool operator < (const ddd &b) const
    {
        if(r==b.r)
            return id<b.id;
        return r<b.r;
    }
}
a[maxl];
struct node
{
    int l,r;
    set <ddd> s;
}tree[maxl<<2];
int ans[maxl];
set <ddd> ::iterator it;
 
bool cmp(const nb &x,const nb &y)
{
    return x.num<y.num;
}
 
inline void build(int k,int l,int r)
{
    tree[k].l=l;tree[k].r=r;tree[k].s.clear();
    if(l==r)
        return;
    int mid=(l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
}
 
inline void add(int k,ddd d)
{
    tree[k].s.insert(d);
    if(tree[k].l==tree[k].r)
        return;
    int mid=(tree[k].l+tree[k].r)>>1;
    if(L<=mid)
        add(k<<1,d);
    else
        add(k<<1|1,d);
}
 
inline void prework()
{
    scanf("%d%d",&n,&m);
    for(register int i=1;i<=n;++i)
    {
        scanf("%d%d",&a[i].l,&a[i].r);
        a[i].id=i;
        b[i].num=a[i].l;b[i].id=i;
        ans[i]=0;
    }
    sort(b+1,b+1+n,cmp);
    cnt=1;b[1].f=cnt;
    a[b[1].id].l=cnt;
    for(register int i=2;i<=n;++i)
    if(b[i].num==b[i-1].num)
    {
        a[b[i].id].l=cnt;
        b[i].f=cnt;
    }
    else
    {
        ++cnt;
        a[b[i].id].l=cnt;
        b[i].f=cnt;
    }
    build(1,1,cnt);
    ddd d;
    for(register int i=1;i<=n;++i)
    {
        d.r=a[i].r;d.id=a[i].id;
        L=a[i].l;
        add(1,d);
    }
}
 
inline ddd query(int k,int pos)
{
    if(L<=tree[k].l && tree[k].r<=R)
    {
        ddd d;d.id=0;d.r=pos;
        //it=lower_bound(tree[k].s.begin(),tree[k].s.end(),d);
        it=tree[k].s.lower_bound(d);//上面那个lower_bound是O(n)的= =，改了以后从60%到了80%TLE 
		if(it!=tree[k].s.end())
            d=(*it);
        return d;
    }
    int mid=(tree[k].l+tree[k].r)>>1;
    if(R<=mid)
        return query(k<<1,pos);
    else
    if(L>mid)
        return query(k<<1|1,pos);
    else
    {
        ddd d=query(k<<1,pos);
        if(d.id!=0)return d;
        return query(k<<1|1,pos);
    }
}
 
inline void des(int k,int l,ddd x)
{
    it=tree[k].s.find(x);
    tree[k].s.erase(it);
    if(tree[k].l==tree[k].r)
        return;
    int mid=(tree[k].l+tree[k].r)>>1;
    if(l<=mid)
        des(k<<1,l,x);
    else
        des(k<<1|1,l,x);
}
 
inline void mainwork()
{
    printf("Case #%d:\n",cas);
    int pos,x;b[0].f=0;
    for(register int i=1;i<=m;++i)
    {
        scanf("%d",&pos);
        pos=pos^res;
        nb d;d.num=pos;
        x=lower_bound(b+1,b+1+n,d)-b;
        if(b[x].num==pos)
            x=b[x].f;
        else
            x=b[x-1].f;
        if(x==0)
        {
            res=0;tot=0;
            printf("%d\n",tot);
            continue;
        }
        res=1;tot=0;
        ddd desd;
        while(1)
        {
            L=1;R=x;
            desd=query(1,pos);
            if(desd.id==0)
                break;
            tot++;res=(1ll*res*desd.id)%mod;
            ans[desd.id]=i;
            des(1,a[desd.id].l,desd);
        }
        printf("%d\n",tot);
        if(tot==0)
            res=0;
    }
}
 
inline void print()
{
    for(register int i=1;i<=n;++i)
        printf("%d%c",ans[i],i==n?'\n':' ');
}
 
int main()
{
    int t;
    scanf("%d",&t);
    for(cas=1;cas<=t;++cas)
    {
        prework();
        mainwork();
        print();
    }
    return 0;
}

 

二分抄代码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2018暑假牛客多校第六场
帅气廖鹏飞
08-05 332
A-Singing Contest J-Heritage of skywalkert A-Singing Contest 就是两个两个比较，然后用比对手大的最小的去与对手比就行了~ #include"bits/stdc++.h" #define out(x) cout&lt;&lt;#x&lt;&lt;"="&lt;&lt;x #define C(n,m) ((long lo...
牛客2018多校第六场 J Heritage of skywalkert - nth_element
weixin_30951743的博客
08-06 81
传送门 题意：提供一个随机生成函数，让你生成n个数，然后问你其中能找到的两个数的最小公倍数 最大 是多少。 思路：可以用nth_element()函数在O（n）下求出前 15 个大的数（当然，100个数也是可以的），暴力枚举这15个数两两求最小公倍数的结果。当然可以用小根堆优先队列，保证队列中有15个最大的数。 　　（雾，由于是随机数，互质的概率大。 // #include&...
2018 牛客多校第六场 I Team Rocket （线段树）
Oops的博客
08-10 289
https://www.nowcoder.com/acm/contest/144/I 题意： n个区间[l,r],m个操作：给数b，删去包含点b^res的区间，记录每个区间i第几次操作时被删去，每次操作删去的区间数。  res是上次删除的区间编号的乘积%998244353，如果上次未删区间，即res为0。 思路： 我们可以将线段按照l来排序，然后再来构造线段树，找到区间右端点的最大值，如果...
2018牛客多校第六场 I.Team Rocket
weixin_30657999的博客
08-05 102
题意： 　　给出n个区间和m个点（点按顺序给出且强制在线）。每个区间只会被第一个他包含的点摧毁。问每个点能摧毁多少个区间以及每个区间是被哪个点摧毁的。 题解： 　　将n个区间按照左端点排序，然后用vector（储存左端点，右端点，id）初始化线段树。 　　初始化的方法是：对于线段树的n个叶子节点，即为排好序的n个区间。对于其他节点，将左右儿子按照右端点大小归并（归并是线性复杂度）。 　　...
2018 牛客多校第六场 C Generation I （组合数）
Oops的博客
08-09 264
https://www.nowcoder.com/acm/contest/144/C   题意：给定n个集合， 要求用n次操作， 第i次操作用1~m中一个数填入 i ~ n个集合中， 集合无序而且元素不重复。   思路： 代码： #include&lt;bits/stdc++.h&gt; using namespace std; #define ll long long cons...
2018牛客暑期多校第二场题解
09-28
2018牛客暑期多校第二场题解
2020牛客暑期多校第一场讲课笔记版本题解1
08-03
6. 快速幂运算(Brute Force and Exponentiation): 题目中提到了用加法表示乘法，乘法表示指数运算，并预计算B_{i,j} = 2^{W*j} * v_i，然后利用快速幂优化计算，复杂度为O(nm/W + 2^W)，其中W通常取16，可以得到足够...
2020牛客暑期多校集训营第二场题解.pdf
01-20
2020牛客暑期多校集训营第二场题解.pdf
牛客暑假多校第六场 I Team Rocket
dengpangbu3703的博客
08-07 119
题意： 现在有n条火车， 每条火车都有一个运行 [ Li, Ri ]， 现在有m支火箭队， 每次火箭队都会破坏这整条铁路上的一个点， 如果一条火车的运行区间[Li, Ri] 被破坏了， 那么这条火车会立刻停止。 题解：线段树， 先将所有火车的左右端点排好序， 然后每一个叶子节点都是一个火车的区间， 每一颗子树的根节点都保存着子树内所有火车的运行区间的最左边的点 还有 最右边的点，然后x...
牛客多校第六场 Singing Contest
gtuif的博客
08-04 317
链接：https://www.nowcoder.com/acm/contest/144/A 来源：牛客网   时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 262144K，其他语言524288K 64bit IO Format: %lld 题目描述 Jigglypuff is holding a singing contest. There are 2n singers i...
牛客网暑期ACM多校训练营（第六场
qq_34921856的博客
08-06 217
F Squirtle 理解题意之后就十分好做了，唯一要注意的是会爆longlong，所以要用大数。 具体树dp见代码。 #include&lt;bits/stdc++.h&gt; using namespace std; typedef long long LL; struct BigInt { static const int BASE = 100000000; /...
2018牛客多校第六场 G.Pikachu
weixin_30624825的博客
08-07 88
题意： 　　给出一棵n个点的树，每条边有边权。对这个树加边变成一个完全图。新加的边的权值为边上两点在树上的距离。求完全图上任意两点的最大流之和。 题解： 　　一共有C(n，2)个点对。假设当前求s到t之间的最大流，也就是最小割。那么割完之后会是2个连通块，且连通块内部是完全图。 　　因为是最小割，所以被割掉的边权和最小。即两个连通块内部的边权和最大。那么就会有一个连通块是孤立点，取s和t中...
2018 牛客多校 6
weixin_30708329的博客
08-11 114
Problem A Problem B Problem C Problem D Problem E Problem F Problem G Problem H Problem I Problem J Problem K Problem L 转载于:https://www.cnblogs.com/cxhscst2/p/9458537.html
牛客网暑期ACM多校训练营（第六场) I题：Team Rocket （线段树）
污miao汪的博客
08-06 207
  题目大意： 一维坐标系上有n条线段，每条线段都有 l r 。每次破坏一个点x 所有包含这个点x 的线段都会被破坏。现在要求你针对每次询问输出每次有多少条线段被破坏，被破坏过的线段不能被破坏(强制在线)。 m次询问完后统一输出每条线段分别是在第多少次操作后被破坏的，没有被破坏的输出0。   解题思路： 比赛的时候想到了 一种思路，就是按照每条线段的左端点排序，然后针对右端点建立主席树...
2018牛客多校6 - I Team Rocket KD树维护空间
weixin_30687811的博客
08-05 86
题意:给出n条铁路区间\([L,R]\),共有m个boom依时间顺序放置在\(k_i\)中，区间与\(k_i\)有交集的都被炸掉 求每次炸掉的铁路个数和最后输出所有id被炸的时间点 炸弹能炸到的区间满足\(L≤K≤R\) 因为\(L\)与\(R\)无关,将其关系改写为\(X≤K≤Y\), 对应于二维空间,铁路区间相当于一个点\((L,R)\),每次询问有多少个没被屏蔽的点满足\(X≤K\)且\(K...
牛客多校第六场 J Heritage of skywalkert 简单题
lkaicheng的博客
08-04 134
  题意   ：每次运行上述的函数可获得一个数，让你从运行n次函数后得到的n个数中   求随便两个数的lcm  输出其中的最大值 思路：这个数看起来像是随便生成的  那么我们就取其中前100个最大的数 暴力求出最大lcm即可。   愚蠢的我不知道unsigned 如果超出范围不会变负数  无符号数超出位数的部分就不要   好吧 我第一次用 unsigned  根本不知道啥玩意。    前1...
牛客多校第6场J（Heritage of skywalkert）
pcfbyssz的博客
08-27 199
牛客多校第6场J（Heritage of skywalkert） 题意： 给出初始的A，B，C，按照题目中迭代n次求n个z，然后求这n个数中的两个数lcm的最大值。 思路： 随机两个正整数互质的概率为 6/π^2，概率很大，所以我们暴力取前20个数然后枚举lcm就。 可以用STL的nth_element，这个容器的作用是取前k大的数。 用法：nth_element(a,a+n-20,a...
2020牛客多校(第三场)
最新发布
10-02
这段代码是一个用于解决2020牛客多校（第三场）的问题的代码。它使用了C++语言，并且通过输入和输出字符数组来处理数据。代码中使用了一个变量pos来记录开始位置，左移操作是将开始位置设置为pos * x，右移操作是将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值