CCF201412-3 集合竞价 日常暴力带BUG修复

问题描述

　　某股票交易所请你编写一个程序，根据开盘前客户提交的订单来确定某特定股票的开盘价和开盘成交量。
　　该程序的输入由很多行构成，每一行为一条记录，记录可能有以下几种：
　　1. buy p s 表示一个购买股票的买单，每手出价为p，购买股数为s。
　　2. sell p s 表示一个出售股票的卖单，每手出价为p，出售股数为s。
　　3. cancel i表示撤销第i行的记录。
　　如果开盘价为p ₀，则系统可以将所有出价至少为p ₀的买单和所有出价至多为p ₀的卖单进行匹配。因此，此时的开盘成交量为出价至少为p ₀的买单的总股数和所有出价至多为p ₀的卖单的总股数之间的较小值。
　　你的程序需要确定一个开盘价，使得开盘成交量尽可能地大。如果有多个符合条件的开盘价，你的程序应当输出最高的那一个。

输入格式

　　输入数据有任意多行，每一行是一条记录。保证输入合法。股数为不超过10 ⁸的正整数，出价为精确到恰好小数点后两位的正实数，且不超过10000.00。

输出格式

　　你需要输出一行，包含两个数，以一个空格分隔。第一个数是开盘价，第二个是此开盘价下的成交量。开盘价需要精确到小数点后恰好两位。

样例输入

buy 9.25 100
buy 8.88 175
sell 9.00 1000
buy 9.00 400
sell 8.92 400
cancel 1
buy 100.00 50

样例输出

9.00 450

评测用例规模与约定

　　对于100%的数据，输入的行数不超过5000。

这题实际上暴力着价格完全没有问题，代码分几块：

1、输入

2、cancel

3、暴力求开盘价

首先输入这里题主用了优先队列——小顶堆，把买卖分成了两部分，并顺便求得了买入方的总成交量。

第二步cancel，分别把堆里面的倒进另一个堆，剔除出去被取消的，再放回来（这里其实有BUG，可以想一想）

第三步就是暴力遍历（CCF判据一般比较水），把开盘价格从买入价最小遍历到买入价最高，不断刷新成交量即可。

遍历的操作：

设置当前开盘价（当前最低买入价） ——> 刷新可卖出总量 ——> 刷新开盘成交量

有两点需要说明：① 之所以用买入价遍历是因为最终符合条件的一定有 买入价 ≥ 卖出价，取最大就是买入价。

                             ② 更新sum成交量的时候一定要用" ≥ "，因为题目要求相同结果取最大。

下面就是带BUG的AC代码：

#include<iostream>
#include<cstdio>
#include<string>
#include<vector>
#include<queue>
#include<stack>
#include<algorithm>
using namespace std;

#define MAX 5000+5
#define INF 0x3f3f3f3f
#define ll long long
#define LDT priority_queue<GG, vector<GG>, LT>

struct GG{ // 交易
	int num;
	ll sum;
	double price;
};

int fg[MAX];double p = 0; // fg标记是否取消
ll sum1 = 0, sum2 = 0; // 买入量与卖出量

struct LT{ // 优先队列自定义排序函数（小顶）
	bool operator ()(const GG &g1,const GG &g2){
		return g1.price > g2.price;
	}
};

LDT qin; LDT qout; // 买入与卖出堆

void can(LDT &q,bool add){ // 取消-区分是否求加和
	LDT tmp;
	while (!q.empty()){
		GG tg = q.top(); q.pop();
		if (fg[tg.num] != INF) tmp.push(tg);
	}
	while (!tmp.empty()){
		GG tg = tmp.top(); tmp.pop();
		q.push(tg); sum1 += add ? tg.sum : 0;
	}
}

void dooo(){ //总-取消
	LDT tmp;
	can(qin, true);
	can(qout, false);
}

int main(){
	string s; int n = 0;
	while (cin >> s && ++n){ // 读入命令并计数
		if (s == "cancel"){ // 取消操作
			int kn;
			cin >> kn;
			fg[kn] = INF; // 取消，可通过修改这里修复BUG
		}
		else{ // 交易操作
			double pri; ll su;
			cin >> pri >> su; // 读入信息
			GG ng; ng.num = n; // 创建交易实例
			ng.price = pri; ng.sum = su;
			if (s == "buy"){ // 加入买入交易序列
				qin.push(ng);
			}
			else if (s == "sell"){ // 加入卖出交易序列
				qout.push(ng);
			}
			else{ // else
				break; 
			}
		}
	}
	dooo(); // do cancel
	double px; ll sum =0;
	while (!qin.empty()){ // 遍历买入价
		GG ng = qin.top(); qin.pop();
		if (qout.empty()) break;
		while (!qout.empty() && qout.top().price <= ng.price){
			sum2 += qout.top().sum;
			qout.pop();
		} // 所有低于买入价的全部卖出
		if (sum <= min(sum1, sum2)){ // 更新成交量（较小值）
			p = ng.price;
			sum = min(sum1, sum2);
		}
		sum1 -= ng.sum; // 提高买入价
	}
	printf("%.2lf %lld\n", p,sum); // 按格式打印结果
	return 0;
}

然后就是提到的BUG，实际上是这样处理“cancel”操作造成的，想象一下，如果我们取消的是一个取消操作呢.......

当然题目所给的现实情况不存在连环取消的情况，因为操作取消等同于数据删除，但换个前提可能就是一个严重到重写的BUG了.......

这里想要屏蔽这个BUG并不难，只要在cancel输入的时候记录一下：

fg[n] = kn; fg[kn] = INF;
if (fg[kn] == 0) fg[kn] = INF;
else{
	while (fg[kn] != INF) kn = fg[kn];
	fg[kn] = fg[kn] == 0 ? INF : 0;
}

留下索引，按照一直找到根源的操作数，把所指向的交易状态改成相反的就好。