数列 - Sequence - Indexed Tree
作者：互联网
数列
测试用例总数：40 个用例，1.5 秒 (C/C++)，2 秒 (JAVA)
当前有一组包含N个数字的数列。当从数列中选取几个连续的数字时，想在这些选择的数字中创建最小值和最大值差为K的子数列。请求出最大值和最小值差为K的子数列中长度为最短的情况。
下面案例是从包含10个数的数列中找出K为10的子数列。
为方便起见，数列的第一个数字开始定义为 index 1, index 2, …, index 10
当选择Index 1到5时，最大值为11，最小值为1，满足差值为K的要求，并且长度为 5。当选择Index 5到8时，最大值为21，最小值为11，满足差值为K的要求，并且长度为4。这是满足条件的最短的子数列。
给出数组大小N和最大值与最小值之差K，以及数组的值时，请找出可选择的最短长度子数列和长度最短的子数列个数。如果不存在这种情况，则输出 -1。
[限制条件]
1.数字个数N为介于1到100,000之间的整数。
2.各数值为介于1到1,000,000,000之间的整数。
3.最大值与最小值之差K为介于1到1,000,000,000之间的整数。
4.一个数列中的数值不存在重复的情况。
[输入]
首先给出测试用例数量T，接着给出T种测试用例。每个测试用例的第一行空格区分给出数字个数N，以及最大值与最小值之差K。第二行空格区分给出N个数值。
[输出]
每个测试用例输出一行。各测试用例都输出“#x”（其中x表示测试用例编号，从1开始），隔一个空格后，请输出满足最大值与最小值之差为K的子数列中，长度最短的子数列长度和长度最短的子数列的个数。如果没有满足最大值与最小值之差为K的子数列，则输出 -1。
[输入输出 示例]
(输入)
4
10 10
1 7 2 5 11 17 13 21 3 6
8 3
6 1 2 4 3 5 9 7
4 10
7 2 4 3
12 100
2 49 1 90 51 101 149 151 112 152 113 222
(输出)
#1 4 1
#2 3 1
#3 -1
#4 4 2
思路分析：
要求区间最大值、最小值，首先考虑Indexed Tree
如果逐个去查寻最大值最小值并求差值，数据量为10W，效率肯定过不去，因此需要反向思维，即数据从小到大排序后，逐个找当前数+K的数（有序，可使用二分查找）
如果当前数+K存在，则去原数组中，找两个数之间的最大值与最小值，如果最大值=当前数+K且最小值=当前数，则此区间是区满足题目条件的区间
package tree;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
/**
* 思路：要求区间最大值、最小值，首先考虑Indexed Tree
* 如果逐个去查寻最大值最小值并求差值，数据量为10W，效率肯定过不去，因此需要反向思维，即数据从小到大排序后，逐个找当前数+K的数（有序，可使用二分查找）
* 如果当前数+K存在，则去原数组中，找两个数之间的最大值与最小值，如果最大值=当前数+K且最小值=当前数，则此区间是区满足题目条件的区间
* @author XA-GDD
*
*/
public class EQ_Sequence_0329 {
static int T,N, K;
static int _max_Nval = 100000;
static Node []srcArr = new Node[_max_Nval];
static long[] maxIdxTree = new long[_max_Nval*4]; //最大值Indexed Tree
static long [] minIdxTree = new long[_max_Nval*4]; //最小值Indexed Tree
static int offset;
static int seqLength;
static int seqCnt;
public static void main(String[] args) throws IOException {
System.setIn(new FileInputStream("D:\\workspace\\sw_pro\\sample_input_0329.txt"));
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
T = Integer.parseInt(st.nextToken());
for(int testCase = 1; testCase<=T;testCase++) {
st = new StringTokenizer(br.readLine());
N = Integer.parseInt(st.nextToken());
K = Integer.parseInt(st.nextToken());
//初始化Tree
int k=0;
while((1<<k)<N) {
k++;
}
offset = 1<<k;
Arrays.fill(maxIdxTree, Long.MIN_VALUE);
Arrays.fill(minIdxTree, Long.MAX_VALUE>>1);
Arrays.fill(srcArr, null);
seqLength = Integer.MAX_VALUE;
seqCnt = 0;
st = new StringTokenizer(br.readLine());
for(int i=0;i<N;i++) {
srcArr[i] = new Node(i,Integer.parseInt(st.nextToken()));
//将原数组更新到Tree上
update(offset+i,srcArr[i].val);
}
//将原数组按照从小到大排序
Arrays.sort(srcArr, 0, N);
for(int i=0;i<N;i++) {
//按照排序后的顺序，使用二分查找，逐个找当前数+K的数
int idx = Arrays.binarySearch(srcArr, 0, N, new Node(0,srcArr[i].val+K));
if(idx>0) {
int left = (int) Math.min(srcArr[i].idx, srcArr[idx].idx); //两个数在原数组靠前的，在tree中的位置靠左
int right = (int) Math.max(srcArr[i].idx, srcArr[idx].idx); //两个数在原数组靠后的，在tree中的位置靠右
//如果最大值=当前数+K且最小值=当前数，则此区间是区满足题目条件的区间
if(query(left+offset,right+offset,srcArr[i].val,srcArr[i].val+K)) {
int length = right-left+1;
if(length==seqLength) {
seqCnt++;
}else if(length<seqLength) {
seqLength = length;
seqCnt=1;
}
}
}
}
if(seqCnt==0) {
System.out.printf("#%d %d\n",testCase,-1);
}else {
System.out.printf("#%d %d %d\n",testCase,seqLength,seqCnt);
}
}
}
static void update(int index , long value) {
maxIdxTree[index] = value;
minIdxTree[index] = value;
index = index >> 1;
while(index>0) {
maxIdxTree[index] = Math.max(maxIdxTree[index*2], maxIdxTree[index*2+1]);
minIdxTree[index] = Math.min(minIdxTree[index*2], minIdxTree[index*2+1]);
index = index >> 1;
}
}
static boolean query(int start, int end, long leftVal, long rightVal) {
long minVal = Long.MAX_VALUE>>1;
long maxVal = Long.MIN_VALUE;
while(start<=end) {
if(start%2==1){
minVal = Math.min(minVal, minIdxTree[start]);
maxVal = Math.max(maxVal, maxIdxTree[start]);
}
if(end%2==0){
minVal = Math.min(minVal, minIdxTree[end]);
maxVal = Math.max(maxVal, maxIdxTree[end]);
}
start = (start+1)>>1;
end = (end-1)>>1;
}
return minVal == leftVal && maxVal == rightVal;
}
static class Node implements Comparable<Node>{
int idx;
int val;
Node(int idx , int val){
this.idx = idx;
this.val = val;
}
@Override
public int compareTo(Node o) {
return this.val - o.val;
}
}
}
标签：index,数列,Sequence,int,最大值,Tree,最小值,static,Indexed 来源： https://www.cnblogs.com/smile_to_warm/p/15184625.html