斐波纳契数列 线段树的维护

像一般的数列维护一样，这题也差不多。有一个数列a，修改操作是将a[i] .. a[j]的值都加上一个d，询问操作就有点不同，给出i和j，求出a[i] * fib(0) + a[i + 1] * fib(1) + a[i + 2] * fib(2) + ... + a[j] * fib(j - i)模上一个数的结果。其中fib就是斐波纳契数列，即fib(0) = fib(1) = 1，对于fib(i)（> 1）， fib(i) = fib(i -1) + fib(i - 2)。

如果这个线段树要支持某个操作，那必须要实现合并的操作，也就是在线段树的某个结点，它如何将两个儿子的信息合并成一个。对于这题，就需要实现一个：

已知a[i] * fib(0) + a[i + 1] * fib(1) + a[i + 2] * fib(2) + ... + a[j] * fib(j - i)或者保存多一些需要的信息，怎样求出a[i] * fib(0 + k) + a[i + 1] * fib(1 + k) + a[i + 2] * fib(2 + k) + ... + a[j] * fib(j - i + k)。

斐波纳契数列有一个奇特的性质，尝试如下的运算，得出的序列还是斐波纳契数列。

a  1  1  2  3  5  8  13  ....

b  1  2  3  5  8  13  21 ....

将同一个位置的相加（c[i] = a[i] + b[i]），得：

c  2  3  5  8  13  21  34 ....

再加加d[i] = b[i] + c[i]，得：

d 3  5  8  13  21  34  55

如此看来，我们可以设：

X =  a[i] * fib(0) + a[i + 1] * fib(1) + a[i + 2] * fib(2) + ... + a[j] * fib(j - i)；

Y =  a[i] * fib(1) + a[i + 1] * fib(2) + a[i + 2] * fib(3) + ... + a[j] * fib(j - i + 1)；

那么：

X + Y  = a[i] * fib(2) + a[i + 1] * fib(3) + a[i + 2] * fib(4) + ... + a[j] * fib(j - i + 2)；

X + 2Y = a[i] * fib(3) + a[i + 1] * fib(4) + a[i + 2] * fib(5) + ... + a[j] * fib(j - i + 3)；

2X + 3Y = a[i] * fib(4) + a[i + 1] * fib(5) + a[i + 2] * fib(6) + ... + a[j] * fib(j - i + 4)；

3X + 5Y = a[i] * fib(5) + a[i + 1] * fib(6) + a[i + 2] * fib(7) + ... + a[j] * fib(j - i + 5)；

....

fib(k - 2) * X + fib(k - 1) * Y = a[i] * fib(0 + k) + a[i + 1] * fib(1 + k) + a[i + 2] * fib(2 + k) + ... + a[j] * fib(j - i + k)   （k > 1），k = 0，k = 1的情况额外处理，fib数列预处理。

这样，我们就可以实现维护了，需要保存两个信息，就是上述的X，Y。接着就是信息传递的操作，也就是整段都加上d。

也就是已知a[i] * fib(0) + a[i + 1] * fib(1) + a[i + 2] * fib(2) + ... + a[j] * fib(j - i)，求(a[i] + d) * fib(0) + (a[i + 1] + d) * fib(1) + (a[i + 2] + d) * fib(2) + ... + (a[j]  + d) * fib(j - i)。

通过拆分得：a[i] * fib(0) + a[i + 1] * fib(1) + a[i + 2] * fib(2) + ... + a[j] * fib(j - i) + d * fib(0) + d * fib(1) + d * fib(2) + ... + d * fib(j - i)

a[i] * fib(0) + a[i + 1] * fib(1) + a[i + 2] * fib(2) + ... + a[j] * fib(j - i) + d * (fib(0) + fib(1) + fib(2) + ... + fib(j - i))。

fib的数列和有个定理：fib(0) + fib(1) + fib(2) + ... + fib(i) = fib(i + 2) - 1。这样又可以实现信息传递的操作了。问题到此就解决了。此外，我们可以从fib的矩阵乘法中联想到合并信息的方法，本质是一样的。

对于一些比较难维护的数据，可以通过列公式等方法找出其中的规律，哪怕没有什么规律，我们也能从中得到一些启发。还可以想想另一些方法，即使它们看起来是不能解决问题的。

#include <cstdio>
#include <iostream>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pii;

const ll mod = 1000000000LL;
const int N = 200007;
int n, m;
ll fib[N], X[N], Y[N];

int nnode = 1;
struct Node
{
	Node *lch, *rch;
	int lo, hi;
	ll flag;
	pii dat;
	inline int mi()
	{
		return (lo + hi) >> 1;
	}
	inline int size()
	{
		return hi - lo;
	}
}node[N << 1], *root = &node[0];

inline pii Calc(pii a, int k)
{
	pii res;
	res.first = (a.first * (k == 1 ? 0LL : fib[k - 2]) % mod + 
				a.second * fib[k - 1] % mod) % mod;
	res.second = (a.first * fib[k - 1] % mod +
				a.second * fib[k] % mod) % mod;
	return res;
}

pii operator + (pii const &a, pii const &b) 
{
	return make_pair((a.first + b.first) % mod, 
					(a.second + b.second) % mod);
}

void Build(Node *p, int le, int ri)
{
	p -> lo = le;
	p -> hi = ri;
	p -> flag = 0LL;
	if (le + 1 == ri)
	{
		scanf("%I64d\n", &p -> dat.first);
		p -> dat.second = p -> dat.first;
		p -> lch = p -> rch = NULL;
	}
	else 
	{
		int mi = p -> mi();
		p -> lch = &node[nnode ++];
		p -> rch = &node[nnode ++];
		Build(p -> lch, le, mi);
		Build(p -> rch, mi, ri);
		p -> dat = p -> lch -> dat + 
			Calc(p -> rch -> dat, mi - le);
	}
}

void Update(Node *p, ll flag)
{
	p -> flag += flag;
	p -> dat.first = (flag * (fib[p -> size() + 1] - 1LL) + 
				p -> dat.first) % mod;
	p -> dat.second = (flag * (fib[p -> size() + 2] - 2LL) +
				p -> dat.second) % mod;
}

void Modify(Node *p, int le, int ri, ll delta)
{
	if (le <= p -> lo && ri >= p -> hi)
		Update(p, delta);
	else 
	{
		if (p -> flag) 
		{
			Update(p -> lch, p -> flag);
			Update(p -> rch, p -> flag);
			p -> flag = 0LL;
		}
		int mi = p -> mi();
		if (le < mi) Modify(p -> lch, le, ri, delta);
		if (ri > mi) Modify(p -> rch, le, ri, delta);
		p -> dat = p -> lch -> dat + 
			Calc(p -> rch -> dat, p -> lch -> size());
	}
}

pii Ask(Node *p, int le, int ri)
{
	if (le <= p -> lo && ri >= p -> hi)
		return p -> dat;
	if (p -> flag) 
	{
		Update(p -> lch, p -> flag);
		Update(p -> rch, p -> flag);
		p -> flag = 0LL;
	}
	int mi = p -> mi();
	if (le < mi && ri > mi)
		return Ask(p -> lch, le, ri) + 
			Calc(Ask(p -> rch, le, ri), 
				p -> lch -> hi - max(le, p -> lch -> lo));
	else if (le < mi) return Ask(p -> lch, le, ri);
	else return Ask(p -> rch, le, ri);
}

void Init()
{
	scanf("%d%d\n", &n, &m);
	fib[0] = fib[1] = 1;
	for (int i = 2; i < n; i ++)
		fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
	Build(root, 0, n);
}

void Solve()
{
	while (m --)
	{
		int tmp, le, ri;
		scanf("%d%d%d", &tmp, &le, &ri);
		if (tmp == 2)
		{
			scanf("\n");
			printf("%I64d\n", Ask(root, le - 1, ri).first);
		}
		else 
		{
			ll di;
			scanf("%I64d\n", &di);
			Modify(root, le - 1, ri, di);
		}
	}
}

int main()
{
	freopen("fib.in", "r", stdin);
	freopen("fib.out", "w", stdout);
	
	Init();
	Solve();
	
	return 0;
}