集合竞价 CCF java实现 （大部分代码是借鉴的别人的，）

（只是把借鉴代码完善成100分了，分享给大家）

问题描述 　　某股票交易所请你编写一个程序，根据开盘前客户提交的订单来确定某特定股票的开盘价和开盘成交量。
　　该程序的输入由很多行构成，每一行为一条记录，记录可能有以下几种：
　　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。
时间要求为1.0 S，内存要求为256M

具体代码实现：

import java.io.BufferedInputStream;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

class StockArray{          
    String SBC;
    float price;
    long number;
}

public class Stocks {
 public static void main(String[] args){

     

        Scanner scanner=new Scanner(new BufferedInputStream(System.in));

        StockArray[] ss=new StockArray[5002];
        for (int i = 0; i < 5002; i++) {
            ss[i]=new StockArray();
        }

        int num=1;
        while(scanner.hasNextLine()){
         
            String a = scanner.nextLine();
          
            if(a.trim().length()==0)
            {
             break;
            }

           
            String []b = a.split(" ");
            ss[num].SBC=b[0];
            if (ss[num].SBC.equals("buy")||ss[num].SBC.equals("sell")) {
                ss[num].price=Float.parseFloat(b[1]);
                ss[num].number=Long.parseLong(b[2]);
            }else if (ss[num].SBC.equals("cancel")) {
                ss[(int) Long.parseLong(b[1])].SBC="CANCEL";
            }
           
           

            num++; 
        }
        scanner.close();
      

        StockArray[] n1=new StockArray[num];
        for (int i = 0; i < num; i++) {
            n1[i]=new StockArray();
        }

        StockArray[] n2=new StockArray[num]; 
        for (int i = 0; i < num; i++) {
            n2[i]=new StockArray();
        }

        int num1=0;
        int num2=0;
        long ans_num=0;
        float ans_price=0;

        for(int i=1;i<num;i++){
            if (ss[i].SBC.equals("buy")) {
                n1[num1].price=ss[i].price;
                n1[num1].number=ss[i].number;
                num1++;
            }
            if (ss[i].SBC.equals("sell")) { 
                n2[num2].price=ss[i].price;
                n2[num2].number=ss[i].number;
                num2++;
            }
        }

        Arrays.sort(n1,0,num1,new MyComprator1());
        Arrays.sort(n2,0,num2,new MyComprator2());

        long sum1=0, sum2;
        float p;
        for (int i = 0; i < num1; i++) {
            p=n1[i].price;
            sum1+=n1[i].number;
            sum2=0;
            for (int j = 0; j < num2; j++) {
                if (n2[j].price>n1[i].price)
                    break;
                    sum2+=n2[j].number;
            }

            long min_sum=Math.min(sum1, sum2);

            if (ans_num<min_sum) {
                ans_num=min_sum;
                ans_price=p;
            }
        }

     
       
        System.out.printf("%.2f",ans_price);
        System.out.printf(" "+ans_num);

       

      
    }

}

class MyComprator1 implements Comparator<Object>{
    public int compare(Object o1, Object o2){
        StockArray s1=(StockArray)o1;
        StockArray s2=(StockArray)o2;

        if (s1.price!=s2.price) {
            return s2.price>s1.price ? 1: -1;
        }else {
            return s2.number>s1.number ? 1:-1;
        }      
    }
}

class MyComprator2 implements Comparator<Object>{
    public int compare(Object o1, Object o2){
        StockArray s1=(StockArray)o1;
        StockArray s2=(StockArray)o2;
        if (s1.price!=s2.price) {
            return s1.price>s2.price ? 1: -1;
        }else {
            return s1.number>s2.number ? 1:-1;
        }  
    }
   

}