ZOJ 3772 Calculate the Function

题目链接

题意 ：先给你n个数， 然后给你一个函数的定义， 最后来m次询问， 问你一个[L, R]下F(R)的值。

今年浙大校赛的F题， 比赛的时候这道题目搞了很长时间， 最后YY了一个坐标转换过掉的， 赛后铭铭和我说可以用矩阵+线段树做， 卧槽， 太炫酷了吧。

先讲讲我比赛的时候的做法。

首先我们约定下 ： F(t, L)表示在左端是L的情况下算出来的t的函数值

然后观察前几他的给出的方程， 我们大概的可以YY出一个方程 ：

F(t, 1) = A(t, 1) * a[1] + B(t, 1) * a[2]     t >= 1

F(L, 1) = A(L, 1) * a[1] + B(L, 1) * a[2]                                             (1)

F(L + 1, 1) = A(L+1, 1)*a[1] + B(L+1, 1) * a[2]                                 (2)

显然 A(1, 1) = 1，B(1, 1) = 0，A(2, 1) = 0, B(2, 1) = 1。

然后对于一个询问 : query[L, R]

F(R, L) = A(R, L) * a[L] + B(R, L) * a[L+1]

这里我们只要求出A(t, L) , B(t, L) 函数就可以成功了， 至于求这两个函数么， 我们在YY一下 ： 把其中的a[L]和a[L+1]替换成(1)和(2)中的F(L, 1)和F(L+1, 1)。

就得到了一个新的方程newF(R) = F(L,1) * A(R, L) + F(L+1, 1) * B(R, L)

好吧， 这里再做一次最后的YY ： 其实这个newF(R) 就是F(R, 1)!!

之后就是解方程的过程了， 我们把F(L, 1) 、F(L+1, 1)、 F(R, 1)代掉， 然后求出A(R, L)和B(R, L)

求得结果是 ：



最后么就是一个除法用乘以一个逆元来做咯。。。

CODE ：

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long lld;
const lld mod = 1000000007;
const int maxn = 100005;
void ex_gcd(lld a, lld b, lld &d, lld &x, lld &y){
if (!b){
d = a; x = 1; y = 0;
}else {
ex_gcd(b, a % b, d, y, x);
y -= (lld)x * (a / b);
}
}
lld inv(lld a){
a %= mod;
if (a < 0)a += mod;
lld d, x, y;
ex_gcd(a, mod, d, x, y);
return d == 1 ? (x + mod) % mod : -1;
}
lld a[maxn];
int n, m;
lld A[maxn] = {0}, B[maxn] = {0};
void init() {
A[1] = 1; B[1] = 0;
A[2] = 0; B[2] = 1;
for (int i = 3; i <= n; i++) {
A[i] = (A[i - 1] + a[i] * A[i - 2]) % mod; A[i] %= mod;
B[i] = (B[i - 1] + a[i] * B[i - 2]) % mod; B[i] %= mod;
}
}
int main() {
int T;
scanf("%d", &T);
for (int cas = 1; cas <= T; cas++) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
init();
while (m--) {
int l, r;
scanf("%d%d", &l, &r);
if (r <= l + 1) {
printf("%lld\n", a[r]);
continue;
}
lld tx = ((A[r]*B[l+1]%mod-B[r]*A[l+1]%mod)%mod+mod)*inv((A[l]*B[l+1]%mod-B[l]*A[l+1]%mod)%mod+mod);
tx %= mod;
lld ty = ((A[r]*B[l]%mod-B[r]*A[l]%mod)%mod+mod)*inv((A[l+1]*B[l]%mod-B[l+1]*A[l]%mod)%mod+mod)%mod;
ty %= mod;
lld res = a[l] * tx % mod + a[l + 1] * ty % mod;
printf("%lld\n", res % mod);
}
}
return 0;
}

再么， 讲一个铭铭告诉我的超炫酷的做法， 线段树+矩阵

这道题目， 对于那个F(x) = F(x - 2) * a[x] + F(x - 1)的定义很容易想到用乘以一个系数矩阵获得新的向量。

但是存在n个系数矩阵！

怎么办？

线段树维护了 ！

定义M(x)为第x个系数矩阵

具体为 ： 

0       1

a[x]   1

那么[ F(R)   ]  = M(R)*...*(M(L+2) *( M(L+1)* [ a[L]     ])

      [ F(R-1) ]                         [ a[L+1] ]

注意从右边先算 ： 矩阵乘法不符合交换律的。。。。但是符合结合律

奥， 附加一句 ： 因为我习惯于写成列向量， 所以要倒着算， 如果是行向量的话直接正的算过去就好了。

所以么用线段树来维护向量前面的(R - L - 2)个矩阵的乘法之积的结果 。。。 非常炫酷。。。。

CODE ：

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;
#define lson rt<<1, l, mid
#define rson rt<<1|1, mid+1, r
typedef long long lld;
const int mod = 1000000007;
const int MAXN = 100005;
struct M {
lld a[3][3];
}sum[MAXN << 2], ONE;
int val[MAXN];
int n, m;
int F(int x) {
return n + 1 - x;
}
M mul(M a, M b) {
M ans;
for (int i = 1; i <= 2; i++) {
for (int j = 1; j <= 2; j++) {
ans.a[i][j] = 0;
for (int k = 1; k <= 2; k++) {
ans.a[i][j] += (a.a[i][k] * b.a[k][j]) % mod;
ans.a[i][j] %= mod;
}
}
}
return ans;
}
void init(M& A) {
for (int i = 1; i <= 2; i++) {
for (int j = 1; j <= 2; j++) {
A.a[i][j] = 0;
}
}
}
void Up(int rt) {
sum[rt] = mul(sum[rt<<1], sum[rt<<1|1]);
}
void build(int rt, int l, int r) {
if (l == r) {
sum[rt].a[1][1] = 0;
sum[rt].a[1][2] = sum[rt].a[2][2] = 1;
sum[rt].a[2][1] = val[F(l)];
return ;
}
int mid = r + l >> 1;
build(lson);
build(rson);
Up(rt);
}
M query(int rt, int l, int r, int L, int R) {
if (l >= L && r <= R) {
return sum[rt];
}
int mid = r + l >> 1;
M res = ONE;
if (mid >= L)res = mul(res, query(lson, L, R));
if (R > mid) res = mul(res, query(rson, L, R));
return res;
}

int main() {
int T;
scanf("%d", &T);
init(ONE);
for (int i = 1; i <= 2; i++)ONE.a[i][i] = 1;
for (int cas = 1; cas <= T; cas++) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &val[i]);
}
build(1, 1, n);
while (m--) {
int L, R;
scanf("%d%d", &L, &R);
if (R - L <= 1) {
printf("%d\n", val[R]);
continue;
}
int l = F(R), r = F(L + 2);
M res = query(1, 1, n, l, r);
lld ans = res.a[2][1] * val[L] % mod + res.a[2][2] * val[L+1] % mod;
printf("%lld\n", ans % mod);
}
}
return 0;
}

比赛的时候弱到方程还是队友帮忙解出的， 忧伤。。。