时间限制:
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;
}
}
}
}
}
}