UVA 10870 Recurrences

Recurrences

Consider recurrent functions of the following form:

f(n) = a₁ f(n - 1) + a₂ f(n - 2) + a₃ f(n - 3) + ... + a_d f(n - d), for n > d.
a₁, a₂, ..., a_d - arbitrary constants.

A famous example is the Fibonacci sequence, defined as: f(1) = 1, f(2) = 1, f(n) = f(n - 1) + f(n - 2). Here d = 2, a₁ = 1, a₂ = 1.

Every such function is completely described by specifying d (which is called the order of recurrence), values of d coefficients: a₁, a₂, ..., a_d, and values of f(1), f(2), ..., f(d). You'll be given these numbers, and two integers n and m. Your program's job is to compute f(n) modulo m.

Input

Input file contains several test cases. Each test case begins with three integers: d, n, m, followed by two sets of d non-negative integers. The first set contains coefficients: a₁, a₂, ..., a_d. The second set gives values of f(1), f(2), ..., f(d).

You can assume that: 1 <= d <= 15, 1 <= n <= 2³¹ - 1, 1 <= m <= 46340. All numbers in the input will fit in signed 32-bit integer.

Input is terminated by line containing three zeroes instead of d, n, m. Two consecutive test cases are separated by a blank line.

Output

For each test case, print the value of f(n) (mod m) on a separate line. It must be a non-negative integer, less than m.

Sample Input 

1 1 100

2

1

 

2 10 100

1 1

1 1

 

3 2147483647 12345

12345678 0 12345

1 2 3

 

0 0 0

Output for Sample Input

1

55

423

#include <cstdio>
#include <cstring>

typedef long long LL;
const int N = 16;
LL MOD;

struct Matrix{
	LL ary[N][N];
	void init() {
		memset(ary, 0, sizeof(ary));
	}
	Matrix() {
		init();
	}
};

const Matrix operator*(const Matrix & A, const Matrix & B) {
	Matrix t;
	for (int i = 0; i < N; ++i)
		for (int j = 0; j < N; ++j) {
			for (int k = 0; k < N; ++k) 
				t.ary[i][j] += A.ary[i][k] * B.ary[k][j];
			t.ary[i][j] %= MOD;
		}
	return t;
}

LL quick_pow(int d, LL n) {
	Matrix ans, tmp;

	for (int i = 0; i < d; ++i) {
		scanf("%lld", &tmp.ary[i][0]);
		tmp.ary[i][i + 1] = 1;
	}
	for (int i = 0; i < d; ++i) 
		scanf("%lld", &ans.ary[0][d - i - 1]);

	if (n <= d)
		return ans.ary[0][n - 1];

	n -= d;
	while (n) {
		if (n & 1)
			ans = ans * tmp;
		n >>= 1;
		tmp = tmp * tmp;
	}

	return ans.ary[0][0];
}

int main() {
	int d;
	LL n, m;

	while (~scanf("%d%lld%lld", &d, &n, &m), (d || n || m)) {
		MOD = m;

		LL ans = quick_pow(d, n);
		printf("%lld\n", ans);
	}

	return 0;
}