Merge pull request #2271 from cpinitiative/CF-718C

Solution for CF-718C

Author: bqi343

content/5_Plat/Matrix_Expo.problems.json

@@ -42,6 +42,30 @@
         "section": "23.3"
       }
     },
+    {
+      "uniqueId": "cf-691E",
+      "name": "Xor-sequences",
+      "url": "https://codeforces.com/contest/691/problem/E",
+      "source": "CF",
+      "difficulty": "Easy",
+      "isStarred": false,
+      "tags": ["Exponentiation", "Matrix"],
+      "solutionMetadata": {
+        "kind": "internal"
+      }
+    },
+    {
+      "uniqueId": "cf-718C",
+      "name": "Sasha and Array",
+      "url": "https://codeforces.com/problemset/problem/718/C",
+      "source": "CF",
+      "difficulty": "Normal",
+      "isStarred": false,
+      "tags": ["Exponentiation", "Matrix", "PURS"],
+      "solutionMetadata": {
+        "kind": "internal"
+      }
+    },
     {
       "uniqueId": "baltic-07-ConnectedPoints",
       "name": "2007 - Connected Points",
@@ -55,18 +79,6 @@
         "url": "https://github.com/mostafa-saad/MyCompetitiveProgramming/blob/master/Olympiad/Baltic/Baltic-07-Points.txt"
       }
     },
-    {
-      "uniqueId": "cf-691E",
-      "name": "Xor-sequences",
-      "url": "https://codeforces.com/contest/691/problem/E",
-      "source": "CF",
-      "difficulty": "Easy",
-      "isStarred": false,
-      "tags": ["Exponentiation", "Matrix"],
-      "solutionMetadata": {
-        "kind": "internal"
-      }
-    },
     {
       "uniqueId": "balkan-09-reading",
       "name": "2009 - Reading",

solutions/cf-718C.mdx

@@ -0,0 +1,179 @@
+---
+id: cf-718C
+source: CF
+title: Sasha and Array
+author: Dustin Miao
+---
+
+## Explanation
+
+Firstly, a note on notation: let $F_i$ denote the $i$th Fibonacci number. That is,
+
+$$
+F_i = 
+\begin{cases} 
+	0 & i = 0 \\ 
+	1 & i = 1 \\
+	F_{i - 1} + F_{i - 2} & i \geq 2 \\
+\end{cases}
+$$
+
+In this problem, we will build a segment tree over the array. For a leaf node in the segment tree with value $v$, we will store a pair of values $(F_{v - 1}, F_v)$. For all non-leaf nodes, we will store a pair of values equal to the pair-sum of its children. That is, if a node $u$ has children $v$ and $w$, then $$u = (v_0 + w_0, v_1 + w_1)$$. 
+
+We will use the term _cycle by k_ to denote transforming some pair $(F_{i - 1}, F_i)$ to $(F_{i - 1 + k}, F_{i + k})$. By default, the term _cycle_ refers to _cycle by 1_.
+
+For each update, we need to cycle each leaf node by some amount $x$ such that the value in a node affected goes from $(F_{v - 1}, F_v)$ to $(F_{v - 1 + x}, F_{v + x})$. We can do this using matrix exponentiation.
+
+First note that for a matrix $\begin{pmatrix} F_{i - 1} & F_i \end{pmatrix}$, we can cycle it by multiplying by $\begin{pmatrix} 0 & 1 \\ 1 & 1 \end{pmatrix}$. That is,
+
+$$
+\begin{pmatrix} F_i & F_{i + 1} \end{pmatrix} = \begin{pmatrix} F_{i - 1} & F_i \end{pmatrix}\begin{pmatrix} 0 & 1 \\ 1 & 1 \end{pmatrix}
+$$
+
+Inductively, we can cycle by $k$ by multiplying multiple times:
+
+$$
+\begin{pmatrix} F_{i - 1 + k} & F_{i + k} \end{pmatrix} = \begin{pmatrix} F_{i - 1} & F_i \end{pmatrix}\begin{pmatrix} 0 & 1 \\ 1 & 1 \end{pmatrix}^k
+$$
+
+We can use binary exponentiation to quickly compute powers of the two-by-two matrix. 
+
+Secondly, we need to utilize the distributive property of matrix multiplication to same-size matrices. That is, if $m_k$ is a one-by-two matrix for $k \in [1, n]$, then the following property is satisfied:
+
+$$
+(m_1 + m_2 + \dots + m_n) \cdot \begin{pmatrix} 0 & 1 \\ 1 & 1 \end{pmatrix} = m_1 \cdot \begin{pmatrix} 0 & 1 \\ 1 & 1 \end{pmatrix} + m_2 \cdot \begin{pmatrix} 0 & 1 \\ 1 & 1 \end{pmatrix} + \dots + m_n \cdot \begin{pmatrix} 0 & 1 \\ 1 & 1 \end{pmatrix}
+$$
+
+In that way, we can utilize lazy propagation on the segment tree. We will store an integer tag in each node denoting the lazy update, which denotes that we must cycle every node in its subtree by the value of the tag. When propagating, we can simply update the node by binary exponentiating and then multiplying, then storing it in the lazy tag. Querying works as normal on the segment tree. 
+
+## Implementation
+
+<LanguageSection>
+
+<CPPSection>
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+#define f first
+#define s second
+
+using ll = long long;
+using pll = pair<ll, ll>;
+
+const int MAXN = 1e5 + 1;
+const ll MOD = 1e9 + 7;
+	
+
+//BeginCodeSnip{Matrix Operations}
+using Matrix = array<array<ll, 2>, 2>;
+
+// multiplies two two-by-two matricies
+Matrix multiply(const Matrix &a, const Matrix &b) {
+	return {(a[0][0] * b[0][0] + a[0][1] * b[1][0]) % MOD, 
+		(a[0][0] * b[0][1] + a[0][1] * b[1][1]) % MOD,
+		(a[1][0] * b[0][0] + a[1][1] * b[1][0]) % MOD,
+		(a[1][0] * b[0][1] + a[1][1] * b[1][1]) % MOD};
+}
+
+// multiplies a one-by-two matrix with a two-by-two matrix
+pll multiply(const pll &a, const Matrix &b) {
+	return {(a.f * b[0][0] + a.s * b[1][0]) % MOD, 
+		(a.f * b[0][1] + a.s * b[1][1]) % MOD};
+}
+
+// returns {0, 1, 1, 1,} to the power of n
+Matrix pow(ll n) { 
+	Matrix res = {1, 0, 0, 1};  // identity matrix
+	Matrix base = {0, 1, 1, 1};  // fibonacci matrix
+	for (; n; n >>= 1) {  // binary exponentiation (log n)
+		if (n & 1) {
+			res = multiply(res, base);
+		}
+		base = multiply(base, base);
+	}
+	return res;
+}
+//EndCodeSnip
+
+int N, Q;
+pll tree[MAXN * 4];
+ll lazy[MAXN * 4];
+
+// returns the pair-sum of a and b
+pll merge(const pll &a, const pll &b) {
+	return {(a.f + b.f) % MOD, (a.s + b.s) % MOD};
+}
+
+// pushes lazy update in t to its children
+void pushdown(int t) {
+	if (lazy[t] == 0)
+		return;
+	tree[t << 1] = multiply(tree[t << 1], pow(lazy[t]));
+	lazy[t << 1] += lazy[t];
+	tree[t << 1 | 1] = multiply(tree[t << 1 | 1], pow(lazy[t]));
+	lazy[t << 1 | 1] += lazy[t];
+	lazy[t] = 0;
+}
+
+// cycle range from l to r by v
+void update(int l, int r, ll v, int t = 1, int tl = 1, int tr = N) {
+	if (r < tl || tr < l) {
+		return;
+	}
+	if (l <= tl && tr <= r) {
+		tree[t] = multiply(tree[t], pow(v));
+		lazy[t] += v;
+		return;
+	}
+	pushdown(t);
+
+	int tm = (tl + tr) >> 1;
+	update(l, r, v, t << 1, tl, tm);
+	update(l, r, v, t << 1 | 1, tm + 1, tr);
+	tree[t] = merge(tree[t << 1], tree[t << 1 | 1]);
+}
+
+// query sum from l to r
+ll query(int l, int r, int t = 1, int tl = 1, int tr = N) {
+	if (r < tl || tr < l) {
+		return 0;
+	}
+	if (l <= tl && tr <= r) {
+		return tree[t].f;
+	}
+	pushdown(t);
+
+	int tm = (tl + tr) >> 1;
+	return (query(l, r, t << 1, tl, tm) + query(l, r, t << 1 | 1, tm + 1, tr)) % MOD;
+}
+
+int main() {
+	cin >> N >> Q;
+	fill_n(tree, MAXN * 4, pll{0, 1});
+	for (int i = 1; i <= N; i++) {
+		ll a; 
+		cin >> a;
+		update(i, i, a);
+	}
+
+	while (Q--) {
+		int t; 
+		cin >> t;
+		if (t == 1) {
+			int l, r; 
+			ll v;
+			cin >> l >> r >> v;
+			update(l, r, v);
+		} else if (t == 2) {
+			int l, r;
+			cin >> l >> r;
+			cout << query(l, r) << '\n';
+		}
+	}
+}
+```
+</CPPSection>
+
+</LanguageSection>