UVA-10881 - Piotr's Ants

Piotr‘s Ants

Time Limit: 2 seconds

Kent Brockman

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

Input

The first line of input gives the number of cases, N. Ntest cases follow. Each one starts with a line containing 3 integers:L ,T andn
(0 <= n <= 10000).The nextn lines give the locations of then ants (measuredin 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 byn lines describing the locations and directions of then ants in the same format and order as in the input. If two or moreants are at the same
location, print "Turning" instead of "L" or "R" fortheir direction. If an ant falls off the polebefore
T seconds,print "Fell off" for that ant. Print an empty line after each test case.

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

Case #1:
2 Turning
6 R
2 Turning
Fell off

Case #2:
3 L
6 R
10 R

这个问题真的不简单啊，貌似挑战上也有这个例子，首先输入的顺序不是特定的，所以要从左到右编号，中间碰撞虽然可以视为相互穿过，但是相对位置是不变的，与初始顺序一样的。

，，，其实理解了order数组的作用就很简单了

开始输入的第i只蚂蚁，是从左边数第order[i]个，所以我们后面操作的是order数组，即按照相对顺序排列的

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 10005;
struct ant
{
    int id;//输入顺序
    int p;//位置
    int d;//方向
    bool operator < (const ant & a){
        return p < a.p;
    }
}before[N],after[N];
int order[N];
const char dir[][10] = {"L","Turning","R"};

int main()
{
    int tt;
    cin >> tt;
    for(int ca = 1;ca <= tt;ca++)
    {
        int l,t,n;
        scanf("%d%d%d",&l,&t,&n);
        for(int i = 0;i < n;i++)
        {
            int p,d;
            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};
        }
        //计算order数组
        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-1;i++)
            if(after[i].p == after[i+1].p)
                after[i].d = after[i+1].d = 0;

        //输出
        printf("Case #%d:\n",ca);
        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,dir[after[a].d+1]);
        }
        printf("\n");
    }
    return 0;
}

UVA-10881 - Piotr's Ants