Piotr's Ants(Uva 10881)

“One thing is for certain: there is no stopping them; the ants will soon be here. And I, for one, welcome our new insect overlords.” —–Kent Brockman

Problem 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.

Sample Input

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

Sample Output

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

题目大意：
一个长度为L的木棍上，有几只蚂蚁，它们要么向左爬要么向右爬，速度为1厘米每秒，两只蚂蚁碰面时，均掉头（掉头时间忽略），给出每只蚂蚁的初始位置和朝向，计算T秒之后每只蚂蚁的位置；
输入格式：
输入的第一行为数据的组数，每组数据的第一行为3个正整数L，T，n(0<= n <=10000)，以下的每行描述一只蚂蚁距离木棍左端的距离（厘米）以及一个字母表示朝向，L表示蚂蚁的初始朝向向左，R表示朝向右；
输出格式：
对于每组数据，输出n行，按照输入顺序输出每只蚂蚁的位置以及朝向(Turning表示正在碰撞)，如果在T秒以前已经掉下木棍，输出Fell off

分析：
这个问题看似有点麻烦，其实只要分成两大步求解就会变的简单很多：
1.忽视蚂蚁的差异性，将蚂蚁的调头视为相互穿过继续前进
2.计算在步骤1中计算出来的位置上的蚂蚁都是哪一只蚂蚁以及各只蚂蚁现在面对的方向是左还是右

因为输入数据中蚂蚁不一定是有序的，所以确定输入的蚂蚁的各自的序号order[i]

#include <cstdio>
#include <algorithm>

using namespace std;

const int maxn = 10000+5;

struct Ant{
    int id; //input order
    int p;  //position
    int d;  //direction

    bool operator < (const Ant& a)const{
        return  p < a.p;
    }
}before[maxn], after[maxn];

const char dirName[][10] = {"L", "Turning", "R"};

int order[maxn];

int main()
{

    int K;
    scanf("%d", &K);

    for(int kase = 1; kase <= K; kase++){
        int L, T, n;
        printf("Case #%d:\n", kase);
        scanf("%d%d%d", &L, &T, &n);
        for(int i = 0; i<n; i++){
            int p, d;   //the start position of this ant and the start direction
            char c;
            scanf("%d %c",&p, &c);
            d = (c == 'L' ? -1 : 1);
            before[i] = (Ant){i,p,d};
            after[i] = (Ant){0, p+T*d, d};
        }

        sort(before, before+n);
        for(int i=0; i<n; i++){
            order[before[i].id] = i;
        }


        sort(after, after+n);
        for(int i = 0; i<n; i++){
            if(after[i].p == after[i+1].p){
                after[i].d = after[i+1].d = 0;
            }
        }

        for(int i = 0; i<n; i++){
            int a = order[i];
            if(after[a].p < 0|| after[a].p > L){
                printf("Fell off\n");
            }else{
                printf("%d %s\n", after[a].p, dirName[after[a].d+1]);
            }
        }
        printf("\n");
    }

    return 0;
}