nefu 1490 Sequence

很显然是一个递推问题，那么就应该推矩阵了

我们可以发现当n取值在某一区间内时是一个固定的值，所以可以先找到取固定值的区间，因为区间是连续且单调的，所以可以使用二分进行计算（二分n值与当前的作比较，找到当前取值n的最大值），很显然当np时，始终为1.

Code:

int check(int n,int x)
{
	int l = 1, r = n;
	int mid;
	while (l <= r) {
		mid = l + r >> 1;
		if (ceil((n * 1.0) / mid) >= x) l = mid + 1;
		else r = mid - 1;
	}
	return r;
}

二分找到区间之后就基本做完了，只需遍历每个区间加和就可以了吗？如果数据不大当然可以，但是出题人的数据量较大，就算推出了公式也会T，所以还需要优化。

在二分时我们发现当np时，始终为1.那么我们就可以根据这点进行优化，当n<p时，我们只需要遍历到n，这也是一遍情况。当np我们可以遍历到p，因为n>p之后为1，也就是说这个常量固定了，那就可以直接套模板了。

下面给出ac代码Code:

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1e5 + 5;
const int MOD = 1e9 + 7;
const int MAX = 3;
typedef struct {
	LL m[MAX][MAX];
}Mit;
Mit I = { 1,0,0,0,1,0,0,0,1 };
Mit P;
int check(int n,int x)
{
	int l = 1, r = n;
	int mid;
	while (l <= r) {
		mid = l + r >> 1;
		if (ceil((n * 1.0) / mid) >= x) l = mid + 1;
		else r = mid - 1;
	}
	return r;
}
Mit Mul(Mit a, Mit b)//快速乘
{
	Mit c;
	for (int i = 0; i < MAX; i++)
		for (int j = 0; j < MAX; j++) {
			c.m[i][j] = 0;
			for (int k = 0; k < MAX; k++) {
				a.m[i][k] = (a.m[i][k] % MOD + MOD) % MOD;
				b.m[k][j] = (b.m[k][j] % MOD + MOD) % MOD;
				c.m[i][j] += (a.m[i][k] * b.m[k][j]) % MOD;
			}
			c.m[i][j] = (c.m[i][j] % MOD + MOD) % MOD;
		}
	return c;
}
Mit qpow(Mit P, Mit I, int n)//快速幂
{
	Mit m = P, b = I;
	while (n >= 1) {
		if (n & 1) {
			b = Mul(b, m);
		}
		n = n >> 1;
		m = Mul(m, m);
	}
	return b;
}
int main()
{
	//ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
	int t;
	scanf("%d", &t);
	while (t--) {
		memset(P.m, 0, sizeof(P.m));
		LL a, b, c, d;
		int p, n;
		scanf("%lld%lld%lld%lld%d%d", &a, &b, &c, &d, &p, &n);
		LL ans = 0;
		if (n == 1) cout << a << endl;
		else if (n == 2) cout << b << endl;
		else {
			Mit S;
			P = { d,c,1,1,0,0,0,0,1 };
			int tmp = 0;
			int m = min(p, n);
			for (int i = 3; i <= m; i = (tmp + 1)) {
				tmp = min(check(p, (int)ceil((1.0 * p) / i)), m);//取min为n更小
				S = qpow(P, I, tmp - i + 1);
				ans = (S.m[0][0] * b % MOD + S.m[0][1] * a % MOD + S.m[0][2] * (LL)ceil(1.0 * p / i) % MOD + MOD) % MOD;
				a = (S.m[1][0] * b % MOD + S.m[1][1] * a % MOD + S.m[1][2] * (LL)ceil(1.0 * p / i) % MOD + MOD) % MOD;
				b = ans;
			}
			if (n > p) {
				S = qpow(P, I, n - max(p, 2));
				ans = (S.m[0][0] * b % MOD + S.m[0][1] * a % MOD + S.m[0][2] % MOD + MOD) % MOD;
			}
			printf("%lld\n", ans);
		}
	}
	return 0;