Codeforces 852B Neural Network country

B. Neural Network country

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Due to the recent popularity of the Deep learning new countries are starting to look like Neural Networks. That is, the countries are being built deep with many layers, each layer possibly having many cities. They also have one entry, and one exit point.

There are exactly L layers, each having N cities. Let us look at the two adjacent layers L1 and L2. Each city from the layer L1 is connected to each city from the layer L2 with the traveling cost cij for , and each pair of adjacent layers has the same cost in between their cities as any other pair (they just stacked the same layers, as usual). Also, the traveling costs to each city from the layer L2are same for all cities in the L1, that is cij is the same for , and fixed j.

Doctor G. needs to speed up his computations for this country so he asks you to find the number of paths he can take from entry to exit point such that his traveling cost is divisible by given number M.

Input

The first line of input contains N (1 ≤ N ≤ 106), L (2 ≤ L ≤ 105) and M (2 ≤ M ≤ 100), the number of cities in each layer, the number of layers and the number that travelling cost should be divisible by, respectively.

Second, third and fourth line contain N integers each denoting costs 0 ≤ cost ≤ M from entry point to the first layer, costs between adjacent layers as described above, and costs from the last layer to the exit point.

Output

Output a single integer, the number of paths Doctor G. can take which have total cost divisible by M, modulo 109 + 7.

Example

input

2 3 13
4 6
2 1
3 4

output

2

Note

This is a country with 3 layers, each layer having 2 cities. Paths , and  are the only paths having total cost divisible by 13. Notice that input edges for layer cities have the same cost, and that they are same for all layers.

题意：有L层的城市，每层有N个城市，每个第i层可以到i+1层的所有城市，每一层的城市只能到相邻层的城市，层中移动的花费为终点的权值，所有层的第i个城市的权值都是相同的，另外会有一个起点和终点，告诉你起点和终点到第一层和最后一层的N个城市的花费，以及一层中的N个城市的权值，然后问你从起点到终点的花费能被M整除的路径数，答案对1e9+7取模

题解：中间层中的移动都是一样的操作，可以把这N个城市缩成一个M位的数字，代表取模为0~M-1的路径数，所以可以用快速幂完成中间的计算，起点直接乘，终点的话要和最后一层连在一起，再乘上去，中间是计算L-2次的快速幂

代码：

#include<stdio.h>
#include<algorithm>
#include<string.h>
#define N 1000005
using namespace std;
typedef long long ll;
const int M=1e9+7;
struct node{
    ll a[101];
};
int m;
node mul(node a,node b)
{
    node c;
    memset(c.a,0,sizeof(c.a));
    for(int i=0;i<m;i++)
        for(int j=0;j<m;j++)
            (c.a[(i+j)%m]+=a.a[i]*b.a[j]%M)%=M;
    return c;
}
node quick(node a,int b)
{
    node c;
    memset(c.a,0,sizeof(c.a));
    c.a[0]=1;
    while(b)
    {
        if(b&1)c=mul(c,a);
        a=mul(a,a);
        b>>=1;
    }
    return c;
}
int ct[N];
int main ()
{
    int n,l;
    node s,a,e;
    memset(s.a,0,sizeof(s.a));
    memset(a.a,0,sizeof(a.a));
    memset(e.a,0,sizeof(e.a));
    scanf("%d%d%d",&n,&l,&m);
    for(int i=1;i<=n;i++){
        int x;
        scanf("%d",&x);
        s.a[x%m]++;
    }
    for(int i=1;i<=n;i++){
        scanf("%d",&ct[i]);
        a.a[ct[i]%m]++;
    }
    for(int i=1;i<=n;i++){
        int x;
        scanf("%d",&x);
        e.a[(x+ct[i])%m]++;
    }
    s=mul(s,e);
    if(l>2)s=mul(s,quick(a,l-2));
    printf("%lld\n",s.a[0]);
    return 0;
}