51Nod 数据流中的算法

51nod近日上线了用户满意度检测工具，使用高级人工智能算法，通过用户访问时间、鼠标轨迹等特征计算用户对于网站的满意程度。
现有的统计工具只能统计某一个窗口中，用户的满意程度的均值。夹克老爷想让你为统计工具添加一个新feature，即在统计均值的同时，计算窗口中满意程度的标准差和中位数（均值需要向下取整）。

Input

第一行是整数n与k，代表有n次操作，时间窗口大小为k。
（1 <= n <= 10^6， 1 <= k <= 100）

接下来的n行，每行代表一次操作。操作有“用户访问”、“查询均值”、“查询方差”、“查询中位数”四种。每行的第一个数代表操作类型。

操作数1：用户访问
输入格式：<1, v>
用户的满意度v为闭区间[0, 100]中的任意整数。用户每访问一次，数据更新，移动统计窗口。

操作数2：查询均值
输入格式：<2>
统计窗口内的用户满意度的均值。

操作数3：查询方差
输入格式：<3>
统计窗口内用户满意度的方差

操作数4：查询中位数
输入格式：<4>
统计窗口内用户满意度的中位数

p.s. 在有查询请求时，窗口保证不为空
p.s.s. 有查询请求时，窗口可能不满

Output

对于“查询均值”、“查询方差”、“查询中位数”操作的结果，输出保留两位小数。

Input示例

12 3
1 1
1 2
1 3
2
3
4
1 4
1 5
1 6
2
3
4

Output示例

2.00
0.67
2.00
5.00
0.67
5.00

这道题是水题。我一开始没明白题意，那个k是什么意思。原来k应该理解为只能看到k个人的满意度（最后k个人）。而且时间限制对java很不友好（我怀疑51Nod的机器坏了，居然那么慢，我这边能秒出数据的），我没看到别人有java过的。

我一开始考虑用queue和linkedlist，queue用来控制k个满意度，linkedlist则用来插入排序，方便进行中位数的获取。但是被万恶的51Nod机器判定是TLE了。

import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Node51_6_Dataflow {
	
	public void insertToList(LinkedList<Integer> list,int satisfy){
		Iterator<Integer> it = list.iterator();
		int index = 0;
		while (it.hasNext()) {
			int theNumber = it.next();
			if (theNumber > satisfy) {
				break;
			} else {
				index++;
			}
		}
		list.add(index, satisfy);
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

		Node51_6_Dataflow node=new Node51_6_Dataflow();
		DecimalFormat df = new DecimalFormat("0.00");
		int n = in.nextInt();//操作数
		int k = in.nextInt();//窗口
		Queue<Integer> queue=new LinkedList<Integer>();
		LinkedList<Integer> list=new LinkedList<Integer>();//插入排序的list
		int sum=0;
		int numNow=0;//当前窗口内的满意个数
		for(int i=0;i<n;i++){
			int operation=in.nextInt();
			switch (operation) {
				case 1:
					int satisfy=in.nextInt();
					sum=sum+satisfy;
					numNow++;
					if (queue.size() < k) {
						queue.offer(satisfy);
						node.insertToList(list, satisfy);
					}
					else{
						int removedValue=queue.poll();
						numNow--;
						sum=sum-removedValue;
						list.remove(Integer.valueOf(removedValue));//注意
						queue.offer(satisfy);
						node.insertToList(list, satisfy);
					}
					break;
				case 2:
					int average=(int)Math.floor((double)sum/numNow);
					out.println(df.format(average));
					break;
				case 3:
					double avg=(double)sum/numNow;
					Iterator<Integer> it = list.iterator();
					double sumOfSquare=0;
					while (it.hasNext()) {
						int theNumber = it.next();
						sumOfSquare+=Math.pow((theNumber-avg), 2);
					}
					double biaozhuncha=sumOfSquare/numNow;
					out.println(df.format(biaozhuncha));
					break;
				case 4:
					it = list.iterator();
					double zhongweishu=0;
					if(numNow%2!=0){//当前窗口内有奇数个满意度					
						int index=0;				
						while (it.hasNext()) {
							int theNumber = it.next();
							if(index==numNow/2){
								zhongweishu=theNumber;
								break;
							}
							index++;
						}
					}
					else{
						int index=0; 
						while (it.hasNext()) {
							int theNumber = it.next();
							if(index==numNow/2-1||index==numNow/2){//偶数时，中位数有两个
								zhongweishu+=theNumber;
								if(index==numNow/2){
									break;
								}						
							}
							index++;
						}
						zhongweishu=zhongweishu/2;
					}
					out.println(df.format(zhongweishu));
					break;					
				default:
					break;
			}
		}
		in.close();
		out.flush();
	}
}

需要注意的是list.remove(Integer.valueOf(removedValue));//注意        这一行，为什么不直接list.remove(removedValue)呢？因为removedValue是int类型，会自动默认为调用的是list.remove(index)而非list.remove(object)，所以如果需要在list中删除某个整数而非那个索引上的值，则可以用Integer.valueOf(value)或者 new Integer(value)，而最好还是用Integer.valueOf(value), 因为Integer把-128~127的整数放入了cache，cache中取得的值不需要创建新的对象。具体见 http://www.myexception.cn/program/1293747.html 。

后来发现TLE之后，我就看人家AC的c++代码，按照人家的思路改我的java程序，但是最终还是TLE了，所以我觉得应该是题目对java不友好的问题。使用一个数组来模拟queue，有前指针和后指针来控制k个元素，之所以用数组而不是用真正的queue是方便之后的排序。当然，我觉得也可以直接用int[k]的数组来做，当插入一个值时pointer++，当pointer=k时，重新令pointer=0，继续从0开始覆盖之前数组的元素，因此之前数组的元素就是从0~k过时的，0最老，所以从0开始覆盖。

import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Node51_6_Dataflow {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

		Node51_6_Dataflow node=new Node51_6_Dataflow();
		DecimalFormat df = new DecimalFormat("0.00");
		int n = in.nextInt();//操作数
		int k = in.nextInt();//窗口
		int[] queue=new int[1000001];
		int frontPointer=0;//指向队列第一个元素
		int endPointer=-1;//指向队列最后一个元素
		int sum=0;
		int numNow=0;//当前窗口内的满意个数
		for(int i=0;i<n;i++){
			int operation=in.nextInt();
			switch (operation) {
				case 1:
					int satisfy=in.nextInt();
					if(numNow!=k){
						sum=sum+satisfy;
						numNow++;
						endPointer++;
						queue[endPointer]=satisfy;						
					}
					else{
						sum=sum-queue[frontPointer]+satisfy;
						frontPointer++;
						endPointer++;
						queue[endPointer]=satisfy;
					}
					break;
				case 2:
					int average=(int)Math.floor((double)sum/numNow);
					out.println(df.format(average));
					break;
				case 3:
					double avg=(double)sum/numNow;
					double sumOfSquare=0;
					for(int j=frontPointer;j<=endPointer;j++){
						sumOfSquare+=(queue[j]-avg)*(queue[j]-avg);
					}
					double biaozhuncha=sumOfSquare/numNow;
					out.println(df.format(biaozhuncha));
					break;
				case 4:
					int[] queueCopy=new int[numNow];
					int pointer=0;
					for(int j=frontPointer;j<=endPointer;j++){
						queueCopy[pointer]=queue[j];
						pointer++;
					}
					Arrays.sort(queueCopy);
					double zhongweishu=0;
					if(numNow%2!=0){//当前窗口内有奇数个满意度
						zhongweishu=queueCopy[numNow/2];
					}
					else{//偶数时，中位数有两个
						zhongweishu=(double)(queueCopy[numNow/2-1]+queueCopy[numNow/2])/2;
					}
					out.println(df.format(zhongweishu));
					break;					
				default:
					break;
			}
		}
		in.close();
		out.flush();
	}
}