座位问题

时间限制: 10000ms

单点时限: 1000ms

内存限制: 256MB

描述

给定包含N个整数的数组A1, A2, ... AN，你可以选择任意一个Ai，将Ai旋转到数组第一项，即将数组变成：

Ai, Ai+1, Ai+2, ... AN, A1, A2, ..., Ai-1  

现在小Hi希望旋转之后的数组满足：

对于任意K(1 ≤ i ≤ N)，前K项的和都是正数。  

例如对于A=[3, -5, 2, -2, 3, 0]，旋转成[3, 0, 3, -5, 2, -2]满足条件。  

请你输出i，代表将Ai旋转到第一项满足条件。  

如果有多解，你可以输出任意一个i。如果无解输出-1。

输入

第一行包含一个整数N。  

第二行包含N个整数A1, A2, ... AN。  

对于50%的数据，1 ≤ N ≤ 1000  

对于100%的数据，1 ≤ N ≤ 100000, -1000000 ≤ Ai ≤ 1000000

输出

一个整数表示答案。

样例输入

6  
3 -5 2 -2 3 0

样例输出

5

如果用遍历，最起码也是100000*1000差不多执行一亿次。所以不能使用。

从题目上看，是通过条件进行判断，也就是一道实现逻辑的题。

想到存储一些数据信息来进行判断，从而降低执行次数。

使用的排序算法是优先队列。

import java.util.ArrayList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;


public class Main {

	public static void main(String args[]){
		Main test=new Main();
		test.start();
	}
	public void start(){
		Scanner scan=new Scanner(System.in);
		int N=scan.nextInt();
		int M=scan.nextInt();
		int K=scan.nextInt();
		ArrayList<Integer> list=new ArrayList<Integer>();
		int array[]=new int[N+2];
		for(int i=0;i<M;i++){
			int a=scan.nextInt();
			array[a]=-1;
		}
		Queue<B> queue=new PriorityQueue<B>();
		int isK=0;
		int start=0;
		for(int i=1;i<N+2;i++){
			
			if(array[i]==-1){
				
					
				int end=i-start-1;
				if(end>0){
					queue.offer(new B(start,end));
				}
				
					
				
				start=i;
				
			}
			if(i==N+1&&array[N+1]==0){
				int end=i-start-1;
				if(end>0){
					queue.offer(new B(start,end));
				}
			}
			
		}
		for(int i=0;i<K;i++){
			B b=queue.poll();
			int index2=(int) (b.start+Math.ceil(b.length/(double)2));
			
			System.out.println(index2);
			int end1=index2-b.start-1;
			
			int end2=(b.start+b.length+1)-index2-1;
			
			if(end1>0){
				queue.offer(new B(b.start,end1));
			}
			if(end2>0){
				queue.offer(new B(index2,end2));
			}
		}
	}
	class B implements Comparable<B>{
		
		public B(int start, int length) {
			super();
			this.start = start;
			this.length = length;
		}
		int start;
		int length;
		@Override
		public int compareTo(B o) {
			if(length>o.length){
				return -1;
			}else{
				if(length<o.length){
					return 1;
				}else{
					if(start<o.start){
						return -1;
					}else{
						return 1;
					}
				}
			}
			
		}
		
	}
}