UVA - 10881 - Piotr's Ants

传送门：

    http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=25979

题意：

    蚂蚁在单杠上爬，互相碰撞就转向。输入杠长，持续时间，还有蚂蚁数量。最后得出所有蚂蚁的位置。

    ① 蚂蚁因碰撞而掉头时，看上去就是两个点“对穿而过”。

    ② 如，蚂蚁点A（1,R），在碰撞的两秒后，存在点A'（3，R），只是（3，R）是另外一只蚂蚁。A与A'方向一样。

    ③ 其实无论怎么碰撞，原本在杠上的顺序abcdefg，碰撞后还是abcdefg的顺序，而且原本的顺序。

    ④ 只需要按照原来的顺序和方向，计算出N秒后各个点的位置（计算时，方向保持不变），再套用原来的顺序abcdefg，从左到右套用在N秒后的顺序上即可。

    ⑤ 根据输入的顺序，对应输出结果。不是简单的从左到右。所以要保存好原来的输入顺序，用数组做好映射(Mapping)。

注意：

    ① 要根据输入的顺序，输出对应蚂蚁的位置结果。

思路：

    ① 保存原有状态（位置和方向）

    ② 根据位置，从左到右排序出结果；并使用数组实现从“原输入顺序的id”到“排序后的id”的映射。

    ③ 模拟N秒后的状态，并进行位置的排序。

    ④ 根据原有从左到右的id，分配到N秒后的顺序上。结合“映射”按顺序输出结果。

总结：

    ① 智商低，就是更要多看看别人代码，学学思想；静下心来思考。

    ② 定义类或结构体的时候，用其来声明数组时，有时会出错；因为没有定义一个默认构造函数（无参数）。

    ③ 适当把输出文本放在数组里，根据结果对应输出数组内容，快速、而且方便管理。

    ④ 在进行“==”操作对比时，居然用数字比'R'，或者字母比'1'；不要以为‘==’两边顺其自然就是同类型数据，要理解各位置各变量的内容！低级错误不能有。

STL版本<使用list和stack>：Memery 0 KB/Time 129 ms

#include <iostream>
#include <algorithm>
#include <stdio.h>

using namespace std;

// Local Test
// #define LOCAL_TEST


// used to define Array
const int MAX_SIZE = 10000 + 2;


// define class CAnt
// "before" array store original "InputOrder" and position/direction
struct CAnt
{
	// InputOrder number
	int id;
	// Position on pole
	int pos;
	// Direction, "-1" means "left", "0" means "turning", "1" means "right"
	int dir;
	// constructed function
	CAnt(int a, int b, int c):id(a), pos(b), dir(c){}
	// If define array, class needs a constructed function
	// for setting default value
	CAnt(){id=0; pos=0; dir=0;}
	// operator for "sort" function
	bool operator < (const CAnt &b){return pos<b.pos;}
} before[MAX_SIZE], after[MAX_SIZE];

// A Mapping for turning "InputOrder number" to the sorted array's index
int mpInOrderToSorted[MAX_SIZE];
// faster Mapping from "index" to "direction string"
char outStr[][10] = {"L", "Turning", "R"};


int main()
{
#ifdef LOCAL_TEST
	freopen("..\\in.txt", "r", stdin);
	freopen("..\\out.txt", "w+", stdout);
#endif
	// ------- Solution by using Sync(false)
	std::ios::sync_with_stdio(false);
	std::cin.tie(0);

	// Store the number of Cases
	int nCase;
	cin >>nCase;
	// Every case processing
	for ( int index=0; index<nCase; index++ )
	{
		// Get "maxLen", the length of pole
		// Get "timePass", the time passed
		// Get "nAnts", the number of Ants
		int maxLen, timePass, nAnts;
		cin >>maxLen >>timePass >>nAnts;
		// Get input data
		for ( int i=0; i<nAnts; i++ )
		{
			// the current "i" means the inputOrder
			int id = i;
			// Get position(integer) and direction(char)
			int pos;
			char c;
			cin >>pos >>c;
			// char to integer.
			// Take care of 'R' (letter with single quotes mark)
			int dir = (c=='R'?1:-1);
			// store data to "before" array
			before[i] = CAnt(id, pos, dir);
			// use easy formula "pos+dir*timepass"
			// to calculate the positions after the time
			// By the way, directions remain unchanged
			after[i] = CAnt(0, pos+dir*timePass, dir);
		} // end for

		// 'Cause "inputOrder" is out of order From left to right on the pole
		// We need to sort the array data.
		// From the sorted array, we can get a order sequence while it means
		// the current order and the future order(they're the same)
		sort(before, before+nAnts);
		// After sorted, we miss the inputOrder,
		// use another array to store a Mapping
		// From "InputOrder"[0~n] to "poleOrder"(current or future)
		for ( int i=0; i<nAnts; i++ )
			mpInOrderToSorted[before[i].id] = i;

		// sort the array after moving
		// Get the final Ants' position
		sort(after, after+nAnts);
		// while neighbour Ants together means "Turning" direction
		// Set to "0"
		for ( int i=0; i<nAnts-1; i++ )
			if ( after[i].pos == after[i+1].pos )
				after[i].dir = after[i+1].dir = 0;

		cout <<"Case #" <<index+1 <<":" <<endl;
		for ( int i=0; i<nAnts; i++ )
		{
			int a = mpInOrderToSorted[i];
			if ( after[a].pos<0	|| after[a].pos>maxLen )
				cout <<"Fell off" <<endl;
			else
				cout <<after[a].pos <<" " <<outStr[after[a].dir+1] <<endl;
		} // end for
		cout <<endl;
	} // end for

	return 0;
}