万万没想到之抓捕孔连顺

import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String input1[] = in.nextLine().split(" ");
        int n =Integer.parseInt(input1[0]);
        int d =Integer.parseInt(input1[1]);
        input1 = in.nextLine().split(" ");
        //int arr[] = new int[input1.length];
        TreeMap<Integer,Integer> map  = new TreeMap<Integer, Integer>();
        //TreeSet<Integer> set = new TreeSet<>();
        for (int i=0;i<input1.length;i++){
            //arr[i]=Integer.parseInt(input1[i]);
            int num = Integer.parseInt(input1[i]);
            if (map.containsKey(num)){
                continue;
            }
            map.put(num,i);
        }
        long res= 0;
        Set<Integer> set = map.keySet();
        int begin = 0;
        for (Integer integer : set) {
            if (begin>=n-2){
                break;
            }
            int limit = integer+d;
            Integer floor = map.floorKey(limit);
            Integer index = map.get(floor);
            res+=((index-begin)*(index-begin-1))/2;
            res%=99997867;
            begin++;
        }
        System.out.println(res);
    }
}

考点：排列组合，同时利用“定一计算二”的方式即可，即总共只有三个数字去排列，所以可以将最右边的固定下，左边两位通过组合的计算公式就可以得出，当然左边两位的边界还需要进行一些判断

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long num = in.nextInt();
        if(num<3){
            System.out.println(0);
            return;
        }
        int dis = in.nextInt();
        List arr = new ArrayList();
        int i=0;
        while(i++<num) {
            arr.add(in.nextInt());
        }
        int left = 0;
        int right = 2;
        long count = 0;

        while(right != num){
            int curDis = arr.get(right)-arr.get(left);
            if(curDis <= dis) {
                if(right-left > 1){
                    count+=C(right-left);
                    right++;
                } else{
                    right++;
                }

            }else if(curDis > dis){
                if(right-left > 1){
                    left++;
                } else{
                    break;
                }
            }
        }
        System.out.print(count%99997867L);

    }

    public static long C(long num){
        if(num == 2)return 1L;
        return num*(num-1)/2;
    }

}

import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n, d;
        n = sc.nextInt();
        d = sc.nextInt();
        int[] a = new int[n+1];
        for (int i = 0 ; i < n; i++){
            a[i] = sc.nextInt();
        }
        // 从左到右会超时，因为右节点有回头，每一次都需要j重置到i+1的位置。
        // run_left(n, d, a);
        // 改用从右到左判断，i每次向后移，j必定在当前值的基础上进行移动。即以最右边的节点作为“定点”
        run_right(n, d, a);
    }
    
    public static void run_right(int n, int d, int[] a) {
        Long result = 0L;
        for (int i = 2, j = 0 ; i < n; i++){
            while(a[i] - a[j] > d) {
                // 因为即使 a[i] - a[i-1] >d, 当j==i 的时候，不满足 a[i] - a[j] > d 的条件
                // 所以这里不会使 j > i
                j++;
            }
            // 两者想乘可能会 超过 int 的返回，导致结果为负，输出的结果错误
            result += ((long)(i-j)*(long)(i-j-1)/2);
        }
        System.out.println(result % 99997867);
    }
    
    public static void run_left(int n, int d, int[] a) {
        Long result = 0L;
        for (int i = 0 ; i < n-2; i++){
            int j = i + 1;
            while(j+1 < n && a[j+1] - a[i] <= d) {
                j++;
            }
            result += ((j-i)*(j-i-1)/2);
        }
        System.out.println(result % 99997867);
    }
}

import java.util.Scanner;
 public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int d = scanner.nextInt();
        int n=scanner.nextInt();
        int [] a=new int[d];
        for (int i = 0; i < d; i++) {
            a[i]=scanner.nextInt();
        }
        //定义计数器
        int count=0;
        //遍历,1号位定位
        for (int i = 0; i <d-2 ; i++) {
            //遍历,2号位定位
            for(int j=i+1;j<d-1;j++){
                //三号位,
                for (int k=j+1;k<d;k++){
                    if (a[k]-a[i]<=n){
                        count++;
                    }
                }
            }
        }
        System.out.println(count%99997867);
    }

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int N = input.nextInt();
        int D = input.nextInt();
        int[] L = new int[N];
        for(int i = 0; i < N; i ++)
        	L[i] = input.nextInt();
        input.close();
        System.out.println(Solution(N, D, L));
    }
    
    public static long Solution(int N, int D, int[] L) {
    	final int MOD = 99997867;
    	long sum = 0;
    	int i = 0;
    	int j = 2;
    	while(j < N) {
    		if(L[j] - L[i] > D)
    			i ++;
    		else if(j - i < 2)
    			j ++;
    		else {
    			sum += Sum(j-i-1);
    			j ++;
    		} 		
    	}
    	return sum%MOD;  	
    }
    
    public static long Sum(long n) {
		return (1+n)*n/2;   	
    }
}