【BZOJ1018】[SHOI2008]堵塞的交通traffic 线段树

【BZOJ1018】[SHOI2008]堵塞的交通traffic

Description

  有一天,由于某种穿越现象作用,你来到了传说中的小人国。小人国的布局非常奇特,整个国家的交通系统可以被看成是一个2行C列的矩形网格,网格上的每个点代表一个城市,相邻的城市之间有一条道路,所以总共有2C个城市和3C-2条道路。 小人国的交通状况非常槽糕。有的时候由于交通堵塞,两座城市之间的道路会变得不连通,直到拥堵解决,道路才会恢复畅通。初来咋到的你决心毛遂自荐到交通部某份差事,部长听说你来自一个科技高度发达的世界,喜出望外地要求你编写一个查询应答系统,以挽救已经病入膏肓的小人国交通系统。 小人国的交通部将提供一些交通信息给你,你的任务是根据当前的交通情况回答查询的问题。交通信息可以分为以下几种格式:Close r1 c1 r2 c2:相邻的两座城市(r1,c1)和(r2,c2)之间的道路被堵塞了;Open r1 c1 r2 c2:相邻的两座城市(r1,c1)和(r2,c2)之间的道路被疏通了;Ask r1 c1 r2 c2:询问城市(r1,c1)和(r2,c2)是否连通。如果存在一条路径使得这两条城市连通,则返回Y,否则返回N;

Input

  第一行只有一个整数C,表示网格的列数。接下来若干行,每行为一条交通信息,以单独的一行“Exit”作为结束。我们假设在一开始所有的道路都是堵塞的。我们保证 C小于等于100000,信息条数小于等于100000。

Output

  对于每个查询,输出一个“Y”或“N”。

Sample Input

2
Open 1 1 1 2
Open 1 2 2 2
Ask 1 1 2 2
Ask 2 1 2 2
Exit

Sample Output

Y
N

题解:先不考虑从两边走的情况,直接上线段树的区间合并即可。用f[0/1][0/1]表示从左上/左下能否走到右上/右下。

那么如果考虑从两边绕的情况呢?一定是贪心的选取第一个能拐的点就直接拐,所以在线段树上找到第一个拐点然后判断中间是否全部连通即可。

#include <cstdio>
#include <cstring>
#include <iostream>
#define lson x<<1
#define rson x<<1|1
using namespace std;
const int maxn=100010;
int n,pre,nxt;
struct node
{
	bool f[2][2],g[3],lp;
	node () {memset(f,0,sizeof(f)),memset(g,0,sizeof(g)),lp=0;}
}s[maxn<<2];
node mix(node a,node b)
{
	node c;
	c.f[0][0]=(a.f[0][0]&b.f[0][0])|(a.f[0][1]&b.f[1][0])|(a.f[0][0]&b.f[1][0]&b.lp)|(a.f[0][1]&b.f[0][0]&b.lp);
	c.f[0][1]=(a.f[0][0]&b.f[0][1])|(a.f[0][1]&b.f[1][1])|(a.f[0][0]&b.f[1][1]&b.lp)|(a.f[0][1]&b.f[0][1]&b.lp);
	c.f[1][0]=(a.f[1][0]&b.f[0][0])|(a.f[1][1]&b.f[1][0])|(a.f[1][0]&b.f[1][0]&b.lp)|(a.f[1][1]&b.f[0][0]&b.lp);
	c.f[1][1]=(a.f[1][0]&b.f[0][1])|(a.f[1][1]&b.f[1][1])|(a.f[1][0]&b.f[1][1]&b.lp)|(a.f[1][1]&b.f[0][1]&b.lp);
	c.g[0]=a.g[0]&b.g[0],c.g[1]=a.g[1]&b.g[1],c.g[2]=a.g[2]|b.g[2],c.lp=a.lp;
	return c;
}
char str[20];
inline int rd()
{
	int ret=0,f=1;	char gc=getchar();
	while(gc<'0'||gc>'9')	{if(gc=='-')f=-f;	gc=getchar();}
	while(gc>='0'&&gc<='9')	ret=ret*10+gc-'0',gc=getchar();
	return ret*f;
}
void updata(int l,int r,int x,int a,int b,int c)
{
	if(l==r)
	{
		s[x].g[b]=c,s[x].f[0][0]=s[x].g[0],s[x].f[1][1]=s[x].g[1],s[x].lp=s[x].g[2];
		s[x].f[0][1]=s[x].g[2]&s[x].f[1][1],s[x].f[1][0]=s[x].g[2]&s[x].f[0][0];
		return ;
	}
	int mid=(l+r)>>1;
	if(a<=mid)	updata(l,mid,lson,a,b,c);
	else	updata(mid+1,r,rson,a,b,c);
	s[x]=mix(s[lson],s[rson]);
}
void getpre(int l,int r,int x,int a)
{
	if(l>a||pre>=r||!s[x].g[2])	return ;
	if(l==r)
	{
		pre=l;
		return ;
	}
	int mid=(l+r)>>1;
	getpre(mid+1,r,rson,a),getpre(l,mid,lson,a);
}
void getnxt(int l,int r,int x,int a)
{
	if(r<a||nxt<=l||!s[x].g[2])	return ;
	if(l==r)
	{
		nxt=l;
		return ;
	}
	int mid=(l+r)>>1;
	getnxt(l,mid,lson,a),getnxt(mid+1,r,rson,a);
}
node query(int l,int r,int x,int a,int b)
{
	if(a>b)
	{
		node tmp;
		tmp.f[0][0]=tmp.f[1][1]=tmp.g[0]=tmp.g[1]=1;
		return tmp;
	}
	if(a<=l&&r<=b)	return s[x];
	int mid=(l+r)>>1;
	if(b<=mid)	return query(l,mid,lson,a,b);
	if(a>mid)	return query(mid+1,r,rson,a,b);
	return mix(query(l,mid,lson,a,b),query(mid+1,r,rson,a,b));
}
int main()
{
	n=rd();
	int a1,b1,a2,b2;
	while(1)
	{
		scanf("%s",str);
		if(str[0]=='E')	return 0;
		a1=rd()-1,b1=rd(),a2=rd()-1,b2=rd();
		if(b1>b2||(b1==b2&&a1>a2))	swap(a1,a2),swap(b1,b2);
		if(str[0]=='C')
		{
			if(b1==b2)	updata(1,n,1,b1,2,0);
			else	updata(1,n,1,b1,a1,0);
		}
		if(str[0]=='O')
		{
			if(b1==b2)	updata(1,n,1,b1,2,1);
			else	updata(1,n,1,b1,a1,1);
		}
		if(str[0]=='A')
		{
			node tmp;
			tmp=query(1,n,1,b1,b2-1);
			if(tmp.f[a1][a2])	printf("Y\n");
			else
			{
				pre=0,getpre(1,n,1,b1);
				nxt=n+1,getnxt(1,n,1,b2);
				node t1,t2;
				if(pre)	t1=query(1,n,1,pre,b1-1);
				if(nxt!=n+1)	t2=query(1,n,1,b2,nxt-1);
				if(t1.g[0]&t1.g[1]&tmp.f[a1^1][a2])	printf("Y\n");
				else	if(t2.g[0]&t2.g[1]&tmp.f[a1][a2^1])	printf("Y\n");
				else	if(t1.g[0]&t1.g[1]&t2.g[0]&t2.g[1]&tmp.f[a1^1][a2^1])	printf("Y\n");
				else	printf("N\n");
			}
		}
	}
}//4 Open 1 1 1 2 Open 1 1 2 1 Open 2 1 2 2 Open 2 2 2 3 Open 2 3 2 4 Open 1 4 2 4 Open 1 3 1 4 Ask 1 2 1 3

转载于:https://www.cnblogs.com/CQzhangyu/p/7425137.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SQLAlchemy 是一个 SQL 工具包和对象关系映射(ORM)库,用于 Python 编程语言。它提供了一个高级的 SQL 工具和对象关系映射工具,允许开发者以 Python 类和对象的形式操作数据库,而无需编写大量的 SQL 语句。SQLAlchemy 建立在 DBAPI 之上,支持多种数据库后端,如 SQLite, MySQL, PostgreSQL 等。 SQLAlchemy 的核心功能: 对象关系映射(ORM): SQLAlchemy 允许开发者使用 Python 类来表示数据库表,使用类的实例表示表中的行。 开发者可以定义类之间的关系(如一对多、多对多),SQLAlchemy 会自动处理这些关系在数据库中的映射。 通过 ORM,开发者可以像操作 Python 对象一样操作数据库,这大大简化了数据库操作的复杂性。 表达式语言: SQLAlchemy 提供了一个丰富的 SQL 表达式语言,允许开发者以 Python 表达式的方式编写复杂的 SQL 查询。 表达式语言提供了对 SQL 语句的灵活控制,同时保持了代码的可读性和可维护性。 数据库引擎和连接池: SQLAlchemy 支持多种数据库后端,并且为每种后端提供了对应的数据库引擎。 它还提供了连接池管理功能,以优化数据库连接的创建、使用和释放。 会话管理: SQLAlchemy 使用会话(Session)来管理对象的持久化状态。 会话提供了一个工作单元(unit of work)和身份映射(identity map)的概念,使得对象的状态管理和查询更加高效。 事件系统: SQLAlchemy 提供了一个事件系统,允许开发者在 ORM 的各个生命周期阶段插入自定义的钩子函数。 这使得开发者可以在对象加载、修改、删除等操作时执行额外的逻辑。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值