teamnote default

source/Linear Algebra/BerlekampMassey.cpp

@@ -0,0 +1,107 @@
+// https://gist.github.com/koosaga/d4afc4434dbaa348d5bef0d60ac36aa4
+vector<int> berlekamp_massey(vector<int> x){
+	vector<int> ls, cur; int lf, ld;
+	for(int i=0; i<x.size(); i++){
+		ll t = 0;
+		for(int j=0; j<cur.size(); j++)
+			t = (t + (ll)x[i-j-1] * cur[j]) % mod;
+		if((t - x[i]) % mod == 0) continue;
+		if(cur.empty()){
+			cur.resize(i+1);
+			lf = i; ld = (t - x[i]) % mod;
+			continue;
+		}
+		ll k = -(x[i] - t) * ipow(ld, mod - 2) % mod;
+		vector<int> c(i-lf-1); c.push_back(k);
+		for(auto &j : ls) c.push_back(-j * k % mod);
+		if(c.size() < cur.size()) c.resize(cur.size());
+		for(int j=0; j<cur.size(); j++) c[j] = (c[j] + cur[j]) % mod;
+		if(i-lf+(int)ls.size()>=(int)cur.size())
+			tie(ls, lf, ld) = make_tuple(cur, i, (t - x[i]) % mod);
+		cur = c;
+	}
+	for(auto &i : cur) i = (i % mod + mod) % mod;
+	return cur;
+}
+int get_nth(vector<int> rec, vector<int> dp, ll n){
+	int m = rec.size();
+	vector<int> s(m), t(m);
+	s[0] = 1;
+	if(m != 1) t[1] = 1;
+	else t[0] = rec[0];
+	auto mul = [&rec](vector<int> v, vector<int> w){
+		int m = v.size();
+		vector<int> t(2 * m);
+		for(int j=0; j<m; j++){
+			for(int k=0; k<m; k++){
+				t[j+k] += (ll)v[j] * w[k] % mod;
+				if(t[j+k] >= mod) t[j+k] -= mod;
+			}
+		}
+		for(int j=2*m-1; j>=m; j--){
+			for(int k=1; k<=m; k++){
+				t[j-k] += (ll)t[j] * rec[k-1] % mod;
+				if(t[j-k] >= mod) t[j-k] -= mod;
+			}
+		}
+		t.resize(m);
+		return t;
+	};
+	while(n){
+		if(n & 1) s = mul(s, t);
+		t = mul(t, t);
+		n >>= 1;
+	}
+	ll ret = 0;
+	for(int i=0; i<m; i++) ret += (ll)s[i] * dp[i] % mod;
+	return ret % mod;
+}
+// 1. calculate vi x: the first terms of recurrence;
+// 2. calculate vi p: berlekamp_massey(x)
+// 3. int get_nth(p, x, n) : nth term
+
+struct elem{int x, y, v;}; // A_(x, y) <- v, 0-based. no duplicate please..
+vector<int> get_min_poly(int n, vector<elem> M){
+	// smallest poly P such that A^i = sum_{j < i} {A^j \times P_j}
+	vector<int> rnd1, rnd2;
+	mt19937 rng(0x14004);
+	auto randint = [&rng](int lb, int ub){
+		return uniform_int_distribution<int>(lb, ub)(rng);
+	};
+    fors(i, 0, n-1) rnd1.push_back(randint(1, mod - 1));
+    fors(i, 0, n-1) rnd2.push_back(randint(1, mod - 1));
+	vector<int> gobs;
+    fors(i, 0, 2*n+1){
+		int tmp = 0;
+        fors(j, 0, n-1){
+			tmp += (ll)rnd2[j] * rnd1[j] % mod;
+			if(tmp >= mod) tmp -= mod;
+		}
+		gobs.push_back(tmp);
+		vector<int> nxt(n);
+		for(auto &i : M){
+			nxt[i.x] += (ll)i.v * rnd1[i.y] % mod;
+			if(nxt[i.x] >= mod) nxt[i.x] -= mod;
+		}
+		rnd1 = nxt;
+	}
+	auto sol = berlekamp_massey(gobs);
+	reverse(sol.begin(), sol.end());
+	return sol;
+}
+
+ll det(int n, vector<elem> M){
+	vector<int> rnd;
+	mt19937 rng(0x14004);
+	auto randint = [&rng](int lb, int ub){
+		return uniform_int_distribution<int>(lb, ub)(rng);
+	};
+	fors(i, 0, n-1) rnd.push_back(randint(1, mod - 1));
+	for(auto &i : M){
+		i.v = (ll)i.v * rnd[i.y] % mod;
+	}
+	auto sol = get_min_poly(n, M)[0];
+	if(n % 2 == 0) sol = mod - sol;
+	for(auto &i : rnd) sol = (ll)sol * ipow(i, mod - 2) % mod;
+	return sol;
+}

source/Linear Algebra/Matrix.cpp

@@ -0,0 +1,56 @@
+class Matrix {
+private:
+    ll c, r, mod; vector<vector<ll>> arr;
+    ll power(ll x, ll y, ll p) {
+        if (y == 0) return 1;
+        ll v = power(x, y/2, p) % p;
+        v = (v * v) % p;
+        return (y%2 == 0)? v : (x * v) % p;
+    }
+    ll modInverse(ll a, ll p) { return power(a, p-2, p); }
+public:
+    Matrix(int _n, int _m, ll p) : c(_n), r(_m), mod(p), arr(_n, vl(_m, 0)){}
+    void setI() { assert(c == r); for(int i=0; i<c; i++) arr[i][i] = 1; }
+    vl& operator[](ll i) { return arr[i]; }
+    void swaprow(ll i, ll j) { swap(arr[i], arr[j]); }
+
+    pair<bool, Matrix> Inverse() {
+        assert(c == r);
+        Matrix victim = *this, retm(c, c, mod); retm.setI();
+        for (int k = 0; k < c; k++) {
+            int t = k - 1; while (t + 1 < c && !victim[++t][k]);
+            if (t == c - 1 && !victim[t][k])
+                return {false, Matrix(0, 0, 0)};
+            victim.swaprow(k, t), retm.swaprow(k, t);
+            ll d = victim[k][k];
+            for (int j = 0; j < c; j++) {
+                victim[k][j] = (victim[k][j] * modInverse(d, mod))%mod;
+                retm[k][j] = (retm[k][j] * modInverse(d, mod))%mod;
+            }
+            for (int i = 0; i<c; i++) if (i != k) {
+                ll m = victim[i][k];
+                for (int j = 0; j < c; j++) {
+                    if (j >= k) victim[i][j] = (victim[i][j] - victim[k][j] * m + mod*mod)%mod;
+                    retm[i][j] = (retm[i][j] - retm[k][j] * m + mod*mod)%mod;
+                }
+            }
+        }
+        return {true, retm};
+    }
+    vector<double> GaussElimination() {
+        assert(c == r - 1);
+        vector<double> retv(c, 0.0);
+        for(ll i=0; i<c; i++) for(ll j=1+i; j<c; j++) {
+            double tmp = arr[j][i];
+            for(ll k=i; k<r; k++)
+                arr[j][k] = arr[j][k] - (tmp / arr[i][i]) * arr[i][k];
+        }
+        ll p = c, q = 0;
+        for (ll p = c - 1; p >= 0; p--) {
+            retv[p] = arr[p][c] / arr[p][p];
+            for (q = p - 1; q >= 0; q--)
+                arr[q][c] = arr[q][c] - arr[q][p] * retv[p];
+        }
+        return retv;
+    }
+};

source/Linear Algebra/XORBasis.cpp

@@ -0,0 +1,5 @@
+vector<ll> basis;
+void insert(ll x) {
+    for(auto i:basis) x = min(x, x ^ basis[i]);
+	if (x != 0) basis.push_back(x);
+}