#bzoi3038#关灯（模拟）

3038: 关灯

时间限制: 1 Sec  内存限制: 128 MB

题目描述

谷仓是一个简单的多边形。它的每一条边或平行于x轴，或平行于y轴。从任意一个点沿顺时针方向走，横边和纵边是交替出现的。多边形一共有n个点，编号为1到n。其中1号点为出口。奶牛贝西已经完全记住了谷仓的地图。它从某一个点出发，只能沿着边界走，在开灯的情况，它能很快知道怎么走才能更快到达出口。可是有一天，灯熄灭了。它一下慌了神，然后它忘了自己在哪个点了。但是幸运的是它仍然记得整个谷仓的地图，而且它能够凭触觉知道当前点的内角有多大，它也能感觉到当前点是不是出口，而且经过一条边后也能精确地计算出该边的长度。现在，为了寻找出口，它决定采取这样的策略：沿着顺时针方向继续走下去，直到它能够判断出自己的位置，然后再选择距离最短的方向（顺时针或逆时针）走到出口。求最坏的情况下，贝西走到出口要比灯没坏的情况下多花多少时间。

输入

第一行包含N（4<=N<=200）,接下来N行每行包含两个整数，表示多边形的n个顶点（xi,yi），按顺时针的方向给出。这些点的范围均在[-100000,100000]

输出

输出贝西按照上述策略在最坏情况下比正常情况下要多花的时间。

样例输入

4
0 0
0 10
1 10
1 0

样例输出

2

提示

贝西如果在出口处，肯定可以感知到，这绝对不会是最坏情况。现在考虑它在其他3个点时的情形：它当前可以感知到内角的大小。但因为内角都是90度，所以他无法确定自己位置。于是它按照既定的策略，顺时针走：

1. 如果它在开始在点2，它需要走到点3，此时，它知道自己在哪里了。于是它找最短的路径，不管哪边，都是11.所以，它一共需要走12个单位。如果是开灯的情况下，只需要走10个单位。所以，它要多走两个单位。

2. 如果它在点3，它要走11个单位。开灯的情况下也要走11个单位。

3. 如果它在点4，它要走1个单位。开灯的情况下也要走1个单位。

于是最坏的情况下，它要多走两个单位。

这题其实很有意思，关键在判断怎样才算是知道自己在哪里了。

对每个内角用叉乘判断角度并标号（我的处理应该是麻烦了，可以不用把边和点连起来的，分开存就行了）。

凡是奶牛走过的，都将成为它能够获知的信息（判断依据），也就是说走过的路和角度按照顺序都成为新的哈希标准。

然后就是模拟了。

哈希用vector + map比较好写，具体见代码

Code:

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<map>
#include<vector>
#include<cmath>
#include<algorithm>
using namespace std;

const int Max = 200;

struct node{
	int a, b, len;
}L[Max + 5];

int N;
int X[Max + 5], Y[Max + 5];
int Dis[2][Max + 5];

map<vector<int>, int>Hash;

void getint(int & num){
	char c;	int flg = 1;	num = 0;
	while((c = getchar()) < '0' || c > '9')	if(c == '-')	flg = -1;
	while(c >= '0' && c <= '9'){	num = num * 10 + c - 48;	c = getchar();}
	num *= flg;
}

int Get_angle(int a, int b, int c){
	int x1 = X[b] - X[a], x2 = X[c] - X[b];
	int y1 = Y[b] - Y[a], y2 = Y[c] - Y[b];
	int ji = x1 * y2 - x2 * y1;
	if(ji < 0)	return -1;//90
	if(ji > 0)	return -2;//270
	else return -3;//180
}

void Pre_line(){
	L[1].a = Get_angle(N - 2, N - 1, 1);
	L[1].b = Get_angle(N - 1, 1, 2);
	L[1].len = fabs(X[1] - X[N] + Y[1] - Y[N]);
	for(int i = 2; i < N; ++ i){
		L[i].a = L[i - 1].b;
		L[i].b = Get_angle(i - 1, i, i + 1);
		L[i].len = fabs(X[i] - X[i - 1] + Y[i] - Y[i - 1]);
	}
	L[N].a = L[N - 1].b;
	L[N].b = Get_angle(N - 1, N, 1);
	L[N].len = fabs(X[N] - X[N - 1] + Y[N] - Y[N - 1]);
}

void Pre_dis(){
	for(int i = 2; i <= N; ++ i)
		Dis[0][i] = Dis[0][i - 1] + L[i].len;
	Dis[1][N] = L[1].len;
	for(int i = N - 1; i >= 1; -- i)
		Dis[1][i] = Dis[1][i + 1] + L[i + 1].len;
}

int main(){
	//freopen("lightsout.in", "r", stdin);
	//freopen("lightsout.out", "w", stdout);
	getint(N);
	for(int i = 1; i <= N; ++ i)
		getint(X[i]), getint(Y[i]);
	Pre_line();
	Pre_dis();
	vector<int>now;
	for(int i = 2; i < N; ++ i){
		now.clear();
		now.push_back(L[i].b);
		++ Hash[now];
		for(int j = i + 1; j <= N; ++ j){
			now.push_back(L[j].len);
			now.push_back(L[j].b);
			++ Hash[now];
		}
	}
	int Ans = 0;
	bool flg = 0;
	for(int i = 2; i < N; ++ i){
		now.clear();
		now.push_back(L[i].b);
		if(Hash[now] == 1){
			Ans = max(Ans, min(Dis[0][i], Dis[1][i]));
			continue;
		}
		for(int j = i + 1; j <= N; ++ j){
			now.push_back(L[j].len);
			now.push_back(L[j].b);
			if(Hash[now] == 1){
				flg = 1;
				Ans = max(Ans, (Dis[1][i] - Dis[1][j]) + min(Dis[0][j], Dis[1][j]) - min(Dis[0][i], Dis[1][i]));
				break;
			}
		}
		if(! flg)	Ans = max(Ans, Dis[1][i]);
	}
	Ans = max(Ans, Dis[1][N] - min(Dis[0][N], Dis[1][N]));
	printf("%d\n", Ans);
	return 0;
}