Problem:
Score : 500 points

Problem Statement

Takahashi has a string S of length N consisting of digits from 0 through 9.

He loves the prime number P. He wants to know how many non-empty (contiguous) substrings of S - there are N \times (N + 1) / 2 of them - are divisible by P when regarded as integers written in base ten.

Here substrings starting with a 0 also count, and substrings originated from different positions in S are distinguished, even if they are equal as strings or integers.

Compute this count to help Takahashi.

Constraints

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

S consists of digits.

|S| = N

2 \leq P \leq 10000

P is a prime number.

Input

Input is given from Standard Input in the following format:

N P
S

Output

Print the number of non-empty (contiguous) substrings of S that are divisible by P when regarded as an integer written in base ten.

Sample Input 1

4 3
3543

Sample Output 1

6

Here S = 3543. There are ten non-empty (contiguous) substrings of S:

3: divisible by 3.

35: not divisible by 3.

354: divisible by 3.

3543: divisible by 3.

5: not divisible by 3.

54: divisible by 3.

543: divisible by 3.

4: not divisible by 3.

43: not divisible by 3.

3: divisible by 3.

Six of these are divisible by 3, so print 6.

Sample Input 2

4 2
2020

Sample Output 2

10

Here S = 2020. There are ten non-empty (contiguous) substrings of S, all of which are divisible by 2, so print 10.

Note that substrings beginning with a 0 also count.

Sample Input 3

20 11
33883322005544116655

Sample Output 3

68

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

import java.math.BigInteger;
import java.util.*;

public class Main {
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        TrieNode root = new TrieNode();
        int N = sc.nextInt();
        long P = sc.nextLong();
        String S = sc.next();
        //printAllDivisible(S, P);
        long sum = 0;
        boolean[] visited = new boolean[S.length()+1];
        Arrays.fill(visited, false);
        //System.out.println(getSum(S,root, 11, visited));
        for(int i=0;i<S.length();i++){
            if(visited[i]){continue;}
            sum += getSum(S, root, i, visited, P);
        }
        System.out.println(sum);
    }

    private static void printAllDivisible(String S, long P){
        for(int i=0;i<20;i++){
            for(int j=i+1;j<=20;j++){
                if(j-i <= 18){
                    if(Long.decode(S.substring(i,j)) % P == 0){
                        System.out.println(S.substring(i,j));
                    }
                }
            }
        }
    }

    private static long getSum(String S, TrieNode root, int start, boolean[] visited, long P){
        int now = start;
        long renzoku=0;
        long sum = 0;
        while(now < S.length()){
            int next = root.getWordEnd(S, now, P);
            visited[now] = true;
            if(next == -1){
                sum += renzoku * (renzoku+1) / 2;
                //System.out.println("from " + start + ":" + sum);
                return sum;
            }else{
                renzoku++;
                now = next;
            }
        }
        sum += renzoku * (renzoku+1) / 2;
        //System.out.println("from " + start + ":" + sum);
        return sum;
    }

    private static String toStrFromLong(long val){
        if(val == 0){return "0";}
        String r = new Long(val).toString();
        return r;
    }

    private static class TrieNode{
        TrieNode[] ch = new TrieNode[10];
        boolean isWord = false;
        TrieNode(){
        }

        void setWord(String S){
            if(S.length() == 0){
                isWord = true;
                return;
            }
            int num = S.charAt(0) - '0';
            if(ch[num] == null){
                ch[num] = new TrieNode();
            }
            ch[num].setWord(S.substring(1));
        }

        int getWordEnd(String S, int from, long P){
            long val = S.charAt(from)-'0';
            int ind = from+1;
            while(val % P != 0 && ind < S.length()){
                val -= (val/P)*P;
                val *= 10;
                val += (S.charAt(ind)-'0');
                ind++;
            }
            if(val % P == 0){
                return ind;
            }else{
                return -1;
            }
        }
    }
}