【优先队列】【链表】【priority_queue】【list】hdu 1434

方法一：优先队列（9203MS 21048K）

方法二：链表（9640MS 33620K）

性能分析：优先队列的方法内存占用较少，速度也更快。

注意：方法一中使用的是 greater functor, 需要重载 ">", 方法二 sort 采用默认的 less functor, 需要重载 "<".

方法一：优先队列

1. 这里的优先队列应该是使用小根堆，因此用 greater

2. 这里用构造函数初始化优先队列，而不是先建立空队列，然后不停 push. 这样做可以省去多次建堆操作，不初始化用的 vector 浪费了空间。

/*
 * hdu 1434
 * http://acm.hdu.edu.cn/showproblem.php?pid=1434
 * 【优先队列】【priority_queue】
 * 9203MS	21048K
 * 1. 这里的优先队列应该是使用小根堆，因此用 greater
 * 2. 这里用构造函数初始化优先队列，而不是先建立空队列，然后不停 push.
 *    这样做可以省去多次建堆操作，不初始化用的 vector 浪费了空间。
 */
#include <iostream>
#include <queue>
#include <vector>
#include <functional>
#include <string>
using namespace std;

struct SPassenger
{
    int     iRp;
    string  strName;
};

bool operator>(const SPassenger &oPl, const SPassenger &oPr)
{
    if (oPl.iRp == oPr.iRp)
    {
        return (oPl.strName < oPr.strName);
    }
    return (oPl.iRp > oPr.iRp);
}

typedef priority_queue<SPassenger, vector<SPassenger>,
                        greater<SPassenger> > Train;

int main()
{
    vector<Train>       vecTrains;
    int                 iTrainNum, iCmdNum, iPsgrNum;
    SPassenger          oTmpPsgr;
    string              strTmp;
    int                 i, j, iRp;
    greater<SPassenger> oTmpComp;

    while (cin >> iTrainNum >> iCmdNum)
    {
        while (iTrainNum--)
        {
            vector<SPassenger>  vecTmp;

            cin >> iPsgrNum;
            while (iPsgrNum--)
            {
                cin >> oTmpPsgr.strName >> oTmpPsgr.iRp;
                vecTmp.push_back(oTmpPsgr);
            }
            Train oTmpTrain(oTmpComp, vecTmp);
            vecTrains.push_back(oTmpTrain);
        }

        while (iCmdNum--)
        {
            cin >> strTmp;
            if ("GETON" == strTmp)
            {
                cin >> i >> oTmpPsgr.strName >> oTmpPsgr.iRp;
                vecTrains[i-1].push(oTmpPsgr);
            }
            else if ("JOIN" == strTmp)
            {
                cin >> i >> j;
                while (!vecTrains[j-1].empty())
                {
                    vecTrains[i-1].push(vecTrains[j-1].top());
                    vecTrains[j-1].pop();
                }
            }
            else    // GETOUT
            {
                cin >> i;
                cout << vecTrains[i-1].top().strName << endl;
                vecTrains[i-1].pop();
            }
        }

        vecTrains.clear();
    }

    return 0;
}

方法二：链表

之所以用 list, 主要是考虑到合并操作时 list.merge() 能保证有序（前提是参数 list 有序）

/*
 * hdu 1434
 * http://acm.hdu.edu.cn/showproblem.php?pid=1434
 * 9640MS	33620K
 * 【链表】【list】
 * 之所以用 list, 主要是考虑到合并操作时 list.merge() 能保证有序（前提是参数 list 有序）
 */
#include <iostream>
#include <vector>
#include <list>
#include <string>
using namespace std;

struct SPassenger
{
    int     iRp;
    string  strName;
};

bool operator<(const SPassenger &oPl, const SPassenger &oPr)
{
    if (oPl.iRp == oPr.iRp)
    {
        return (oPl.strName > oPr.strName);
    }
    return (oPl.iRp < oPr.iRp);
}

typedef list<SPassenger> Train;
typedef list<SPassenger>::iterator ItTrain;

int main()
{
    vector<Train>       vecTrains;
    int                 iTrainNum, iCmdNum, iPsgrNum;
    SPassenger          oTmpPsgr;
    string              strTmp;
    int                 i, j, iRp;
    ItTrain             itTrain;

    while (cin >> iTrainNum >> iCmdNum)
    {
        while (iTrainNum--)
        {
            Train oTmpTrain;

            cin >> iPsgrNum;
            while (iPsgrNum--)
            {
                cin >> oTmpPsgr.strName >> oTmpPsgr.iRp;
                oTmpTrain.push_back(oTmpPsgr);
            }
            oTmpTrain.sort();
            vecTrains.push_back(oTmpTrain);
        }

        while (iCmdNum--)
        {
            cin >> strTmp;
            if ("GETON" == strTmp)
            {
                cin >> i >> oTmpPsgr.strName >> oTmpPsgr.iRp;
                itTrain = vecTrains[i-1].begin();
                while ( !(oTmpPsgr < *itTrain) &&
                       (itTrain != vecTrains[i-1].end()) )
                {
                    ++itTrain;
                }
                vecTrains[i-1].insert(itTrain, oTmpPsgr);
            }
            else if ("JOIN" == strTmp)
            {
                cin >> i >> j;
                vecTrains[i-1].merge(vecTrains[j-1]);
            }
            else    // GETOUT
            {
                cin >> i;
                cout << vecTrains[i-1].front().strName << endl;
                vecTrains[i-1].pop_front();
            }
        }

        vecTrains.clear();
    }

    return 0;
}