2304: [Apio2011]寻路

最新推荐文章于 2018-04-15 17:04:00 发布
最新推荐文章于 2018-04-15 17:04:00 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： SPFA 离散化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CRZbulabula/article/details/52563525
版权

2304: [Apio2011]寻路

Time Limit: 20 Sec   Memory Limit: 256 MB
Submit: 512   Solved: 162
[ Submit][ Status][ Discuss]

Description

TooDee是一块二维格子状的土地（就像著名的笛卡尔坐标系那样） ，在这里
生活着很多可爱的Dee。Dee是像蜜蜂一样的小动物，它们只在二维活动，而且
它们非常的文明开化。TooDee 的蜂窝和正常世界的蜂窝也是很不一样的，它们
是矩形的且它们的边平行于TooDee的地理坐标系，就是说矩形的边或者是东西
走向，或者是南北走向。 
因为 Dees 是很高级的生物，它们有很多固定的飞行轨道，这些轨道由一些
平行于坐标轴的线段组成，线段只会在经纬度都是整数的点相交。 Dee在TooDee
飞行时必须遵守以下规则（请记住TooDee中所有点的经纬度都是整数）： 
1  如果当前在点(XS, YS)， 则下步只能飞到四个邻点  (XS, YS – 1), (XS, YS + 1),   
(XS – 1, YS ), (XS + 1, YS )； 
2  不可以进入蜂巢； 
3  只能在蜂巢的角或者边上改变飞行方向； 
4  开始的时候可以向任何方向飞； 
今晚是公共财政大臣Deeficer的女儿的生日，她想尽早回家，请帮她找到最
快的回家路径。假设她每秒可以飞行一个单位的距离。

Input

每个测试点包含多组数据。 
输入的第一行包含一个整数T，表示测试数据的组数。接下来依次描述这T
组数据，相邻的两组之间使用一个空行分隔。测试数据不多于20组。 
对于每组数据，第一行包含4个整数 xs, ys, xt, yt，表示Deeficer 的办公室和
家的坐标分别为(xs, ys)和(xt, yt)。第二行包含一个整数n，表示蜂巢的个数。接下
来的n行描述所有的蜂巢，其中第 i行包含 4 个整数xi1,  yi1,  xi2,  yi2，表示第i个
蜂巢两个对角的坐标分别为(xi1, yi1)和(xi2, yi2)。 
任何两个蜂巢都不会相交，也不会接触（在角上也不会接触）。办公室和家
处在不同的位置。每个蜂巢的面积为正。

Output

对于每一组数据，输出一个整数，表示Deeficer 最快回家的时间（单位为秒），
如果她无法按规则回家，则输出“No Path”。

对于100%的测试数据，1 ≤ n ≤ 1000，所有坐标都是不超过10^9
的整数；

Sample Input

2

1 7 7 8
2
2 5 3 8
4 10 6 7

2 1 5 4
1
3 1 4 3

Sample Output

9
No Path

HINT

数据为国际加国内综合版

Source

[ Submit][ Status][ Discuss]

第一感觉就是最短路
好一点的搜索方案是把所有矩形的坐标离散化，这样全图剩下O(n^2)个点
本来以为这样可以过，，但是只能过60%的数据，，GG
n^2的点即使每个点只有四条边，也是不行啊。。。

好不容易找到正解，，
就是这样一张图。。对于从一个矩形起飞，最多造出12个有效点
这样点数瞬间降到O(n)级别，SPFA就能过啦


不过这时候找这些点就非常麻烦。。。
苟蒻的做法是想扫描线一样，一行一行/一列一列搞，在线段树中查询前驱or后缀之类
把需要新建的点扔到坐标系，和前驱and后缀连边
新建完点之后要注意哪些方向不能连
以及边角点和起始点要特判它一定是能走向四方。。 
#include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
#include<bitset>
#include<algorithm>
#include<cstring>
#include<map>
#include<stack>
#include<set>
#include<cmath>
#include<ext/pb_ds/priority_queue.hpp>
using namespace std;

const int maxn = 2010;
const int dx[4] = {0,1,0,-1};
const int dy[4] = {1,0,-1,0};
typedef long long LL;
const LL INF = 1E15;
const int inf = 2139062143;
const int T = 8;

struct Event{
	int key,pos,typ;
	Event(){}
	Event(int key,int pos,int typ): key(key),pos(pos),typ(typ){}
	bool operator < (const Event &B) const{
		if (key < B.key) return 1;
		if (key > B.key) return 0;
		if (typ < B.typ) return 1;
		return 0;
	}
}E[maxn*T];

struct Point{
	int key,Num;
	Point(){}
	Point(int key,int Num): key(key),Num(Num){}
	bool operator < (const Point &B) const {return key < B.key;}
};

struct Edg{
	int to,w;
	Edg(){}
	Edg(int to,int w): to(to),w(w){}
};

int n,Ti,sx,sy,tx,ty,cx,cy,tox,toy,tot,ax[maxn],Mark[maxn][maxn]
	,cnt,Cnt,Begin,End,px1[maxn],py1[maxn],px2[maxn],py2[maxn],ay[maxn]
	,Left[maxn*T],Right[maxn*T],num[maxn][maxn],unable[maxn*20];
LL dis[maxn*20];
bool vis[maxn*20];

vector <Point> px[maxn];
vector <Point> py[maxn];
vector <Edg> v[maxn*20];
queue <int> Q;

int getint()
{
	char ch = getchar();
	int ret = 0,tmp = 1;
	while (ch < '0' || '9' < ch) {
		if (ch == '-') tmp = -1;
		ch = getchar();
	}
	while ('0' <= ch && ch <= '9')
		ret = ret*10 + ch - '0',ch = getchar();
	return ret*tmp;
}

void Work()
{
	cx = cy = 1;
	sort(ax + 1,ax + tox + 1);
	for (int i = 2; i <= tox; i++)
		if (ax[i] != ax[i-1])
			ax[++cx] = ax[i];
	sort(ay + 1,ay + toy + 1);
	for (int i = 2; i <= toy; i++)
		if (ay[i] != ay[i-1])
			ay[++cy] = ay[i];
	for (int i = 1; i <= n; i++) {
		px1[i] = lower_bound(ax + 1,ax + cx + 1,px1[i]) - ax;
		py1[i] = lower_bound(ay + 1,ay + cy + 1,py1[i]) - ay;
		px2[i] = lower_bound(ax + 1,ax + cx + 1,px2[i]) - ax;
		py2[i] = lower_bound(ay + 1,ay + cy + 1,py2[i]) - ay;
	}
	sx = lower_bound(ax + 1,ax + cx + 1,sx) - ax;
	sy = lower_bound(ay + 1,ay + cy + 1,sy) - ay;
	tx = lower_bound(ax + 1,ax + cx + 1,tx) - ax;
	ty = lower_bound(ay + 1,ay + cy + 1,ty) - ay;
}

void Add(int x,int y) {ax[++tox] = x; ay[++toy] = y;}
void Read()
{
	sx = getint();
	sy = getint();
	tx = getint();
	ty = getint();
	tox = toy = 0;
	Add(sx,sy);
	Add(tx,ty);
	n = getint();
	for (int i = 1; i <= n; i++) {
		px1[i] = getint();
		py1[i] = getint();
		px2[i] = getint();
		py2[i] = getint();
		if (px1[i] > px2[i]) swap(px1[i],px2[i]);
		if (py1[i] > py2[i]) swap(py1[i],py2[i]);
		Add(px1[i],py1[i]);
		Add(px2[i],py2[i]);
	}
}

void SPFA()
{
	for (int i = 1; i <= cnt; i++)
		dis[i] = INF,vis[i] = 0;
	Q.push(Begin);
	dis[Begin] = 0;
	vis[Begin] = 1;
	while (!Q.empty()) {
		int k = Q.front(); 
		vis[k] = 0; Q.pop();
		for (int i = 0; i < v[k].size(); i++) {
			int to = v[k][i].to;
			LL w = v[k][i].w;
			if (dis[to] > dis[k] + w) {
				dis[to] = dis[k] + w;
				if (vis[to]) continue;
				vis[to] = 1;
				Q.push(to);
			}
		}
	}
	if (dis[End] == INF) puts("No Path");
	else printf("%lld\n",dis[End]);
	for (int i = 1; i <= cnt; i++) v[i].clear();
}

int New(int x,int y,int WA)
{
	if (Mark[x][y] == Cnt) {
		if (WA == -1)
			unable[num[x][y]] = WA;
		return -1;
	}
	Mark[x][y] = Cnt;
	++cnt;
	px[x].push_back(Point(ay[y],cnt));
	py[y].push_back(Point(ax[x],cnt));
	unable[cnt] = WA;
	num[x][y] = cnt;
	return cnt;
}

void Add_Edgs()
{
	for (int i = 1; i <= cx; i++) {
		if (!px[i].size()) continue;
		sort(px[i].begin(),px[i].end());
		for (int j = 1; j < px[i].size(); j++) {
			int A = px[i][j-1].Num,B = px[i][j].Num;
			int w = px[i][j].key - px[i][j-1].key;
			if (unable[A] != 0) v[A].push_back(Edg(B,w));
			if (unable[B] != 2) v[B].push_back(Edg(A,w));
		}
		px[i].clear();
	}
	for (int i = 1; i <= cy; i++) {
		if (!py[i].size()) continue;
		sort(py[i].begin(),py[i].end());
		for (int j = 1; j < py[i].size(); j++) {
			int A = py[i][j-1].Num,B = py[i][j].Num;
			int w = py[i][j].key - py[i][j-1].key;
			if (unable[A] != 1) v[A].push_back(Edg(B,w));
			if (unable[B] != 3) v[B].push_back(Edg(A,w));
		}
		py[i].clear();
	}
}

void Modify(int o,int l,int r,int pos,int typ)
{
	if (l == r) {
		if (typ == 1) Left[o] = Right[o] = l;
		else Left[o] = inf,Right[o] = 0;
		return;
	}
	int mid = (l + r) >> 1;
	if (pos <= mid) Modify(o<<1,l,mid,pos,typ);
	else Modify(o<<1|1,mid + 1,r,pos,typ);
	Left[o] = min(Left[o<<1],Left[o<<1|1]);
	Right[o] = max(Right[o<<1],Right[o<<1|1]);
}

int Lower(int o,int l,int r,int ql,int qr)
{
	if (ql > qr) return inf;
	if (ql <= l && r <= qr) return Left[o];
	int mid = (l + r) >> 1,ret = inf;
	if (ql <= mid) ret = Lower(o<<1,l,mid,ql,qr);
	if (ret < inf) return ret;
	if (qr > mid) ret = Lower(o<<1|1,mid+1,r,ql,qr);
	return ret;
}

int Upper(int o,int l,int r,int ql,int qr)
{
	if (ql > qr) return 0;
	if (ql <= l && r <= qr) return Right[o];
	int mid = (l + r) >> 1,ret = 0;
	if (qr > mid) ret = Upper(o<<1|1,mid+1,r,ql,qr);
	if (ret) return ret;
	if (ql <= mid) ret = Upper(o<<1,l,mid,ql,qr);
	return ret;
}

void Pre_Clear()
{
	sort(E + 1,E + tot + 1);
	memset(Left,127,sizeof(Left));
	memset(Right,0,sizeof(Right));
}

void Build()
{
	cnt = tot = 0; ++Cnt;
	Begin = New(sx,sy,-1); 
	End = New(tx,ty,-1); 
	for (int i = 1; i <= n; i++) {
		E[++tot] = Event(py1[i],px1[i],1);
		E[++tot] = Event(py2[i] + 1,px1[i],2);
		E[++tot] = Event(py1[i],px1[i],5);
		E[++tot] = Event(py2[i],px1[i],3);
		E[++tot] = Event(py1[i],px2[i],1);
		E[++tot] = Event(py2[i] + 1,px2[i],2);
		E[++tot] = Event(py1[i],px2[i],6);
		E[++tot] = Event(py2[i],px2[i],4);
	}
	E[++tot] = Event(sy,sx,3);
	E[++tot] = Event(sy,sx,6);
	E[++tot] = Event(ty,tx,3);
	E[++tot] = Event(ty,tx,6);
	Pre_Clear();
	for (int i = 1; i <= tot; i++) {
		if (E[i].typ == 1) Modify(1,1,cx,E[i].pos,1);
		else if (E[i].typ == 2) Modify(1,1,cx,E[i].pos,-1);
		else if (E[i].typ == 3 || E[i].typ == 5) {
			New(E[i].pos,E[i].key,-1);
			int po = Upper(1,1,cx,1,E[i].pos - 1);
			if (po) New(po,E[i].key,3);
		}
		else {
			New(E[i].pos,E[i].key,-1);
			int po = Lower(1,1,cx,E[i].pos + 1,cx);
			if (po < inf) New(po,E[i].key,1);
		}
	}
	
	tot = 0;
	for (int i = 1; i <= n; i++) {
		E[++tot] = Event(px1[i],py1[i],1);
		E[++tot] = Event(px2[i] + 1,py1[i],2);
		E[++tot] = Event(px1[i],py1[i],5);
		E[++tot] = Event(px2[i],py1[i],6);
		E[++tot] = Event(px1[i],py2[i],1);
		E[++tot] = Event(px2[i] + 1,py2[i],2);
		E[++tot] = Event(px1[i],py2[i],3);
		E[++tot] = Event(px2[i],py2[i],4);
	}
	E[++tot] = Event(sx,sy,3);
	E[++tot] = Event(sx,sy,6);
	E[++tot] = Event(tx,ty,3);
	E[++tot] = Event(tx,ty,6);
	Pre_Clear();
	for (int i = 1; i <= tot; i++) {
		if (E[i].typ == 1) Modify(1,1,cy,E[i].pos,1);
		else if (E[i].typ == 2) Modify(1,1,cy,E[i].pos,-1);
		else if (E[i].typ == 5 || E[i].typ == 6) {
			New(E[i].key,E[i].pos,-1);
			int po = Upper(1,1,cy,1,E[i].pos - 1);
			if (po) New(E[i].key,po,2);
		}
		else {
			New(E[i].key,E[i].pos,-1);
			int po = Lower(1,1,cy,E[i].pos + 1,cy);
			if (po < inf) New(E[i].key,po,0);
		}
	}
	Add_Edgs();
}

int main()
{
	#ifdef DMC
		freopen("DMC.txt","r",stdin);
	#endif
	
	cin >> Ti;
	while (Ti--) {
		Read();
		Work();
		Build();
		SPFA();
	}
	return 0;
}

CRZbulabula
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BZOJ 2304: [Apio2011]寻路
月下沙茶树
04-25 882
好久不写题解了不劲啊 最近被多校虐哭了 无聊来水一水APIO的题 感觉APIO的题黑科技不是很多啊 这题大概不是lower_bound和upper_bound的应用？ 反正用这两个函数就可以找到每个点四个方向可以到的点了，然后把新找到的这个点加到它所在的矩形的那个线段上去，最后对于每条线段处理一下上面的点 跑跑spfa就过了 #include #include #include #i
[BZOJ2304][Apio2011]寻路（模拟+spfa）
zyf2000
04-28 1208
题目描述传送门题目大意：在二维平面上有起点和终点，若干不相交、边界平行或竖直的矩形。不能进入矩形内部，只能在矩形的边界上改变方向，求起点到终点的最短距离或者No Path。题解这题和之前写过的冰原探险那道题挺像的，都是将这种图连边然后跑最短路 因为最优情况下只会在矩形的顶点处改变方向，所以可以先将坐标离散化，然后对于矩形的每一个顶点向第一个能到达的地方连边 这样的话除了矩形的顶点图上还会多出来一
bzoj 2304: [Apio2011]寻路 （最短路+建图）
clover_hxy的博客
04-28 693
题目描述传送门题解对于矩形的每个顶点找到能到达的其他矩形边界上的点，然后将所有有用的点找出来。 先按照纵坐标排序，然后将纵坐标相同的点中相邻的点连边，注意在边界上的点需要特判，因为不能进入矩形。 然后按照横坐标排序，处理方式与纵坐标相同。 注意需要特判一下起点与终点的位置，因为有可能在矩形的边界上。 连完边，跑最短路即可。代码#include<iostream> #include<cstri
[BZOJ 2304][Apio2011]寻路：SPFA
SmallSXJ的博客
05-04 454
点击这里查看原题首先可以想到这题求最短路，那肯定是SPFA（没有负权边，Dijkstra当然也可以啦），难点在于如何构图。 将坐标离散化，然后将矩形的边和顶点分别做不同的标记。从每个矩形的四个顶点出发，将到达的第一个有标记的点（也就是其他矩形上的点）标记为mark[i][j]=1。 将所有mark[i][j]=1或是矩形的四个顶点的点加入，在同一行或同一列的点之间连边，然后做SPFA即可。 因
[APIO2011]
weixin_30349597的博客
03-31 112
来自FallDream的博客，未经允许，请勿转载，谢谢。 ------------------------------------------------------ A.[Apio2011]方格染色 Sam和他的妹妹Sara有一个包含n × m个方格的表格。她们想要将其的每个方格都染成红色或蓝色。出于个人喜好，他们想要表格中每个2 × 2的方形区域都包含奇数个（1 个或 3 个）红色方...
apio：用于开放FPGA板的开源生态系统
01-30
用于开放FPGA板的开源生态系统Apio（发音为[ˈa.pjo]）是一个多平台工具箱，具有静态的预构建软件包，项目配置工具和简单的命令界面，可用于验证，综合，模拟和上传Verilog设计。 Icestudio使用 。目录安装安装和 ...
APIO2008.pdf
07-21
"APIO2008.pdf" 本文档是亚洲信息学奥林匹克竞赛（APIO）2008年的竞赛题目，包含三个问题，分别是珠链交换器、换器交和DNA。本文档详细介绍了每个问题的描述、输入格式、输出格式、时间限制和空间限制等信息。 ...
APIO2021.zip
10-18
【APIO2021.zip】是一个压缩包文件，包含了APIO2021年度的课程资料。APIO，全称亚洲与太平洋地区信息学奥林匹克（Asian Pacific Informatics Olympiad），是一项面向中学生的国际信息学竞赛，旨在培养和提升学生的...
APIO2016课件
04-15
APIO2016课件，包含有位运算最小生成树以及组合数取模
APIO2018资料
06-30
【APIO2018资料】是一份包含2018年亚洲太平洋地区信息学奥林匹克竞赛（APIO）相关资源的压缩包文件。这个压缩包里涵盖了多种类型的文档，包括题面、课件以及讲解材料，对于学习和理解APIO2018的题目和解题策略具有...
易语言A星寻路算法
11-01
易语言A星寻路算法
bzoj 2304 [Apio 2011 path] 分类： bzoj...
aa288288的博客
05-01 120
喜闻乐见的最短路。 关于如何求最短路，dijstra+heap 关于如何构图，详见《APIO2011寻路解题报告》 代码很长，勿喷。。。 感觉map不靠谱，手写点离散化。 然后居然冲进第一版了。。。 vfk似乎说过这道题代码超过6k的都是弱菜，所以我是大蒟蒻。 #include<map> #include<stack&g...
bzoj 2304: [Apio2011]寻路【spfa】
weixin_30776863的博客
04-15 97
我是智障*3，读优写错了调了半天没发现= = 虽然是个最短路却有网络流一般的神建图啊。 首先发现在拐角处转弯是最优的，于是先离散化，然后矩形的四个顶点向距离它最近的上下左右点连边，跑spfa即可。 就是难写啊，还要判断无解：st在矩形里；dis[t]=inf #include<iostream> #include<cstdio> #include<queue> ...
【BZOJ2303】【Apio2011】方格染色 异或方程+并查集
辗转山河弋流歌
04-16 3324
题解： 首先我们发现对于 ai,ja_{i,j} 有下列式子： ai,j xor ai+1,j xor ai,j+1 xor ai+1,j+1==1a_{i,j} ~xor\ a_{i+1,j} ~xor\ a_{i,j+1} ~xor\ a_{i+1,j+1} == 1 然后推导得到对于 ai,ja_{i,j} 有下列式子： a1,1 xor a1,j xor ai,1 xor
寻路算法：找到NPC最好的行走路径
博文视点（北京）官方博客
11-29 3806
引言：寻路就是一个看似简单问题的解：给定点A 和B，AI 该怎么智能地在游戏世界中行走？这个问题的复杂来自于实际上A 和B 之间存在大量的路径可走，但只有一条是最佳的。只是找到一条两点之间的有效路径是不够的。理想的寻路算法需要查找所有可能的情况，然后比较出最好的路径。 本文将从搜索空间，可接受的启发式算法、贪婪最佳优先算法进行探讨。搜索空间的表示最简单的寻路算法设计就是将图作为数据结构。一个图包...
游戏里的跨地图寻路算法
07-11 576
前段时间遇到一个跨地图寻路的需求，需要在任意两个地图之间自动寻路。我们的寻路算法用的是AStar,每个地图都有一份格子数据，地图之间有传送门通过。 首先这是一个最短路径问题，常用的最短路径算法有Dijkstra、Floyd。这里我的思路是选择Dijkstra来实现。 具体的Dijkstar算法原理可以参考这两篇文章：（反正我是学完就忘记了 笑哭~） 透彻理解迪杰斯特拉算法 最短路径—D...
一种非常简单有效的基于格子的寻路算法
热门推荐
__xzwdev__
11-03 1万+
这种算法可能比A*要好啊,
bzoj2303 [apio2011 color] 分类： apio ...
aa288288的博客
05-05 126
ppfish的题解 由题意，Ai,j^Ai−1,j ^ Ai,j−1^ Ai−1,j−1=1 只有当i, j全部为偶数时候， Ai,j^ Ai,1^ A1,j ^A1,1=1 其他情况， Ai,j^ Ai,1^ A1,j ^ A1,1=0 所以，只要确定了第一行和第一列，整个矩阵就确定了。 #include<cstdio> #inc...
树形地图的A*寻路算法
阿斌(Ben)的博客
02-20 2993
普通的A*寻路可以在网格化的地图中寻路，但是我们想一想另一种情况，魔兽世界的大地图的飞行点路径选择，我们选择了终点，游戏就自动帮我们找到了最佳的飞行路径，这种寻路方式与网格化地图的寻路很大不同，我们可以把魔兽世界的飞行点系统抽象成一种没有根节点的树，每一个飞行点就是这个树中的一个节点，每个节点有一个列表，保存了与该节点连接的其他节点，同时保存到其他连接的节点的G值，H值为该节点到终点的直线距离，那

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值