UVA - 10881 Piotr‘s Ants(思维)

点击打开题目链接

Piotr's Ants

Description

Piotr likes playing with ants. He has n of them on a horizontal pole L cm long. Each ant is facing
either left or right and walks at a constant speed of 1 cm/s. When two ants bump into each other, they
both turn around (instantaneously) and start walking in opposite directions. Piotr knows where each
of the ants starts and which direction it is facing and wants to calculate where the ants will end up T
seconds from now.

Input

The first line of input gives the number of cases, N. N test cases follow. Each one starts with a line
containing 3 integers: L , T and n (0 ≤ n ≤ 10000). The next n lines give the locations of the n ants
(measured in cm from the left end of the pole) and the direction they are facing (L or R).

Output

For each test case, output one line containing ‘Case #x:’ followed by n lines describing the locations
and directions of the n ants in the same format and order as in the input. If two or more ants are at
the same location, print ‘Turning’ instead of ‘L’ or ‘R’ for their direction. If an ant falls off the pole
before T seconds, print ‘Fell off’ for that ant. Print an empty line after each test case.

Simple Input

2
10 1 4
1 R
5 R
3 L
10 R
10 2 3
4 R
5 L
8 R

Simple Output

Case #1:
2 Turning
6 R
2 Turning
Fell off
Case #2:
3 L
6 R
10 R

题目大意：长度为l的绳子上有n只蚂蚁，开始朝向不同，速度1，相撞后掉头，求t秒之后各蚂蚁的位置，按照输入顺序输出。

和poj上的一个题很像，但那个题只让求一个最值，无关乎顺序，这个题要考虑顺序.

思路:最终的相对顺序是确定的，所以把所有蚂蚁位置排序，从左到右的每只蚂蚁对应着初始状态下的从左到右蚂蚁的顺序，但因为输入不一定按照从左到右输入，所以要order数组存输入的序号。

附上AC代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;
const int maxn = 10000 + 5;
int order[maxn];
int T;
int l, t, n;
int x;
int kase;
char c;
char s[][10] = { "L","Turning","R" };

struct Ant {
	int id;//输入顺序
	int cur;//位置
	int direction;//方向（-1，L；0，转向；1,R）
	bool operator <(const Ant a)
	{
		return cur < a.cur;
	}
}pre[maxn],behind[maxn];

int main()
{
	ios::sync_with_stdio(false);
	cin >> T;
	while (T--)
	{
		memset(order, 0, sizeof(order));
		printf("Case #%d:\n", ++kase);
		cin >> l >> t >> n;//总长度，时间，蚂蚁数量
		for (int i = 0; i < n; i++)
		{
			cin >> x >> c;
			int d = (c == 'L'  ? -1 : 1 );
			pre[i].cur = x;
			pre[i].id = i;
			pre[i].direction = d;
			behind[i].id = 0;//id未知
			behind[i].cur = x + t*d;
			behind[i].direction = d;
		}
		//计算order数组
		sort(pre, pre + n);
		for (int i = 0; i < n; i++)
			order[pre[i].id] = i;
		//计算终态
		sort(behind, behind + n);
		for (int i = 0; i < n-1; i++)//修改碰撞中的蚂蚁的方向
			if (behind[i].cur == behind[i + 1].cur ) behind[i].direction = behind[i + 1].direction = 0;
		//输出结果
		for (int i = 0; i < n; i++)
		{
			int a = order[i];
			if (behind[a].cur<0 || behind[i].cur>l)cout << "Fell off" << endl;//出界
			else
				cout << behind[a].cur << ' ' << s[behind[a].direction+1] << endl;
		}
		cout << endl;
	}
//	system("pause");
	return 0;
}