POJ1083 Moving Tables

POJ1083 Moving Tables

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 35297		Accepted: 11774

Description

The famous ACM (Advanced Computer Maker) Company has rented a floor of a building whose shape is in the following figure. 

The floor has 200 rooms each on the north side and south side along the corridor. Recently the Company made a plan to reform its system. The reform includes moving a lot of tables between rooms. Because the corridor is narrow and all the tables are big, only one table can pass through the corridor. Some plan is needed to make the moving efficient. The manager figured out the following plan: Moving a table from a room to another room can be done within 10 minutes. When moving a table from room i to room j, the part of the corridor between the front of room i and the front of room j is used. So, during each 10 minutes, several moving between two rooms not sharing the same part of the corridor will be done simultaneously. To make it clear the manager illustrated the possible cases and impossible cases of simultaneous moving. 

For each room, at most one table will be either moved in or moved out. Now, the manager seeks out a method to minimize the time to move all the tables. Your job is to write a program to solve the manager's problem.

Input

The input consists of T test cases. The number of test cases ) (T is given in the first line of the input file. Each test case begins with a line containing an integer N , 1 <= N <= 200, that represents the number of tables to move. 
Each of the following N lines contains two positive integers s and t, representing that a table is to move from room number s to room number t each room number appears at most once in the N lines). From the 3 + N -rd 
line, the remaining test cases are listed in the same manner as above.

Output

The output should contain the minimum time in minutes to complete the moving, one per line.

Sample Input

3 
4 
10 20 
30 40 
50 60 
70 80 
2 
1 3 
2 200 
3 
10 100 
20 80 
30 50 

Sample Output

10
20
30

Source

Taejon 2001

 

解题思路：

     酒店有400个房间，如下编号对称分布在一条走廊两侧
     1 3 5 ... 397 399
        这里是走廊
     2 4 6 ... 398 400
 
     现在要从房间s->t搬桌子，有N组房间需要搬桌子，每搬一次10分钟(不论两个房间相隔多远).
     对于某组房间，搬桌子期间 s->t 之间的走廊会被占用，
     而其他组房间若没有使用到占用的走廊，则可同时搬，否则要等待.
     特别地，相对的两间房，共用一段走廊, 即若房间3的走廊被占用了，等同于房间4的走廊被占用了.
 
     给定N组需要搬的桌子，求最小可以搬完的时间.
 
 
    解题思路:
     感觉这题有点类似于多线程的同步互斥场景问题.
 
     ① 由于相对的两间房共用同一段走廊，为了方便处理问题，可以把所有奇数房间转换成偶数房间，反之亦可.
        如 1->6 可等价转换成 2->6， 尔后只需要关注一侧的房间即可（共200间）
     ② 根据房间号对走廊进行分割，可分割成200段走廊. 在从房间s->t搬桌子期间，对所使用到的每段走廊计数+1
     ③ 所有桌子搬完后，统计每段走廊的计数值（计数值代表这段走廊总共需要被占用的次数）,
        由于题目并不考虑搬动期间的移动过程因素(类比多线程的事务锁)，
        因此最大的一个计数值*10分钟 就是所求的最小搬完时间（因为只要走廊被占着，就只能在下一次再搬，不能同时搬） 

#include <iostream>
using namespace std;
 
const static int ROOM_NUM = 400;    // 最大房号
const static int TIME_UNIT = 10;    // 时间单位
 
/* 
 * 把偶数房号转换成奇数房号
 *  even 偶数房号
 * return 奇数房号
 */
int toOdd(int even);
 
void solve(void);
 
int main(void) {
    int testCase = 0;
    cin >> testCase;
    for(int t = 0; t < testCase; t++) {
        solve();
    }
 
    //system("pause");
    return 0;
}
 
 
int toOdd(int even) {
    return (even % 2 == 0 ? even - 1 : even);
}
 
 
void solve(void) {
    int useCnt[ROOM_NUM] = { 0 };       // 每个房间前的走廊被使用的次数
    int maxUseCnt = 0;                  // 被使用最多的次数
 
    int moveCnt = 0;                    // 需要搬动的桌子组数
    cin >> moveCnt;
    int* fromRooms = new int[moveCnt];  // 起点房间集
    int* toRooms = new int[moveCnt];    // 终点房间集
    for(int i = 0; i < moveCnt; i++) {
        int from, to;
        cin >> from >> to;
 
        // 使房号小的在前面
        fromRooms[i] = (from <= to ? from : to);
        toRooms[i] = (from > to ? from : to);
 
        // 把房号全部转换成奇数
        fromRooms[i] = toOdd(fromRooms[i]); 
        toRooms[i] = toOdd(toRooms[i]);
 
        // 相关房间前占用的走廊被使用次数+1
        for(int roomId = fromRooms[i]; roomId <= toRooms[i]; roomId += 2) {
            useCnt[roomId]++;
            if(maxUseCnt < useCnt[roomId]) {
                maxUseCnt = useCnt[roomId]; // 登记最大的使用次数
            }
        }
    }
    delete[] fromRooms;
    delete[] toRooms;
 
    // 计算最小的使用时间
    maxUseCnt = (maxUseCnt <= 0 || maxUseCnt > moveCnt ? moveCnt : maxUseCnt);
    int minUsedTime = maxUseCnt * TIME_UNIT;
    cout << minUsedTime << endl;
} 

 

转载于:https://www.cnblogs.com/alan-blog-TsingHua/p/10640127.html