CCF CSP 202309-4 阴阳龙

ustc_cat

已于 2024-01-20 16:47:10 修改

阅读量1k

点赞数 19

文章标签： csp 算法 c语言数据结构

于 2024-01-18 16:48:44 首次发布

本文链接：https://blog.csdn.net/qq_40362020/article/details/135678256

版权

文章讲述了在一个棋盘地图上，如何通过创建有序映射集合来高效计算Dragon出现时每个工人到其最近位置的距离，避免遍历所有工人导致超时。通过判断Dragon到边界和工人位置的关系，仅更新相关映射集合，最后根据Dragon的新位置进行旋转操作。

摘要由CSDN通过智能技术生成

题目

试题编号	202309-4
试题名称	阴阳龙
时间限制	2s
内存限制	1GB
问题描述
输入输出
样例1
样例说明

题目分析

题目要注意的小细节很多：

每次Dragon出现的时候如果Dragon和边界的最小距离要小于等于Dragon到任何工人的位置距离。那么这次Dragon的出现忽略。
对一个 $n * m$ 的地图上的任何一个人，要找到每次Dragon出现下位置 $(x, y)$ 到最近的工人的距离。每次都遍历取找所有员工，那么会超时。正确的做法是把地图中的横，竖，斜线，反斜线存储成四个映射集合。
$ro w 中各个点的 y 值恒定。 co l 中各个点的 x 值恒定。 l u (斜线) 中 x - y 恒定。 u l (反斜线) 中 x + y 恒定$
所以对于每一个员工，都要建立一个映射存储，我用的是 $unordered\_map<int,set<point>>row,col,lu,ul$ point是结构体，存储员工的编号num，以及坐标x，y。
每次Dragon出现在 $(x, y)$ 的时候先判断下到边界的最小距离 $k_{mm}$ 。然后分别判断 $ro w [y], co l [x], l u [x - y], u l [x + y]$ ，找到和Dragon最近的工人距离 $k_{m}$ 。如果 $k_m<=k_{mm}$ 。就把Dragon的距离为 $k_{m}$ 的工人旋转。

AC代码

在这里插入图片描述
不知道为什么每次search的时候要判断下当前的row[y]的集合不为空…我已经在remove中删掉了为空的情况。但是不判断就会运行错误。

#include <bits/stdc++.h>
#define ll long long 
#define rep(i,a,n) for(int i=a;i<n;i++)
#define abs(a) ((a)>0?(a):(-(a)))
#define min(a,b) ((a)<(b)?(a):(b))
using namespace std;
struct point{
	int x;
	int y;
	int num;
	bool operator<(const point& b)const{
		if(x<b.x)return true;
		else if(x==b.x)return y<b.y;
		return false;
	}
	bool operator==(const point& b)const{
		return x==b.x&&y==b.y;
	}
	point(int _x,int _y):x(_x),y(_y){}
	point(){}
}u[100001];
point e;//dragon 
unordered_map<int,set<point>>row,col,lu,ul;
vector<point>result;
int n,m,p,g,t,x,y,k;
ll ans=0;
int k_m;
int dir[8][2]={{1,0},{1,1},{0,1},{-1,1},{-1,0},{-1,-1},{0,-1},{1,-1}};
int main(){
	cin>>n>>m>>p>>g;
	auto insert=[&](int i){
		int _x=u[i].x;
		int _y=u[i].y;
		row[_y].insert(u[i]);
		col[_x].insert(u[i]);
		lu[_x-_y].insert(u[i]);
		ul[_x+_y].insert(u[i]);		
	};
	auto remove=[&](int i){
		int _x=u[i].x;
		int _y=u[i].y;
		row[_y].erase(u[i]);
		col[_x].erase(u[i]);
		lu[_x-_y].erase(u[i]);
		ul[_x+_y].erase(u[i]); 	
		if(row[_y].empty())row.erase(_y);
		if(col[_x].empty())col.erase(_x);
		if(lu[_x-_y].empty())lu.erase(_x-_y);
		if(ul[_x+_y].empty())ul.erase(_x+_y);	
	};
	auto search=[&](){
		k_m = 0x7fffffff; 
		x=e.x;
		y=e.y;
		if(row.find(y)!=row.end()){
			auto upper=row[y].upper_bound(e);
			auto lower=row[y].lower_bound(e);
			if(upper==row[y].end()&&lower==row[y].end()&&row[y].size()!=0){
				k_m=min(k_m,abs(x-(row[y].rbegin())->x));
			}
			else{
				if(upper!=row[y].end()){
					k_m=min(k_m,upper->x-x);
				}
				if(lower!=row[y].end()&&lower!=row[y].begin()){
					lower--;
					k_m=min(k_m,x-lower->x);
				}				
			}
		}
		if(col.find(x)!=col.end()){
			auto upper=col[x].upper_bound(e);
			auto lower=col[x].lower_bound(e);
			if(upper==col[x].end()&&lower==col[x].end()&&col[x].size()!=0){
				k_m=min(k_m,abs(y-(col[x].rbegin())->y));
			}
			else{
				if(upper!=col[x].end()){
					k_m=min(k_m,upper->y-y);
				}
				if(lower!=col[x].end()&&lower!=col[x].begin()){
					lower--;
					k_m=min(k_m,y-lower->y);
				}				
			}
		}
		if(lu.find(x-y)!=lu.end()){
			auto upper=lu[x-y].upper_bound(e);
			auto lower=lu[x-y].lower_bound(e);
			if(upper==lu[x-y].end()&&lower==lu[x-y].end()&&lu[x-y].size()!=0){
				k_m=min(k_m,abs(x-(lu[x-y].rbegin())->x));
			}
			else{
				if(upper!=lu[x-y].end()){
					k_m=min(k_m,upper->x-x);
				}
				if(lower!=lu[x-y].end()&&lower!=lu[x-y].begin()){
					lower--;
					k_m=min(k_m,x-lower->x);
				}				
			}
		}
		if(ul.find(x+y)!=ul.end()){
			auto upper=ul[x+y].upper_bound(e);
			auto lower=ul[x+y].lower_bound(e);
			if(upper==ul[x+y].end()&&lower==ul[x+y].end()&&ul[x+y].size()!=0){
				k_m=min(k_m,abs(x-(ul[x+y].rbegin())->x));
			}
			else{
				if(upper!=ul[x+y].end()){
					k_m=min(k_m,upper->x-x);
				}
				if(lower!=ul[x+y].end()&&lower!=ul[x+y].begin()){
					lower--;
					k_m=min(k_m,x-lower->x);
				}				
			}
		}
	};
	auto rotate=[&](){
		result.clear();
		rep(i,0,8){
			int _x=x+dir[i][0]*k_m;
			int _y=y+dir[i][1]*k_m;
			if(row[_y].find(point(_x,_y))!=row[_y].end()){
				int index=(row[_y].find(point(_x,_y)))->num;
				remove(index);
				result.push_back(point(index,i));
			}
		}		
	};
	rep(i,1,p+1){
		cin>>u[i].x>>u[i].y;
		u[i].num=i;
		insert(i);
	}
	while(g--){
		cin>>e.x>>e.y>>t;
		int k_mm=min(e.x-1,min(n-e.x,min(e.y-1,m-e.y)));	
		search();
		if(k_mm<k_m)continue;
		rotate();
		for(auto _t:result){
			int to_direct=(_t.y+t)%8;
			u[_t.x].x=e.x+dir[to_direct][0]*k_m;
			u[_t.x].y=e.y+dir[to_direct][1]*k_m;
			insert(_t.x);
		}
	}
	rep(i,1,p+1)ans^=(1ll*i*u[i].x+u[i].y);
	cout<<ans;
	return 0;
}
/*
3 3 9 1
1 1
1 2
1 3
2 1
2 2
2 3
3 1
3 2
3 3
2 2 1

7 7 7 5
4 4
4 6
3 6
2 6
6 2
2 4
7 4
4 4 1
2 2 7
4 4 7
3 4 5
5 5 3

7 7 7 4
4 4
4 6
3 6
2 6
6 2
2 4
7 4
4 4 1
2 2 7
4 4 7
3 4 5


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

*/