集合竞价-CCF往届题（90分，系统显示WA）

题记：这道题就此打住，再也不去做优化，刷分了。

分析：

1.需要这道题需要将数据先暂时保存起来，后面根据局cancel的情况，决定那些行有效（最坑的一点）；

2.目标是要找出最大化交易量的最高价格，那么这个最大价格肯定在buy的离散价格里面，因为抛出的价格要小于等于买入价格才能成交；

3.遍历买入价格，寻找当前价格下最大成交量，循环更新最大成交量和价格。

有几个坑：

1.关于Java在刷题时的效率问题，不要随随便便就上On2的代码。在提交时有一次90分超时的情况出现，是因为在最后遍历寻找最优成交量时用了On2遍历；将内循环优化后，即避免每次都从最小抛出价格开始遍历（保存上一次内循环的index位置）后，成功去掉了程序超时的困扰。

2.题目自身表达不清：未说明cancel的作用范围，是否存在cancel嵌套的情况。

3.保存交易量一定不能选择int类型，简单算一下4个字节够不够存就知道啦

下方的代码对cancel功能处理为：每次由后来的cancel输入将cancel所指示的那一行的可用性取反（初始都是可用），直到嵌套指示的那一行不是cancel语句为止。

如有不妥，还请看官指正！

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

import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Scanner;
import java.util.ArrayList;

public class Main{
	static HashMap<Double,Integer> buy=new HashMap<Double,Integer>(5000);
	static HashMap<Double,Integer> sell=new HashMap<Double,Integer>(5000);
	static ArrayList<trade> Nbuy=new ArrayList<trade>(5000);
	static ArrayList<trade> Nsell=new ArrayList<trade>(5000);

	static String inputrecord[]=new String[5001];
	static boolean youxiao[]=new boolean[5001];

	public static void main(String[] args){
		Scanner in=new Scanner(System.in);
		int index=1;
		while(in.hasNext()){
			inputrecord[index]=in.nextLine();
			youxiao[index]=true;
			//if(inputrecord[index].equals("f"))break;
			index++;
		}
		in.close();

		int indexbuy=0,indexsell=0;
		double sumbuy=0,sumsell=0;
		for(int i=index-1;i>0;i--){
			if(youxiao[i]==true){
				String[] input=inputrecord[i].split(" ");
				
				if(input[0].equals("cancel")){

					int nx=Integer.parseInt(input[1]);//yingshe dao child line
					
					while(true){
						String te[]=inputrecord[nx].split(" ");//child line data
						if(!te[0].equals("cancel")){
							if(youxiao[nx]==true){
								youxiao[nx]=false;
								break;
							}
							else break;		
						}
						else{
							if(youxiao[nx]==true){
								youxiao[nx]=false;
								nx=Integer.parseInt(te[1]);
							}
							else break;
						}
					}
				}else{

					double price=Double.parseDouble(input[1]);
					double num=Double.parseDouble(input[2]);

					if(input[0].equals("buy")){
						sumbuy+=num;
						if(buy.containsKey(price)){
							int ind=buy.get(price);
							Nbuy.set( ind,new trade(price,Nbuy.get(ind).num+num) );
						}else{
							Nbuy.add(indexbuy,new trade(price,num) );
							indexbuy++;
						}
					}else{
						sumsell+=num;
						if(sell.containsKey(price)){
							int ind=sell.get(price);
							Nsell.set( ind,new trade(price,Nsell.get(ind).num+num) );
						}else{
							Nsell.add(indexsell,new trade(price,num) );
							indexsell++;
						}
					}
				}
			}

		}

		Comparator<trade> comparator=new Comparator<trade>(){
			public int compare(trade s1,trade s2){
				return (s1.price>s2.price)?1:(s1.price==s2.price?0:-1);
			}
		};
		Collections.sort(Nbuy,comparator);
		Collections.sort(Nsell,comparator);

		double less=0,above=sumbuy;
		//above==bigger and equals
		//less== smaller
		for(int i=0;i<Nbuy.size();i++){
			Nbuy.get(i).less=less;
			Nbuy.get(i).above=above;
			less+=Nbuy.get(i).num;
			above-=Nbuy.get(i).num;
		}

		//above==bigger
		//less== smaller and equals
		less=0;
		above=sumsell;
		for(int i=0;i<Nsell.size();i++){
			less+=Nsell.get(i).num;
			above-=Nsell.get(i).num;
			Nsell.get(i).less=less;
			Nsell.get(i).above=above;
		}

		double dealnum=0;
		double dealprice=0;
		for(int i=0,j=0;i<Nbuy.size();i++){
			while(true){
				if(Nbuy.get(i).price>=Nsell.get(j).price){
					if(Math.min(Nbuy.get(i).above, Nsell.get(j).less)>dealnum){
						dealprice=Nbuy.get(i).price;
						dealnum=Math.min(Nbuy.get(i).above, Nsell.get(j).less);
					}else if(Math.min(Nbuy.get(i).above, Nsell.get(j).less)==dealnum){
						if(Nbuy.get(i).price>dealprice){
							dealprice=Nbuy.get(i).price;
						}
					}
					if(j<Nsell.size()-1)j++;
					else break;
				}else break;
			}
		}
		

		if(Nbuy.size()==0&&Nsell.size()==0){
			System.out.printf("%.2f %.0f",0.0,dealnum);
			return;
		}
		if(Nbuy.size()==0){
			System.out.printf("%.2f %.0f",Nsell.get(Nsell.size()-1).price,dealnum);
			return;
		}
		if(Nsell.size()==0){
			System.out.printf("%.2f %.0f",Nbuy.get(Nbuy.size()-1).price,dealnum);
			return;
		}
		if(dealprice==0)System.out.printf("%.2f %.0f",Math.max(Nbuy.get(Nbuy.size()-1).price, Nsell.get(Nsell.size()-1).price),dealnum);
		else System.out.printf("%.2f %.0f",dealprice,dealnum);
	}
}

class trade{
	double price=0;
	double num=0;
	double less=0;
	double above=0;
	public trade(double price,double num){
		this.price=price;
		this.num=num;
	}
}