1083 -- Moving Tables

 Moving Tables

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 32929		Accepted: 11032

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

 

 题意：

   在一个狭窄的走廊里将桌子从一个房间移动到另一个房间，走廊的宽度只能允许一个桌子通过。给出t，

   表示有t组测试数据。再给出n，表示要移动n个桌子。n下面有n行，每行两个数字，表示将桌子从a房间

   移到b房间。走廊的分布图如一图所示，每移动一个桌子到达目的地房间需要花10分钟，问移动n个桌子

   所需要的时间。

思路：

　　要在一个走廊搬桌子，从第s号房间到第t号房间，可以多组一起搬，但不能同时。
　　搬重合的，例如10-20,30-40可以一起搬，但是10-20,15-30 不能同时搬，求总计用多少时间能搬完桌子（最短时间），
　　根据题目中所给的房间号，可以发现房间号是上下排的，也就是说，从1-3,4-5 其实是不能同时搬动的。
　　而且，要注意到，偶数和奇数的不同。考虑所有情况的过程也比较复杂……
　　可以很简单的考虑到贪心算法，类似于活动安排问题。考虑到活动安排问题是最早结束时间优先
（为了给剩余活动剩余尽可能长的时间）。这道题可以将走廊看成时间轴。
　　但是，我还没有证明贪心算法用在这道题上面的正确性。虽然通过了，但是有两种可能1：测试数据有点水 2：算法正确。
　　所以算法正确性有待证明。

/*
For each room, at most one table will be either moved in or moved out.
可以用map
*/
#include<iostream>
#include<map>
using namespace std;
int main()
{
    int t;
    cin>>t;
    while(t)
    {
        int n;
        cin>>n;
        map<int,int> table;
        int a,b;
        int m = n;
        while(n)
        {
            cin>>a>>b;
            //if(a%2) a=a+1;
            //if(b%2) b = b+1;
            if(b<a)
            {
                a = b+a;b=a-b;a = a-b;
            }
            table[a] = b;
            n--;
        }
        /*
        map<int,int>::iterator print = table.begin();
        for(;print != table.end();print++)
            cout<<print->first<<" "<<print->second<<endl;*/
        map<int,int>::iterator iter = table.begin();
        for(;iter!=table.end();iter ++)
        {
            if(m <= 1) break;
            map<int,int>::iterator temp = iter;
            for(;temp!=table.end();)
            {
                if((temp->first >= (iter->second+2) && (iter->second%2)==(temp->first%2) && (iter->first%2)==(iter->second%2) && (iter->second)%2 == 1)//在同侧，可以一起移动
                   ||(temp->first >= (iter->second+3) && (iter->second%2)!=(temp->first%2) && (iter->first%2)==(iter->second%2) && (iter->second)%2 == 1)//在两侧，可以一起移动
                   ||(temp->first >= (iter->second+2) && (iter->second%2)==(temp->first%2) && (iter->first%2)==(iter->second%2) && (iter->second)%2 == 0)//在同侧，可以一起移动
                   ||(temp->first >= (iter->second+1) && (iter->second%2)!=(temp->first%2) && (iter->first%2)==(iter->second%2) && (iter->second)%2 == 0)//在两侧，可以一起移动
                   ||(temp->first >= (iter->second+2) && (iter->second%2)==(temp->first%2) && (iter->first%2)!=(iter->second%2) && (iter->second)%2 == 0)
                   ||(temp->first >= (iter->second+1) && (iter->second%2)!=(temp->first%2) && (iter->first%2)!=(iter->second%2) && (iter->second)%2 == 0)
                   ||(temp->first >= (iter->second+2) && (iter->second%2)==(temp->first%2) && (iter->first%2)!=(iter->second%2) && (iter->second)%2 == 1)
                   ||(temp->first >= (iter->second+3) && (iter->second%2)!=(temp->first%2) && (iter->first%2)!=(iter->second%2) && (iter->second)%2 == 1)
                   )
                {
                    //cout<<temp->first<<endl;
                    iter->second = temp->second;
                    int y = temp->first;
                    temp++;
                    table.erase(y);
                }
                else{temp++;}
            }
        }
        cout<<table.size()*10<<endl;
        table.clear();
        t--;
    }
    return 0;
}

另一种解决方法（同样为贪心）：

输入的时候只存了一侧的桌子号，也就是说输入的3，我存成4，这样就避免1-3,4-5的问题了，然后贪心方法，
排序，计算，出结果。。。

ACM-贪心之Moving Tables——hdu1050

#include <iostream>
using namespace std;

struct table{
    int front,back;
    bool use;
}tb[10001];


int main()
{
    int T,N,total;            //T为有几组数据，N为每组数据有几行数据,total为总用时
    int i,j,temp;            
    table tem;

    cin>>T;
    while(T--)
    {
        //**************************   输入
        cin>>N;
        for(i=0;i<N;++i)
        {
            cin>>tb[i].front>>tb[i].back;

            if(tb[i].front%2==1)
                tb[i].front+=1;
            if(tb[i].back%2==1)
                tb[i].back+=1;

            if(tb[i].front>tb[i].back)
            {
                temp=tb[i].front;
                tb[i].front=tb[i].back;
                tb[i].back=temp;
            }
        
            tb[i].use=true;
        }
        //*************************       排序

        for(i=0;i<N-1;++i)
            for(j=i+1;j<N;++j)
                if(tb[i].front>tb[j].front)
                {
                    tem=tb[i];
                    tb[i]=tb[j];
                    tb[j]=tem;
                }

        //*************************       计算值
        total=0;
        for(i=0;i<N;++i)
        {
            if(tb[i].use==false)
                continue;
            
            temp=tb[i].back;

            for(j=i+1;j<N;++j)
            {
                if(tb[j].use==false)
                    continue;
                if(tb[j].front>temp)
                {
                    tb[j].use=false;
                    temp=tb[j].back;
                }
            }
            
            total+=10;
        }
        

        //*************************     输出
        cout<<total<<endl;
        

    }

    return 0;
}

另一种思路：

　 若移动多个桌子时，所需要经过的走廊没有重合处，即可以同时移动。若有一段走廊有m个桌子都

     要经过，一次只能经过一个桌子，则需要m*10的时间移动桌子。设一个数组，下标值即为房间号。

     桌子经过房间时，该房间号为下标对应的数组值即加10。最后找到最大的数组值，即为移动完桌子

     需要的最短时间。

ACM--移动桌子--贪心--HDOJ 1050--Moving Tables

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int main(){
    int t,n,count[410],i,start,end,k;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        memset(count,0,sizeof(count));
        while(n--){
            scanf("%d%d",&start,&end);
            //可能出发位置比目的地房间大。
            if(start>end){
                //无论大小，我们都可以看做从小的房间移动到大的房间
                k=start;
                start=end;
                end=k;
            }
            if(start%2==0)//考虑实际情况，出发房间为偶数是减一，可参照题中给出的图一
               start-=1;
            if(end%2==1)//目的地房间为奇数时加一
               end+=1;
            for(i=start;i<=end;++i)
               count[i]+=10;
        }
        printf("%d
",*max_element(count,count+400));//STL中寻找数列最大值函数
    }
    return 0;
}

表示这种方法真是神气，get！！