CSP201412_3(集合竞价)(Java100分)

问题描述
　　某股票交易所请你编写一个程序，根据开盘前客户提交的订单来确定某特定股票的开盘价和开盘成交量。
　　该程序的输入由很多行构成，每一行为一条记录，记录可能有以下几种：
　　1. buy p s 表示一个购买股票的买单，每手出价为p，购买股数为s。
　　2. sell p s 表示一个出售股票的卖单，每手出价为p，出售股数为s。
　　3. cancel i表示撤销第i行的记录。
　　如果开盘价为p0，则系统可以将所有出价至少为p0的买单和所有出价至多为p0的卖单进行匹配。因此，此时的开盘成交量为出价至少为p0的买单的总股数和所有出价至多为p0的卖单的总股数之间的较小值。
　　你的程序需要确定一个开盘价，使得开盘成交量尽可能地大。如果有多个符合条件的开盘价，你的程序应当输出最高的那一个。
输入格式
　　输入数据有任意多行，每一行是一条记录。保证输入合法。股数为不超过108的正整数，出价为精确到恰好小数点后两位的正实数，且不超过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。

---

**思路：**先写一个股票类。然后一个buy数组和一个sell数组。 另外需要一个boolean 类型的数组。
输入数据时有人可能遇到过使用hasNextLine()程序一直等待，无法结束的情况，我也遇到了，然后百度以后用以下代码解决：

 while (sc.hasNextLine()) {
            String s = sc.nextLine();
            if (s.trim().length() == 0) {
                break;
            }
}

我也不知道为什么这样就可以。
然后就是对buy数组和sell数组重小到大排序。
如果开盘价为x时，计算 开盘成交量为出价至少为p0的买单的总股数和所有出价至多为p0的卖单的总股数之间的较小值。 然后和结果比较 。然后如果这个大，就替换掉结果。。说的可能有点乱，你们直接看代码吧。

另一个我遇到的bug就是实现Comparable接口时，没有写价格相等的时候，返回0

if (price < o.price) {
			return -1;
		}  else {
			return 1;
		}
｝

运行时只有80分，提示运行错误。
最后改成：

public int compareTo(Stock o) {
		// TODO Auto-generated method stub
		if (price < o.price) {
			return -1;
		} else if (price == o.price) {
			return 0;
		} else {
			return 1;
		}
	}

然后就100分了。

这个原因就是如果输入的价格都相等的时候 ，无法排序，然后抛出异常造成的。

下面是代码：

---

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Scanner;

public class Main{

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		// new BufferedInputStream(
		int num = 1;
		boolean isCancel[] = new boolean[5005];
		for (int i = 0; i < isCancel.length; i++) {
			isCancel[i] = false;
		}
		Stock buy[] = new Stock[5005];
		Stock sell[] = new Stock[5005];
		int buyNum = 0;
		int sellNum = 0;
		while (sc.hasNextLine()) {
			String s = sc.nextLine();
			if (s.trim().length() == 0) {
				break;
			}
			if (s.contains("buy")) {
				buy[buyNum++] = new Stock(num++, Float.parseFloat(s.split(" ")[1]), Long.parseLong(s.split(" ")[2]));
			} else if (s.contains("sell")) {
				sell[sellNum++] = new Stock(num++, Float.parseFloat(s.split(" ")[1]), Long.parseLong(s.split(" ")[2]));

			} else if (s.contains("cancel")) {
				isCancel[Integer.parseInt(s.split(" ")[1])] = true;
				num++;
			}
		}
		Arrays.sort(buy, 0, buyNum);
		Arrays.sort(sell, 0, sellNum);
		int indexBuy = buyNum - 1;
		float resultPrice = 0;
		long resultNum = 0;
		long tempNumBuy = 0;
		while (indexBuy >= 0) {
			if (!isCancel[buy[indexBuy].id]) {
				float tempPrice = buy[indexBuy].price;
				tempNumBuy += buy[indexBuy].num;
				long tempNumSell = 0;
				for (int i = 0; i < sellNum; i++) {
					if ((!isCancel[sell[i].id]) && sell[i].price <= tempPrice) {
						tempNumSell += sell[i].num;
					}
				}
				long tempResultNum = Math.min(tempNumBuy, tempNumSell);
				if (tempResultNum > resultNum) {
					resultPrice = tempPrice;
					resultNum = tempResultNum;
				}
			} else {

			}
			indexBuy--;
		}
		System.out.printf("%5.2f  ", resultPrice);
		System.out.println(resultNum);

	}

}

class Stock implements Comparable<Stock> {
	int id;
	float price;
	long num;

	public Stock(int id, float price, long num) {
		super();
		this.id = id;
		this.price = price;
		this.num = num;
	}

	@Override
	public int compareTo(Stock o) {
		// TODO Auto-generated method stub
		if (price < o.price) {
			return -1;
		} else if (price == o.price) {
			return 0;
		} else {
			return 1;
		}
	}

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "  id:" + id + " price:" + price + " num:" + num;
	}

}