Problem:
Score : 500 points

Problem Statement

Given are a sequence of N positive integers A_1, A_2, \ldots, A_N, and a positive integer K.

Find the number of non-empty contiguous subsequences in A such that the remainder when dividing the sum of its elements by K is equal to the number of its elements. We consider two subsequences different if they are taken from different positions, even if they are equal sequences.

Constraints

All values in input are integers.

1 \leq N \leq 2\times 10^5

1 \leq K \leq 10^9

1 \leq A_i \leq 10^9

Input

Input is given from Standard Input in the following format:

N K
A_1 A_2 \cdots A_N

Output

Print the number of subsequences that satisfy the condition.

Sample Input 1

5 4
1 4 2 3 5

Sample Output 1

4

Four sequences satisfy the condition: (1), (4,2), (1,4,2), and (5).

Sample Input 2

8 4
4 2 4 2 4 2 4 2

Sample Output 2

7

(4,2) is counted four times, and (2,4) is counted three times.

Sample Input 3

10 7
14 15 92 65 35 89 79 32 38 46

Sample Output 3

8

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        // Your code here!
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[] array = new int[n];
        for (int i = 0; i < n; i++) {
            array[i] = sc.nextInt();
        }
        
        // ans: 連続部分列の和がmod kで要素数になるi, jのパターン数
        long ans = 0;
        
        // 式変形
        // ・連続部分列の和がmod kで要素数になるi, j
        // -> (s[j+1] - s[i]) % k = j+1 - i
        // -> s[j+1]%k - s[i]%k = j+1 - i
        // -> (左辺はmod kの世界、0～k-1の値しか取らない)
        // -> (移項はmod kにならないと無理)
        // -> s[j+1]%k - (j+1)%k = s[i]%k - i%k (j+1-iはk未満)
        // -> s2[j+1] = s2[i] (j+1-iはk未満) のパターン数
        
        // s: 累積和 (mod k)
        long[] s = new long[n+1];
        for (int i = 0; i < n; i++) {
            s[i+1] = (s[i] + array[i]) % k;
        }
        // System.out.println(Arrays.toString(s));
        
        // s2: 累積和 - 要素番号 (mod k)
        long[] s2 = new long[n+1];
        for (int i = 0; i <= n; i++) {
            s2[i] = s[i] - i;
            while (s2[i] < 0) {
                s2[i] += k;
            }
        }
        // System.out.println(Arrays.toString(s2));
        
        // i, jのパターン数を数え上げる
        Map<Long, Integer> map = new HashMap<Long, Integer>();
        for (int i = 0; i <= n; i++) {
            long key = s2[i];
            int cnt = map.getOrDefault(key, 0);
            
            // 「条件:j+1-iはk未満」
            // -> 区間の長さk-1分までしか見れない
            // -> k個前の要素は随時捨てる
            if (i+1 - k >= 0) {
                long outkey = s2[i+1 - k];
                int val = map.getOrDefault(outkey, 0);
                map.put(outkey, --val);
            }
            
            ans += cnt;
            map.put(key, ++cnt);
        }
        System.out.println(ans);
    }
}