佔座位

【問題描述】sun所在學校的教室座位每天都是可以預佔的。
一個人可以去佔多個座位，而且一定是要連續的座位，如果佔不到他所要求的這麼多座位，那麼他就一個座位也不要了。爲了降低難度，每次分配座位按座位號從小到大查找，採用最先適配法分配座位。

【輸入形式】輸入有多組數據。
每組數據輸入座位排數n，0<n<=100（座位的排列數相等，座位是按每行從左到右依次排序的,，第1行的最右邊一個座位與第二行的第一個座位視爲連續座位），m（ 0<m<=min(100,n*n) ）個人。
然後輸入k（0<k<=100），最後輸入k個命令。
命令只有兩種：
1.in id num（代表id,0<=id<m,要佔num個座位，若佔不到連續的num(0<num<=20)個座位表示該命令無效）
2.out id（代表id要釋放他之前佔的所有座位）
注意：如果id之前佔過座還沒釋放那麼之後他的in命令都是無效的，
如果id之前沒佔過座位那麼他的out命令也是無效的。

【輸出形式】對每個in命令輸出yes或者no，如果命令有效則輸出yes，無效則輸出no。
在yes no後面只帶有回車，不帶其他任何字符。

【樣例輸入】

4 10

9

in 1 7

in 2 3

in 3 3

in 3 3

in 4 3

out 2

in 5 6

out 3

in 5 6

• 問題分析及邊界條件

要處理的問題：

1.如何確定該id已經佔過位子。

2.如何確定該id out的時候，他是佔過位子的。

3.如何確定又連續的位置可以被佔用。

邊界條件：

1. 該id重複佔位。
2. 該id沒有佔位卻釋放位置。
3. 沒有連續的位置供佔有。

• 算法設計

通過上述分析，將採用下面的方法解決相關問題：

1. 將座位轉化成結構體數組，數據成員只有id，相當於一串珠子，珠子上有id的相當於被佔用，珠子上沒有Id的即該數據成員的值爲0，表示未被佔用。
2. 如何確定該id已經佔過位子：查找這串珠子上是否有該id。
3. 如何確定該id out的時候，他是佔過位子的：查找這串珠子上是否有該id。
4. 如何確定又連續的位置可以被佔用：查找id=0的連續個數，當不連續時，歸爲0，重新往後查找。

• 詳細設計（從算法到程序）

1. 將輸入的數據存到結構體裏。
2. 設計一個容量爲n*n的結構體數組爲一串珠子。
3. 設計一個查找是否存在重複佔位的函數。
4. 設計一個查找沒有佔位就釋放座位的函數。
5. 設計一個能夠連續佔位的函數。

• 樣例設計與測試

測試樣例一	重複佔位
樣例輸入	3 4 4 in 1 3 in 1 3 in 2 3 out 1
樣例輸出	yes no yes yes

測試樣例一	可以連續佔位
樣例輸入	5 9 5 in 1 10 in 2 10 in 3 5 out 1 in 4 8
樣例輸出	yes yes yes yes yes

 

測試樣例二	沒有佔位就釋放座位
樣例輸入	5 10 4 in 1 10 in 2 15 out 3 out 2
樣例輸出	yes yes no yes

測試樣例三	沒有連續的座位可以被佔用
樣例輸入	5 6 6 in 1 5 in 2 5 in 3 10 in 4 5 out 1 in 5 7
樣例輸出	yes yes yes yes yes no

程序如下：

#include<iostream>
#include<string>
using namespace std;

int n,m,k;
struct occupy
{
    string fea;
    int id;
    int num;
};
struct wipe
{
    int id;
    void ini()
    {
        id=0;
    }
};
bool search_no_in_out(wipe w[],occupy occ);
bool search_in_in(wipe w[],occupy occ);
void wipe_change_out(wipe w[],occupy occ);
bool wipe_change_in(wipe w[],occupy occ);

int main()
{
    cin>>n>>m>>k;
    occupy occ[k];
    for(int i=0;i<k;i++)
    {
        cin>>occ[i].fea;
        if(occ[i].fea=="in")
        {
            cin>>occ[i].id>>occ[i].num;
        } 
        else
        {
            cin>>occ[i].id;
        }
    }
    wipe w[n*n];
    for(int i=0;i<n*n;i++)
    {
        w[i].ini();
    }
    for(int i=0;i<k;i++)
    {
        
        if(occ[i].id>m)
        {
            cout<<"no"<<endl;
        }
        else if(occ[i].fea=="out")
        {
            if(search_no_in_out(w,occ[i]))
            {
                cout<<"yes"<<endl;
                wipe_change_out(w,occ[i]);
            }
            else
            {
                cout<<"no"<<endl;
            }
        }
        else if(occ[i].fea == "in")
        {
            if(search_in_in(w,occ[i]))
            {
                if(wipe_change_in(w,occ[i]))
                {
                    cout<<"yes"<<endl;
                }
                else
                {
                    cout<<"no"<<endl;
                }
            }
            else
            {
                cout<<"no"<<endl;
            }
        }
        
    }
    return 0;
}
bool search_no_in_out(wipe w[],occupy occ)
{
    for(int i=0;i<n*n;i++)
    {
        if(w[i].id==occ.id)
        {
            return 1;
        }
    }
    return 0;
}
bool search_in_in(wipe w[],occupy occ)
{
    for(int i=0;i<n*n;i++)
    {
        if(w[i].id==occ.id)
        {
            return 0;
        }
    }
    return 1;
}
void wipe_change_out(wipe w[],occupy occ)
{
    for(int i=0;i<n*n;i++)
    {
        if(w[i].id==occ.id)
        {
            w[i].id=0;
        }
    }
}

bool wipe_change_in(wipe w[],occupy occ)
{
    int num=0;
    for(int i=0;i<n*n;i++)
    {
        if(w[i].id==0&&num<occ.num)
        {
            num++;
            if(num>=occ.num)
            {
                for(int k=i;k>=i-num+1;k--)
                {
                    w[k].id=occ.id;
                }
                return 1;
            }
        }
        
        else
        {
            num=0;
        }
    }
    return 0;
}