UVA ~ 1598 ~ Exchange （优先队列 + 模拟）

最新推荐文章于 2022-05-05 00:10:29 发布
最新推荐文章于 2022-05-05 00:10:29 发布
阅读量533 收藏 1
点赞数 1
分类专栏： 【栈/队列/优先队列/链表】 【暴力/模拟/水题】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZscDst/article/details/80109856
版权

题意：你的任务是为交易所设计一个订单处理系统。要求支持以下3种指令。

□ BUY p q：有人想买，数量为p，价格为q

□ SELL p q：有人想卖，数量为p，价格为q

□ CANCEL i：取消第i条指令对应的订单（输入保证该指令是BUY或者SELL）

交易规则如下： 对于当前买订单，若当前最低卖价（ask price） 低于当前出价，则发生交易；对于当前卖订单，若当前最高买价（bid price）高于当前价格，则发生交易。发生交易时，按供需物品个数的最小值交易。交易后，需修改订单的供需物品个数。当出价或者价格相同时，按订单产生的先后顺序发生交易。输入输出细节请参考原题。

提示： 本题是一个不错的优先队列练习题。 以上解释为COPY自算法竞赛入门。

补充一下：大家按生活中的常理去理解这个题就是对的。物品只有一种。如果现在有一条BUY的指令，我们肯定要买最便宜的啊（如果能买得起），如果现在现在是一条SELL的指令，我们的东西价格便宜，肯定出价高者先得啊（如果他们能买得起）。

输出格式为：对于当前指令，如果发生交易，输出“TRADE %d %d”，第一个%d此次交易的数量，第二个%d表示此次交易的价格（①如果当前指令是BUY，那么就是卖的价格，因为人家卖10元你花100元去买，那恐怕不是傻子哦 ②如果当前指令是SELL，那么就是买的出价，因为人家花100元买你10元的东西，你还不抓住机会，血赚一波）。每个指令后面输出一个：“QUOTE %d %d - %d %d”，前两个%d表示最高出价（BUY）的那【些】订单的数量、出价，后两个%d表示价格最低（SELL）的那【些】订单的数量、出价。（如果有几个订单都价格都为10，输出这几个订单数量和）

如果没有买的订单，价格数量都认为是0，如果没有卖的订单，价格认为99999，数量认为0。

坑点：可能对某一条指令取消两次！！！比如uDebug中的开始这部分数据：

4042
SELL 186 297
SELL 235 203
CANCEL 1
SELL 32 184
CANCEL 2
SELL 172 241
SELL 54 200
CANCEL 4
CANCEL 4
CANCEL 1

思路：首先保存输入的订单消息，用一个优先队列保存BUY的信息（出价高的优先，相等指令编号小的优先），另外一个优先队列保存SELL的信息（价格低的优先，相等指令编号小的优先）。我们在用两个map<int,int>：价格对应总数量，保存价格为x的数量，一个表示BUY的信息，一个表示SELL的信息。发生交易时，订单中和map和优先队列中对应的东西减少，然后输出此次交易信息。如果只有买卖，就好了，但是还有取消操作，所以我们需要开一个标记数组vis表示该订单有没有被取消，如果被取消了，map对应的东西需要进行对应减少。


AC代码：

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e4 + 5;
struct Node
{
    int cost, num, id;
    string op;
    Node () {}
    Node (int _id, int _num, int _cost, string _op):
        id(_id), num(_num), cost(_cost), op(_op) {}
    bool operator < (const Node& that) const
    {
        if (cost != that.cost) return that.cost > cost;
        return that.id < id ;
    }
    bool operator > (const Node& that) const
    {
        if (cost != that.cost) return that.cost < cost;
        return that.id < id;
    }
};
int n;
Node IN[MAXN];//输入订单
bool vis[MAXN];//指令是否被取消
priority_queue<Node> buy;//买列表
priority_queue<Node, vector<Node>, greater<Node> > sell;//卖列表
map<int, int> _buy;//买的价格对应数量
map<int, int> _sell;//卖价格对应数量
void init()
{
    memset(vis, 0, sizeof(vis));
    _buy.clear(); _sell.clear();
    while (!buy.empty()) buy.pop();
    while (!sell.empty()) sell.pop();
    _buy[0] = 0; _sell[99999] = 0;
    buy.push(Node(MAXN, 0, 0, ""));
    sell.push(Node(MAXN, 0, 99999, ""));
}
void work(string str)
{
    while (sell.top().cost <= buy.top().cost)//可以交易
    {
        if (buy.size() == 1 || sell.size() == 1) break;
        if (vis[buy.top().id]) { buy.pop(); continue; }//被取消
        if (vis[sell.top().id]) {  sell.pop(); continue; }//被标记
        Node s = sell.top(), b = buy.top();
        sell.pop(); buy.pop();
        int num = min(s.num, b.num);
        b.num -= num; s.num -= num;
        IN[b.id].num -= num; IN[s.id].num -= num;//订单数减少
        _buy[b.cost] -= num; _sell[s.cost] -= num;
        if (s.num) sell.push(s);//还有剩余
        if (b.num) buy.push(b);
        if (str == "BUY") printf("TRADE %d %d\n", num, s.cost);
        if (str == "SELL") printf("TRADE %d %d\n", num, b.cost);
    }
    while (sell.size() > 1 && vis[sell.top().id]) sell.pop();//如果队首是被取消的订单
    while (buy.size() > 1 && vis[buy.top().id]) buy.pop();//如果队首是被取消的订单
}
int main()
{
    bool has_out = false;
    while (~scanf("%d", &n))
    {
        init();
        if (has_out) printf("\n");
        else has_out = true;
        for (int i = 1; i <= n; i++)
        {
            string str; cin >> str;
            if (str == "BUY")
            {
                int p, q; scanf("%d%d", &p, &q);
                IN[i] = Node(i, p, q, str);//保存输入信息
                _buy[q] += p;
                buy.push(Node(i, p, q, str));//插入优先队列
            }
            if(str == "SELL")
            {
                int p, q; scanf("%d%d", &p, &q);
                IN[i] = Node(i, p, q, str);//保存输入信息
                _sell[q] += p;
                sell.push(Node(i, p, q, str));//插入优先队列
            }
            if (str == "CANCEL")
            {
                int id; scanf("%d", &id);
                //没有被取消
                if (IN[id].op == "BUY" && !vis[id]) _buy[IN[id].cost] -= IN[id].num;
                if (IN[id].op == "SELL" && !vis[id]) _sell[IN[id].cost] -= IN[id].num;
                vis[id] = true;//标记为取消
            }
            work(str);
            printf ("QUOTE %d %d - %d %d\n", _buy[buy.top().cost], buy.top().cost, _sell[sell.top().cost], sell.top().cost);
        }
    }
    return 0;
}
/*
11
BUY 100 35
CANCEL 1
BUY 100 34
SELL 150 36
SELL 300 37
SELL 100 36
BUY 100 38
CANCEL 4
CANCEL 7
BUY 200 32
SELL 500 30
*/


附一份当时水过去的代码，哈哈哈

采用了一种很暴力的解法，即取消操作：是通过找到优先队列中对应的那个订单删掉，之前pop的那些订单先存到一个vector中，然后在放回优先队列，就实现了取消操作。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e4 + 5;
struct Buy
{
    int cost, num, id;
    Buy (int _num, int _cost, int _id): num(_num), cost(_cost), id(_id) {}
    bool operator < (const Buy& that) const
    {
        if (cost != that.cost) return that.cost > cost;
        return that.id < id ;
    }
};
struct Sell
{
    int price, num, id;
    Sell (int _num, int _price, int _id): num(_num), price(_price), id(_id) {}
    bool operator < (const Sell& that) const
    {
        if (price != that.price) return that.price < price;
        return that.id < id;
    }
};
int n;
priority_queue<Buy> buy;
priority_queue<Sell> sell;
map<int, int> _buy;//price num
map<int, int> _sell;//price num
void init()
{
    _buy.clear(); _sell.clear();
    while (!buy.empty()) buy.pop();
    while (!sell.empty()) sell.pop();
    _buy[0] = 0; _sell[99999] = 0;
    buy.push(Buy(0, 0, MAXN));
    sell.push(Sell(0, 99999, MAXN));
}
void work(string str)
{
    while (sell.top().price <= buy.top().cost)
    {
        if (sell.size() == 1 || buy.size() == 1) break;
        Sell s = sell.top(); Buy b = buy.top();
        sell.pop(); buy.pop();
        int num = min(s.num, b.num);
        s.num = s.num - num; b.num = b.num - num;
        _buy[b.cost] -= num; _sell[s.price] -= num;
        if (s.num) sell.push(s);
        if (b.num) buy.push(b);
        if (str == "BUY") printf("TRADE %d %d\n", num, s.price);
        if (str == "SELL") printf("TRADE %d %d\n", num, b.cost);
    }
}
void Cancel(int id)
{
    bool flag = false;
    vector<Buy> v1;
    while (buy.size() != 1)
    {
        if (buy.top().id == id)
        {
            flag = true;
            _buy[buy.top().cost] -= buy.top().num;
            buy.pop(); break;
        }
        v1.push_back(buy.top()); buy.pop();
    }
    vector<Sell> v2;
    while (sell.size() != 1 && !flag)
    {
        if (sell.top().id == id)
        {
            _sell[sell.top().price] -= sell.top().num;
            sell.pop(); break;
        }
        v2.push_back(sell.top()); sell.pop();
    }
    for (auto i: v1) buy.push(i);
    for (auto i: v2) sell.push(i);
}
int main()
{
    bool has_out = false;
    while (~scanf("%d", &n))
    {
        init();
        if (has_out) puts("");
        has_out = true;
        for (int i = 1; i <= n; i++)
        {
            string str; cin >> str;
            if (str == "BUY")
            {
                int p, q; scanf("%d%d", &p, &q);
                _buy[q] += p;
                buy.push(Buy(p, q, i));
            }
            if(str == "SELL")
            {
                int p, q; scanf("%d%d", &p, &q);
                _sell[q] += p;
                sell.push(Sell(p, q, i));
            }
            if (str == "CANCEL")
            {
                int id; scanf("%d", &id);
                Cancel(id);
            }
            work(str);
            printf ("QUOTE %d %d - %d %d\n", _buy[buy.top().cost], buy.top().cost
                    , _sell[sell.top().price], sell.top().price);
        }
    }
    return 0;
}
/*
11
BUY 100 35
CANCEL 1
BUY 100 34
SELL 150 36
SELL 300 37
SELL 100 36
BUY 100 38
CANCEL 4
CANCEL 7
BUY 200 32
SELL 500 30
*/







张松超
关注
专栏目录
UVA 1598 Exchange
zju2016的博客
07-12 1499
这道题目难在阅读，翻译如下（第一段可以省略，从第二段开始）        订货薄会接收到一系列的消息，这些消息是订单或者是取消之前订单的请求。没有被取消的订单是激活状态的。订单类型分为购买订单和销售订单。每一个购买订单或者是销售订单有两个正数的变量size和price。订货薄保持了一系列激活状态的订单列表，并且产生quote(报价)和trades（交易）。激活状态的购买订单中价格最高的是最优购买
UVa 1598 Exchange 翻译+解题
super_son的博客
10-05 1138
这个题目巨长，而紫书上的描述巨简单，但是看了题目的样例之后，心中mmp，这踏马什么玩意，怎么输出还能是这样。看了原题的输入输出细节之后，只想说，这哪跟哪啊，啥都看不懂。这下只能看原题了。（英语还没过四级，，因为还没考，，，，翻译的烂请谅解） 第一段就不翻译了，因为没啥信息。 这个有一个订货簿啊（后面就用本子代替了啊），它记录着一些订单，还有取消订单的记录啥的。这种没有被取消的订单被称为 act
Uva - 1598 - Exchange
anpi3191的博客
06-14 134
本来想用优先队列做，可是不知道怎么处理之间的关系，最后还是用了map方法AC了，不过速度上有些慢，提交的时候跑了1.557秒。估计这道题时间都稍微长些，题目的时间限制也是4.5秒，不像一般题目的3秒限制。 AC代码： #include <iostream> #include <cstdio> #include <cstdlib> #...
UVA - 1598 Exchange
weixin_30657541的博客
09-17 147
/* 法一借鉴自： http://blog.csdn.net/xienaoban/article/details/52818530 这题的特点和注意点，在上面的博客的解析中，已经说得十分详细了 */ #include <iostream> #include <map> #include <set> #inc...
UVA1598
crazychen的专栏
02-10 1318
思路：每个优先级队列分别存储sell和buy，每个指令后都判断是否产生交易 package test; import java.util.Comparator; import java.util.Iterator; import java.util.PriorityQueue; import java.util.Queue; import java.util.Scanner; import j
uva1598(大模拟+优先队列)
摆渡人的博客
07-06 350
思路：照着模拟就行 坑点：一个订单可能会被删除多次，还有一个点。。。优先队列的top函数，返回的是一个copy。。。 代码如下： /* */ #define LOCAL #include<cstdio> #include<algorithm> #include<cstring> #include<iostream> #include<...
UVa-writeup:使用C ++编写UVa
03-07
你可以使用文件输入/输出模拟UVa的输入输出格式，以确保代码的正确性。 在UVa平台上，你可能会遇到“Time Limit Exceeded”（TLE）或“Memory Limit Exceeded”（MLE）的情况。这时，你需要优化你的算法，减少不必...
UVA 1153（贪心+优先队列）（选择不重叠区间的变形）
白衣少年郎
01-16 369
题意：给定n个工作的需要时间和截止时间，工作只能线性来完成，问最多能完成多少个工作。 题解：容易想到，先将工作根据截止时间排序，截止时间较早者靠前，之后维护一个时间变量cnt和优先队列,若当前工作cnt+q<=d则将q放入优先多队列，否则将当前q与priority_queue.top比较，若q小则将top pop掉并push q，并cnt-=queue.top+q从而减少当前所耗时间，从而实...
紫书UVa1598
weixin_46273288的博客
03-09 142
#include <vector> #include <map> #include<algorithm> #include<cmath> #include<vector> #include<cstdio> #include <sstream> #include<iostream> #include<iomanip> #include<stack> #include<set> .
Exchange UVA - 1598 优先队列，模拟
qq_43185391的博客
02-26 299
https://cn.vjudge.net/problem/UVA-1598#author=0 题意：你的任务是为交易所设计一个订单处理系统。要求支持以下3种指令。 BUY p q：有人想买，数量为p，价格为q SELL p q：有人想卖，数量为p，价格为q CANCEL i：取消第i条指令对应的订单（输入保证该指令是BUY或者SELL） 交易规则如下： 对于当前买订单，若当前最低卖价（ask...
UVa-1598-Exchange
zay999abc的博客
11-18 1139
用两个map>,greater>，map>,less>分别保存buy信息和sell信息,其中key是价格，每个pair是一条信息。pair.first是信息序号，pair.second是数量。map>用来指示某个序号的信息是buy还是sell，并且保存相应的价格。每从输入获取一条信息，如果是buy，则检查sellInfo中的最小价格是否低于此条buy信息的价格，若是，则进行交易，直到有一方size
UVA 1598 Exchange
weixin_30287169的博客
08-20 117
题目链接：https://vjudge.net/problem/UVA-1598 题目大意 　　翻译：https://blog.csdn.net/super_son/article/details/78162653 分析 　　巨烦的模拟题，debug一天。。。 　　要点： 由于交易量可以取到 99999，所以交易量上限设 100000 比较好。 每次交易只可以交易一个条...
UVA-1598 交易所 题解答案代码 算法竞赛入门经典第二版
Coding home - 漂流瓶jz
05-05 977
GitHub - jzplp/aoapc-UVA-Answer: 算法竞赛入门经典 例题和习题答案 刘汝佳 第二版 AC代码 有意思的一个题目。书上说这是一个不错的优先队列练习题，但实际上它其实是一个让我们了解优先队列有哪些限制的题目。 其他同学的很多题解因为优先队列限制太大，转而使用了map等结构作为优先队列的代替。我这里还是使用的优先队列。 这个题目碰到的优先队列的限制有： 1. 不能清空优先队列，无法clear 2. 不能遍历，只能查看堆顶元素 3. 默认是大顶堆，自行改变判断规则有些麻
[刷题]算法竞赛入门经典(第2版) 5-14/UVa1598 - Exchange
weixin_30412013的博客
10-14 137
题意：模拟买卖，当出售价bid等于或低于出售价ask，则交易。 代码：（Accepted，0.330s） //UVa1598 - Exchange //Accepted 0.330s //#define _XIENAOBAN_ #include<functional> #include<algorithm> #include<iostrea...
习题5_14 uva1598交易所（想看题意搓进来）
qq_37548017的博客
09-06 198
说声抱歉，这题写的代码有点乱，所以后面有时间再改，虽然AC了 先讲思路，防止以后自己忘了… 这题主要题意为多组数据，每次很多交易记录，如果此时买的时候，发现有比他内心价格还低的价格，就买，卖的时候，发现有比他心中价格高的，就卖，如果没买完或者卖完，放着剩下的等待， 如果在买或者卖之时，发现有人出价相同，那么编号在前的先来（防止打打杀杀）。 如果还有一个是废除编号第几的命令（保证只废除买或者卖的），...
紫书第五章习题 5-14 UVa1598-Exchange
JXUFE_ACMer的博客
05-26 247
出处：https://blog.csdn.net/zju2016/article/details/75005098题目链接：https://vjudge.net/contest/231030#problem/N #include&lt;iostream&gt; #include&lt;vector&gt; #include&lt;string&gt; #i...
优先队列
Sky_River_Z的博客
02-12 2329
本文摘自博客，欢迎前往博客以获得更好的体验。 优先队列 优先队列可以完成以下操作： 插入一个数值 取出最小的数值（获得数值，并且删除） 在之前的堆排序，我们已经初步引出了优先队列的概念。 优先队列容器与队列一样，只能从队尾插入元素，从队首删除元素。但是它有一个特性，就是队列中最大的元素总是位于队首，所以出队时，并非按照先进先出的原则进行，而是将当前队列中最大的元素出队。元素的比较规则默认按元素值由大到小排序，可以重载“<”操作符来重新定义比较规则。 声明方式 priority_queue .
习题5-14 交易所（Exchange，ACM/ICPC NEERC 2006，UVa1598）
TK_wang_的博客
03-07 341
原题链接：https://vjudge.net/problem/UVA-1598 分类：STL综合 备注：复杂模拟,阅读理解 前言：在别处找到一篇很nice的翻译：https://blog.csdn.net/zju2016/article/details/75005098?depth_1-utm_source=distribute.pc_relevant.none-task&utm_sou...
UVA10763:Foreign Exchange(交换学生)
xqacmer
02-02 767
作者：xq的acm之路题目链接：https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=1704题目大意：有n（1<=n<=500000）个学生想交换到其他学校学习。A到B学校的前提是找到一个B到A的搭档。n个学生两两两交换就ok，A,B用两个整数表示思路：（A,B
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值