史诗级ACM模板整理
基本语法
字符串函数
istream& getline (char* s, streamsize n );
istream& getline (char* s, streamsize n, char delim );
istream& getline (istream& is, string& str, char delim);
istream& getline (istream& is, string& str);
char * strncpy ( char * destination, const char * source, size_t num );
if num > source, will padding with 0. no '\0' //strlen() + 1
const char * strrchr ( const char * str, int character );
const char * strchr ( const char * str, int character );
NULL if not found
const char * strstr ( const char * str1, const char * str2 );
return the first occurance, NULL if not found
size_t strspn ( const char * str1, const char * str2 );
The length of the initial portion of str1 containing only characters that appear in str2.
size_t strcspn ( const char * str1, const char * str2 );
const char * strpbrk ( const char * str1, const char * str2 );
return first occurance of ch among str2
char * strtok ( char * str, const char * delimiters);
控制精度
#include<iomanip>
cout<<fixed<<setprecision(2)<<3.14159<<endl;
Black-Tec
对拍
@echo off
:loop
echo %random% | ran >in.txt
bf <in.txt > std.txt
my <in.txt > my.txt
fc std.txt my.txt > nul
if not errorlevel 1 goto loop
fread读入优化
char buf[1<<21],*p1=buf,*p2=buf;
inline int getc(){
return p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++;
}
pbds
hash_table
#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/hash_policy.hpp>
#include <iostream>
using namespace std;
using namespace __gnu_pbds;
gp_hash_table<int, int> h;
void judge(int i) {
if (h.find(i) == h.end())
cout<<"No"<<endl;
else
cout<<"Yes"<<h[i]<<endl;
return;
}
int main() {
int i;
h[15] = 1;
h.insert(make_pair(12, 2));
while (cin>>i)
judge(i);
return 0;
}
rb_tree
#include <ext/pb_ds/assoc_container.hpp>
#include <iostream>
using namespace std;
using namespace __gnu_pbds;
tree <int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> t, b;
signed main() {
int v = 4;
t.insert(5);
t.insert(2);
t.erase(t.lower_bound(0));
t.order_of_key(5);
t.find_by_order(1);
t.join(b); // no repeat
t.split(v, b);
return 0;
}
字符串
KMP
void getFail(string &P,int *f) {
int i,j;
f[0]=f[1]=0;
for (i=1;i<m;++i) {
j=f[i];
while (j&&P[i]!=P[j]) j=f[j];
f[i+1]=P[i]==P[j]?j+1:0;
}
return;
}
void find(string &T,string &P,int *f) {
int i,j;
j=0;
for (i=0;i<n;++i) {
while (j&&T[i]!=P[j]) j=f[j];
if (T[i]==P[j]) j++; //!!!
if (j==m)
printf("%d ",i-m+2);
}
return;
}
exKMP
#include <iostream>
#include <string>
#include <cstring>
#include <iterator>
using namespace std;
const int maxn = 1e5 + 1;
int nxtP[maxn], Lcp[maxn];
void exKMP(const char* P, int* nxt, const char* T, int* ext) {
int i, mx = 0, p = 0, n = strlen(T), m = strlen(P); //mx: Position where doesn't fit.
if (nxt == ext) {
ext[0] = n;
p = 1; mx = 1; i = 1;
while (mx < n && mx - i < m && T[mx] == P[mx - i]) mx++;
} else i = 0;
for (; i < n; ++i)
if (nxt[i - p] + i < mx) ext[i] = nxt[i - p];
else {
if (i >= mx) mx = i; //i >= mx
while (mx < n && mx - i < m && T[mx] == P[mx - i]) mx++;
ext[i] = mx - i;
p = i;
}
return;
}
signed main() {
string T, P;
cin>>T>>P;
exKMP(P.data(), nxtP, P.data(), nxtP);
exKMP(P.data(), nxtP, T.data(), Lcp);
copy(nxtP, nxtP + P.length(), ostream_iterator <int> (cout, " "));
cout<<endl;
copy(Lcp, Lcp + T.length(), ostream_iterator <int> (cout, " "));
return 0;
}
Aho-Corasick 自动机
#include <iostream>
#include <cstring>
#include <string>
#include <queue>
#include <map>
using namespace std;
const int maxn = 2e5 + 1, maxm = 26;
int n, ans[maxn] = { 0 };
string P[maxn], T;
struct Trie {
int ch[maxn][maxm], sz, val[maxn];
int ind[maxn], lazy[maxn];
map <int, int> e;
Trie() {
memset(ch[0], 0, sizeof(ch[0]));
memset(val, 0, sizeof(val));
sz = 1; //
}
void insert(const char *s, int v) {
int len = strlen(s), u = 0, c;
for (int i = 0; i < len; ++i) {
c = s[i] - 'a';
if (!ch[u][c]) {
memset(ch[sz], 0, sizeof(ch[sz]));
val[sz] = 0; //
ch[u][c] = sz++;
}
u = ch[u][c];
}
if (val[u])
ans[v - 1] = -val[u];
else
val[u] = v;
}
};
struct Aho_Corasick: public Trie {
int f[maxn], last[maxn];
void get_Fail() {
int j, u;
queue <int> Q;
f[0] = 0;
for (auto x: ch[0])
if (x) {
Q.push(x);
f[x] = 0;
last[x] = 0;
}
while (!Q.empty()) {
int r = Q.front();
Q.pop();
for (register int c = 0; c < maxm; ++c)
if (ch[r][c]) {
u = ch[r][c];
Q.push(u);
j = f[r];
while (j && !ch[j][c]) j = f[j];
f[u] = ch[j][c];
last[u] = val[f[u]] ? f[u] : last[f[u]];
if (val[u] && last[u])
Add(val[u], val[last[u]]);
}
}
}
void find(const char* T) {
int len = strlen(T), j = 0, c;
for (register int i = 0; i < len; ++i) {
c = T[i] - 'a';
while (j && !ch[j][c]) j = f[j];
j = ch[j][c];
if (val[j]) print(j);
else if (last[j]) print(last[j]);
}
return;
}
void print(int x) {
lazy[val[x]]++;
/* ans[val[x] - 1]++;
if (last[x])
print(last[x]); */
}
void Add(int x, int y) {
ind[y]++;
e.insert(make_pair(x, y));
}
void topocalc() {
queue <int> Q;
for (int x = 1; x <= n; ++x) if (!ind[x])
Q.push(x);
while (!Q.empty()) {
int u, x = Q.front(); Q.pop();
ans[x - 1] += lazy[x];
if (e.find(x) != e.end()) {
u = e[x];
ind[u]--;
lazy[u] += lazy[x];
if (!ind[u])
Q.push(u);
}
}
}
}AC;
void read() {
cin>>n;
for (int i = 0; i < n; ++i) {
cin>>P[i];
AC.insert(P[i].data(), i + 1);
}
cin>>T;
}
void solve() {
AC.get_Fail();
AC.find(T.c_str());
AC.topocalc();
}
void print() {
for (int i = 0; i < n; ++i)
if (ans[i] >= 0)
cout<<ans[i]<<endl;
else
cout<<ans[-ans[i] - 1]<<endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
read();
solve();
print();
return 0;
}
后缀数组
#include <cstdio>
#include <iostream>
using namespace std;
int sa[maxn], l1[maxn], l2[maxn];
void build_SA(int n, int m, int *s) {
int c[maxn], *x = l1, *y = l2, p;
memset(c, 0, sezeof(c));
for (i = 0; i < n; ++i) c[s[i]]++;
for (i = 1; i < m; ++i) c[i] += c[i - 1];
for (i = n - 1; i >= 0; --i) x[--c[s[i]]] = s[i];
for (k = 1; k <= n; k <<= 1) {
p = 0;
for (i = 0; i < k; ++i) y[++p] = x[i];
for (i = 0; i < n - k; ++i)
if (x[i] >= k)
y[++p] = x[i] - k;
memset(c, 0, sizeof(c));
for (i = 0; i < n; ++i) c[x[i]]++;
for (i = 1; i < m; ++i) c[i] += c[i - 1];
for (i = n - 1; i >= 0; --i) sa[--c[x[y[i]]]] = x[y[i]];
swap(x, y);
p = 1;
x[sa[0]] = 0;
for (i = 0; i < n; ++i)
x[sa[i]] = y[sa[i - 1]] == y[sa[i]] && y[sa[i - 1] + k] == y[sa[i] + k] ? p - 1 : p++;
if (p >= n) break;
m = p;
}
return;
}
int main() {
char s[255],l;
scanf("%s", s);
l = strlen(s);
build_SA(l,s);
return 0;
}
后缀自动机
#include <iostream>
#include <cstring>
#include <string>
using namespace std;
const int sigma_size = 26, maxn = 1e6 + 1;
struct SAM {
struct Node {
int longest, fa;
int ch[sigma_size];
Node() {
memset(ch, 0, sizeof(ch));
longest = 0;
}
}am[maxn << 1];
int las = 1, cnt = 1;
int isnp[maxn << 1];
void insert(int c) {
int p = las, np = ++cnt;
las = np;
isnp[np] = 1;
am[np].longest = am[p].longest + 1;
for (; p && !am[p].ch[c]; p = am[p].fa) am[p].ch[c] = np;
if (!p) am[np].fa = 1;
else {
int q = am[p].ch[c];
if (am[q].longest == am[p].longest + 1) am[np].fa = q;
else {
int nq = ++cnt;
am[nq] = am[q];
am[np].fa = nq;
am[nq].longest = am[p].longest + 1;
am[q].fa = nq;
for (; p && am[p].ch[c] == q; p = am[p].fa) am[p].ch[c] = nq;
}
}
}
}AM;
long long ans;
int nxt[maxn << 2], head[maxn << 2], to[maxn << 2], cnt;
void Adde(int u, int v) {
//cout<<"Add:"<<u<<' '<<v<<endl;
to[++cnt] = v;
nxt[cnt] = head[u];
head[u] = cnt;
}
int dfs(int u) {
int x, sz = AM.isnp[u];
for (x = head[u]; x; x = nxt[x])
sz += dfs(to[x]);
if (sz != 1 && 1ll * sz * AM.am[u].longest > ans)
ans = 1ll * sz * AM.am[u].longest;
return sz;
}
signed main() {
int n, i;
string s;
cin>>s;
n = s.length();
for (i = 0; i < n; ++i) AM.insert(s[i] - 'a');
for (i = 1; i <= AM.cnt; ++i)
Adde(AM.am[i].fa, i);
dfs(1);
cout<<ans<<endl;
return 0;
}
Manacher
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 110001; //change this.
char s0[2 * maxn + 3],s[maxn];
int main() {
int i,l = 0,mx = 1,len[2 * maxn + 3] = { 0 },ans = 0,p = 1;
char ch;
freopen("in.txt", "r", stdin);
while ((ch = getchar())!= EOF)
s0[l++] = ch;
s0[l] = '\0';
s[0] = '$';
s[1] = '#';
for (i = 0; i < l; ++i) {
s[2 * (i + 1)] = s0[i];
s[2 * i + 3] = '#';
}
s[2 * i + 2] = '\0';
l = 2 * i + 1;
for (i = 1; i < l; ++i) {
if (i < mx)
len[i] = min(mx - i, len[2 * p - i]); //chu zhi!!!
else
len[i] = 1;
while (s[i + len[i]] == s[i - len[i]]) len[i]++;
if (i + len[i] > mx) {
mx = i + len[i];
p = i;
}
}
for (i = 1; i <= l; ++i)
if (ans < len[i])
ans = len[i];
printf("%d\n",ans - 1);
return 0;
}
回文自动机
#include <iostream>
#include <cstring>
#include <string>
using namespace std;
const int maxn = 5e5 + 1, sigma_size = 26;
int ans;
struct PAM {
int ch[maxn][sigma_size], fail[maxn], last, node[maxn], len[maxn], cnt, num[maxn];
void insert(string& s) {
int n = s.length();
//cout<<s<<endl;
fail[0] = 1;
len[1] = -1;
cnt = 1;
last = 0;
node[0] = '#';
for (int i = 1; i < n; ++i) {
int c = (s[i] - 97 + ans) % 26 + 97 - 'a', u;
s[i] = (char)c + 'a';
//cout<<s[i]<<' ';
while (s[i] != s[i - len[last] - 1]) last = fail[last]; //bu yong pd !u
if (!ch[last][c]) {
node[++cnt] = c;
len[cnt] = len[last] + 2;
u = fail[last]; //last2
while (s[i] != s[i - len[u] - 1]) u = fail[u];
fail[cnt] = ch[u][c]; //ch
ch[last][c] = cnt; //sequence!
num[ch[last][c]] = num[fail[cnt]] + 1;
}
last = ch[last][c];
ans = num[last];
cout<<ans<<' ';
}
return;
}
}P;
signed main() {
string s;
cin>>s;
s.insert(0, 1, '#');
P.insert(s);
return 0;
}
数论算法
Lucas
#include <iostream>
using namespace std;
int P,px[100001];
int qp(int x,int a) {
int ans = 1;
if (a == 0)
return 1;
while (a) {
if (a & 1)
ans = 1ll * ans * x % P;
x = 1ll * x * x % P;
a = a >> 1;
}
return ans;
}
int inv(int x) {
return qp(x, P - 2);
}
int C(int n,int m) {
if (n < m)
return 0;
return 1ll * px[n] * inv(px[n - m]) * inv(px[m]) % P;
}
int Lucas(int n,int m) {
if (m == 0)
return 1;
return 1ll * C(n % P, m % P) * Lucas(n / P, m / P) % P;
}
int main() {
int n,m,i,T;
cin>>T;
while (T--) {
cin>>n>>m>>P;
px[0] = 1;
for (i = 1; i < P; ++ i)
px[i] = 1ll * px[i-1] * i % P;
cout<<Lucas(n + m, m)<<endl;
}
return 0;
}
exLucas
#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;
long long n, m;
int P;
int C(long long int n, long long int m, int p, int pk);
int fac(long long int n, int p, int pk);
int CRT(int a, int m);
int inv (int m, int p);
void exgcd(int a, int b, long long int &x, long long int &y);
int main() {
int pk, i, p, k;
long long ans = 0;
cin>>n>>m>>P;
p = P;
k = sqrt(p + 0.5);
for (i = 2;i <= k; ++i)
if (p % i == 0) {
pk = 1;
while (p % i == 0) {
pk *= i;
p /= i;
}
ans = (ans + 1ll * CRT(C(n, m, i, pk), P / pk)) % P;
}
if (p != 1)
ans = (ans + 1ll * CRT(C(n, m, p, p), P / p)) % P;
cout<<ans<<endl;
return 0;
}
int ksm(int x, long long int n, int p) {
int ans = 1;
while (n) {
if (n & 1)
ans = 1ll * ans * x % p;
n >>= 1;
x = 1ll * x * x % p;
}
return ans;
}
int C(long long int n, long long int m, int p, int pk) {
long long int k = 0;
long long int i;
if (n < m) //Important.Habit
return 0;
for (i = n; i; i /= p)
k += i / p;
for (i = m; i; i /= p)
k -= i / p;
for (i = n - m; i; i /= p)
k -= i / p;
return 1ll * fac(n, p, pk) * inv(1ll * fac(m, p, pk) * fac(n - m, p, pk) % pk, pk) % pk * ksm(p, k, pk) % pk;
}
int fac(long long int n, int p, int pk) {
int ans = 1;
register int i;
if (!n)
return 1;
for (i = 1; i <= pk; ++i)
if (i % p)
ans = 1ll * ans * i % pk;
ans = ksm(ans, n / pk, pk);
for (i = 1; i <= n % pk; ++i)
if (i % p)
ans = 1ll * ans * i % pk;
return 1ll * ans * fac(n / p, p, pk) % pk;
}
int CRT(int a, int m) {
return 1ll * a * m % P * inv(m, P / m) % P;
}
int inv (int m, int p) {
long long int x, y;
exgcd(m, p, x, y);
return (x + p) % p;
}
void exgcd(int a, int b, long long int &x, long long int &y) {
int t;
if (b == 0) {
if (a != 1)
printf("Error.\n");
y = 0;
x = 1;
return;
}
exgcd(b, a % b, x, y);
t = x;
x = y;
y = t - a / b * y;
return;
}
Eular函数
int euler_phi(int n) {
int m=(int)sqrt(n+0.5);
int ans=n;
for (int i=2;i<=m;++i)
if (n%i==0) {
ans=ans/i*(i-1);
while (n%i==0) n/=i;
}
if (n>1) ans=ans/n*(n-1);
}
int phi[maxn];
void phi_table(int n) {
for (int i=2;i<=n;++i) phi[i]=0;
phi[1]=1;
for (int i=2;i<=n;++i)
if (!phi[i])
for (int j=i;j<=n;j+=i) {
if (!phi[j])
phi[j]=j;
phi[j]=phi[j]/i*(i-1);
}
}
BSGS
int log_mod(int a,int b,int n) {
int m,v,e=1,i;
m=(int)sprt(n+0.5);
v=inv(pow_mod(a,m,n),n);
map <int,int>x;
x[1]=0;
for (i=1;i<m;++i) {
e=mul_mod(e,a,n);
if (!x.count(e)) x[e]=i;
}
for (i=0;i<m;++i) {
if (x.count(b)) return i*m+x[b];
b=mul_mod(b,v,n);
}
return -1;
}
扩展的中国剩余定理
/*When using ExCluid, mind a large prime, better use gcd and divide.*/
#include <cstdio>
#include <utility>
#include <iostream>
#define ll long long int
using namespace std;
const int maxn = 1e5 + 1;
pair <ll, ll> P;
long long tmp;
void exgcd(long long int a, long long b, long long ans) {
if (b == 0) {
P.first = ans / a;
P.second = 0;
}
else {
exgcd(b, a % b, ans);
tmp = P.second;
P.second = P.first - a / b * P.second;
P.first = tmp;
}
return;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll Gui_mul(ll x, ll n, ll mod) {
ll ret = 0;
int f = 1;
if (n < 0) {
f = -1;
n = -n;
}
while (n) {
if (n & 1)
ret = (ret + x) % mod;
n >>= 1;
x = (x << 1) % mod;
}
return ret * f;
}
template <typename T>void gint(T& x) {
char ch = getchar();
x = 0;
while (ch < '0' || ch > '9')
ch = getchar();
while (ch >= '0' && ch <= '9') {
x = 10 * x + (ch ^ 48);
ch = getchar();
}
return;
}
int main() {
int n, i;
ll m[maxn], a[maxn], lcm, t, Gcd;
gint(n);
for (i = 1;i <= n; ++i) {
gint(m[i]);
gint(a[i]);
}
for (i = 2;i <= n; ++i) {
Gcd = gcd(m[i], m[i - 1]);
lcm = m[i] / Gcd * m[i - 1];
t = a[i] - a[i - 1];
exgcd(m[i - 1], m[i], Gcd);
a[i] = (Gui_mul(Gui_mul(P.first, t / Gcd, m[i]), m[i - 1], lcm) + a[i - 1]) % lcm;
m[i] = lcm;
if (a[i] < 0)
a[i] = (a[i] + m[i]) % m[i];
}
cout<<a[n]<<endl;
return 0;
}
高斯消元
#include <cstdio>
#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
const int maxn = 101;
typedef double Matrix[maxn][maxn];
int gauss_elimination(Matrix& A, int n) {
int i, j, k, r;
for (i = 0; i < n; ++i) {
r = i;
for (j = i + 1; j < n; ++j)
if (fabs(A[j][i])>fabs(A[r][i]))
r = j;
if (r != i)
for (j = i; j <= n; ++j)
swap(A[r][j], A[i][j]);
if (fabs(A[i][i]) < 1e-10)
return -1;
for (j = n; j >= i; --j)
for (k = i + 1; k < n; ++k)
A[k][j] -= A[k][i] / A[i][i] * A[i][j]; // -=
}
for (i = n - 1; i >= 0; --i) {
for (j = n - 1; j > i; --j)
A[i][n] -= A[j][n] * A[i][j];
A[i][n] /= A[i][i];
}
return 0;
}
int main() {
int n, i, j;
Matrix A;
cin>>n;
for (i = 0; i < n; ++i)
for (j = 0; j <= n; ++j)
cin>>A[i][j];
if (!gauss_elimination(A, n))
for (i = 0; i < n; ++i)
cout<<fixed<<setprecision(2)<<A[i][n]<<endl;
else
cout<<"No Solution"<<endl;
return 0;
}
拉格朗日插值法
ans = 0;
for (i = 1; i <= n; ++i) {
tmp = y[i];
mot = 1;
for (j = 1; j <= n; ++j)
if (j != i) {
tmp = tmp * (k - x[j]) % mod;
mot = mot * (x[i] - x[j]) % mod;
}
ans = (ans + tmp * inv(mot)) % mod;
}
cout<<(ans + mod) % mod<<endl;
Mobius
mu[1] = 1;
for (register int i = 2; i < maxn; ++i) {
if(!isnp[i]) {
prime[cnt++] = i;
mu[i] = -1;
}
for (register int j = 0; j < cnt && i * prime[j] < maxn; ++j) {
isnp[i * prime[j]] = 1;
if (i % prime[j] == 0)
break;
mu[i * prime[j]] = -mu[i];
}
}
除法分块
#include <cstdio>
#include <iostream>
using namespace std;
int main() {
int n, k, L, R, m;
long long ans = 0;
scanf("%d%d", &n, &k);
m = min(n, k);
for (L = 1; L <= m; L = R + 1) {
R = min(k / (k / L), m);
ans += (1ll * (R - L + 1) * (k % L + k % R) / 2);
}
if (n > k)
ans += 1ll * k * (n - k);
printf("%I64d\n", ans);
return 0;
}
FFT
#include <cstdio>
#include <complex>
#include <iostream>
#include <cmath>
using namespace std;
const int maxn = 601;
const double PI = acos(-1);
int rev[maxn << 1], L;
void FFT(complex <double> *A, int len, int opt) {
int i, j, k;
complex <double> wn, w, t;
for (i = 0; i < len; ++i)
if (i < rev[i])
swap(A[i], A[rev[i]]);
for (i = 1; i < len; i <<= 1) {
wn = complex <double> (cos(PI / i), opt * sin(PI / i));
for (j = 0; j < len; j += i * 2) {
w = complex <double> (1, 0);
for (k = 0; k < i; ++k) {
t = w * A[j + i + k];
A[j + k + i] = A[j + k] - t; //
A[j + k] = A[j + k] + t;
w = w * wn;
}
}
}
return;
}
int main() {
int i, len = 1, n, ans[maxn << 1] = { 0 };
complex <double> A1[maxn << 1], A2[maxn << 1];
char ch;
cin>>n;
while (len < 2 * n) {
++L;
len <<= 1;
}
for (i = 0; i < len; ++i)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1)<< (L - 1)); //
ch = getchar();
while (ch < '0' || ch > '9')
ch = getchar();
A1[n - 1] = ch ^ 48;
for (i = n - 2; i >= 0; --i)
A1[i] = getchar() ^ 48;
ch = '0' - 1;
while (ch < '0' || ch > '9')
ch = getchar();
A2[n - 1] = ch ^ 48;
for (i = n - 2; i >= 0; --i)
A2[i] = getchar() ^ 48;
for (i = n; i < len; ++i) {
A1[i] = 0;
A2[i] = 0;
}
FFT(A1, len, 1);
FFT(A2, len, 1);
for (i = 0; i < len; ++i) //
A1[i] = A1[i] * A2[i];
FFT(A1, len, -1);
for (i = 0; i < len; ++i) {
ans[i] += (int)(real(A1[i]) / len + 0.1);// +0.1;+=
if (ans[i] >= 10) {
ans[i + 1] += ans[i] / 10;
ans[i] = ans[i] % 10;
}
}
while (len > 1)
if (ans[len - 1])
break;
else
len--;
while (len--)
printf("%d", ans[len]);
putchar('\n');
return 0;
}
数据结构
树状数组（区间修改，区间查询）
int vdi[maxn],vd[maxn];
int lowbit(int x) {
return x&(-x);
}
void _add(int x,int vl,int *C) {
while (x<=N + 1) {
C[x]=(0ll + C[x]+vl)%P;
x+=lowbit(x);
}
return;
}
int _sum(int x,int *C) {
int ret=0;
while (x>0) {
ret=(0ll + ret+C[x])%P;
x-=lowbit(x);
}
return ret;
}
void add(int x,int y,int vl) {
if (x==0||y==0) {
return;
}
_add(x,vl,vd);
_add(y+1,P -vl,vd); //-vl
_add(x,1ll * vl*x % P,vdi);
_add(y+1,1ll * (P - vl)*(y+1) % P,vdi);
return;
}
int sum(int x) { //Erred.
return (P+1ll * _sum(x,vd)*(x+1)-_sum(x,vdi))%P;
}
int ask(int x,int y) {
return (0ll+P+sum(y)-sum(x-1))%P;
}
线段树
#include <iostream>
#include <cstdio>
using namespace std;
/* setv != -1 */
const int maxn = 500001 * 2 + 1, INF = 0x7f7f7f7f;
int minv[maxn], maxv[maxn], sumv[maxn], setv[maxn], addv[maxn];
int ql, qr, v, p, _min, _max, _sum; //A[p] = v
void query(int o, int L, int R, int add);
void pushdown(int o);
void maintain(int o, int L, int R);
void updates(int o, int L, int R); //xian set hou add;
void updatea(int o, int L, int R);
int main() {
int n, i, opt;
cin>>n;
for (i = 1; i <= n; ++i) {
cin>>v;
ql = qr = i;
updates(1, 1, n);
}
for (i = 1; i <= 5; ++i) {
cin>>opt>>ql>>qr;
_sum = 0;
_min = INF;
_max = -INF;
switch (opt) {
case 0: cin>>v; updates(1, 1, n); break;
case 1: cin>>v; updatea(1, 1, n); break;
case 2: query(1, 1, n, 0); cout<<_min<<' '<<_max<<' '<<_sum<<endl;
}
}
return 0;
}
void query(int o, int L, int R, int add) { //add shang wu set
if (setv[o] != -1) {
_sum += (setv[o] + add + addv[o]) * (min(qr, R) - max(ql, L) + 1);
_min = min(_min, setv[o] + add + addv[o]);
_max = max(_max, setv[o] + add + addv[o]);
}
else
if (ql <= L && qr >= R) {
_sum += sumv[o] + add * (R - L + 1);
_min = min(_min, minv[o] + add);
_max = max(_max, maxv[o] + add);
}
else {
int lc = 2 * o, rc = 2 * o + 1, M = L + (R - L) / 2;
if (ql <= M)
query(lc, L, M, add + addv[o]);
if (qr > M)
query(rc, M + 1, R, add + addv[o]);
}
return;
}
void updates(int o, int L, int R) { //set qian wu add, set shang ke you add.
if (L >= ql && qr >= R) {
setv[o] = v;
addv[o] = 0;
}
else {
int lc = 2 * o, rc = 2 * o + 1, M = L + (R - L) / 2;
pushdown(o);
if (ql <= M)
updates(lc, L, M);
else
maintain(lc, L, M);
if (qr > M)
updates(rc, M + 1, R);
else
maintain(rc, M + 1, R);
}
maintain(o, L, R);
return;
}
void updatea(int o, int L, int R) {
if (L >= ql && qr >= R)
addv[o] += v;
else {
int lc = 2 * o, rc = 2 * o + 1, M = L + (R - L) / 2;
pushdown(o);
if (ql <= M)
updatea(lc, L, M);
else
maintain(lc, L, M);
if (qr > M)
updatea(rc, M + 1, R);
else
maintain(rc, M + 1, R);
}
maintain(o, L, R);
return;
}
void pushdown(int o) {
int lc = 2 * o, rc = 2 * o + 1;
if (setv[o] == -1) {
addv[lc] += addv[o];
addv[rc] += addv[o];
}
else {
setv[lc] = setv[rc] = setv[o] + addv[o];
addv[lc] = 0; addv[rc] = 0;
}
addv[o] = 0;
setv[o] = -1;
}
void maintain(int o, int L, int R) {
int lc = 2 * o, rc = 2 * o + 1;
if (setv[o] != -1) {
sumv[o] = setv[o] * (R - L + 1);
minv[o] = setv[o];
maxv[o] = setv[o];
}
else
if (L < R) {
sumv[o] = sumv[lc] + sumv[rc];
minv[o] = min(minv[lc], minv[rc]);
maxv[o] = max(maxv[lc], maxv[rc]);
}
sumv[o] += addv[o] * (R - L + 1);
minv[o] += addv[o];
maxv[o] += addv[o];
return;
}
主席树
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 2e5 + 1;
int a[maxn], b[maxn], tot, p, v;
int cnt, C[maxn << 5], rt[maxn], lc[maxn << 5], rc[maxn << 5];
int build(int L, int R) {
int mid = L + (R - L) / 2, u = cnt++;
if (L == R) {
C[u] = 0;
return u;
}
lc[u] = build(L, mid);
rc[u] = build(mid + 1, R);
return u;
}
int update(int o, int L = 1, int R = tot) {
int mid = L + (R - L) / 2, u = cnt++;
if (L == R) {
C[u] = C[o] + v;
return u;
};
lc[u] = lc[o]; rc[u] = rc[o];
if (p <= mid) lc[u] = update(lc[u], L, mid);
else rc[u] = update(rc[u], mid + 1, R);
C[u] = C[lc[u]] + C[rc[u]];
return u;
}
int query(int o1, int o2, int k, int L = 1, int R = tot) {
int mid = L + (R - L) / 2;
if (L == R) return mid;
if (k <= C[lc[o2]] - C[lc[o1]]) return query(lc[o1], lc[o2], k, L, mid);
else return query(rc[o1], rc[o2], k - (C[lc[o2]] - C[lc[o1]]), mid + 1, R);
}
signed main() {
int n, m, i, l, r, k;
freopen("testdata.in", "r", stdin);
freopen("my.out", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin>>n>>m;
for (i = 0; i < n; ++i) {
cin>>a[i];
b[i] = a[i];
}
sort(b, b + n);
tot = unique(b, b + n) - b;
rt[0] = build(1, tot);
v = 1;
for (i = 0; i < n; ++i) {
p = lower_bound(b, b + tot, a[i]) - b + 1;
rt[i + 1] = update(rt[i]);
}
while (m--) {
cin>>l>>r>>k;
cout<<b[query(rt[l - 1], rt[r], k) - 1]<<endl;
}
fclose(stdin);
fclose(stdout);
return 0;
}
Treap
#include <iostream>
#include <cstdlib>
using namespace std;
const int maxn = 1e5 + 1, INF = 0x7f7f7f7f;
int size[maxn], v[maxn], fix[maxn], son[maxn][2], num[maxn], cnt, R;
void pushup(int p) {
size[p] = size[son[p][0]] + size[son[p][1]] + num[p];
return;
}
void rotate(int &p, int dir) {
int t = son[p][dir];
son[p][dir] = son[t][dir ^ 1];
son[t][dir ^ 1] = p;
p = t;
pushup(son[p][0]);
pushup(son[p][1]);
return;
}
void ins(int &p, int x) {
if (!p) {
p = ++cnt;
v[p] = x;
num[p] = 1;
size[p] = 1;
fix[p] = rand();
return;
}
if (v[p] == x) {
num[p]++;
size[p]++;
return;
}
int d = (x > v[p]);
ins(son[p][d], x);
if ((fix[p] < fix[son[p][d]]) != d)
rotate(p, d);
pushup(p);
}
void del(int &p, int x) {
if (!p) {
cout<<"Not exist."<<endl;
return;
}
if (v[p] > x)
del(son[p][0], x);
if (v[p] < x)
del(son[p][1], x);
if (v[p] == x) {
if (!son[p][0] && !son[p][1]) {
num[p]--;
if (num[p] == 0)
p = 0;
}
else if (!son[p][0] && son[p][1]) {
rotate(p, 1);
del(son[p][0], x);
}
else if (son[p][0] && !son[p][1]) {
rotate(p, 0);
del(son[p][1], x);
}
else if (num[p] > 1)
num[p]--;
else {
int d = (fix[son[p][0]] < fix[son[p][1]]);
rotate(p, d);
del(son[p][d ^ 1], x);
}
}
pushup(p);
return;
}
int getrank(int p, int x) {
if (!p)
return 0;
if (v[p] == x)
return size[son[p][0]] + 1;
if (v[p] > x)
return getrank(son[p][0], x);
else
return size[son[p][0]] + num[p] + getrank(son[p][1], x);
}
int getnum(int p, int r) {
int left = size[son[p][0]];
if (!p)
return -1;
if (left >= r)
return getnum(son[p][0], r);
if (left < r && left + num[p] >= r)
return v[p];
else
return getnum(son[p][1], r - left - num[p]);
}
int getpre(int p, int x) {
if (!p)
return -INF;
if (v[p] >= x)
return getpre(son[p][0], x);
else
return max(v[p], getpre(son[p][1], x));
}
int getsuf(int p, int x) {
if (!p)
return INF;
if (v[p] <= x)
return getsuf(son[p][1], x);
else
return min(v[p], getsuf(son[p][0], x));
}
int main() {
int n, opt, x;
ios_base::sync_with_stdio(false);
cin.tie(nullptr);cout.tie(nullptr);
cin>>n;
while (n--) {
cin>>opt>>x;
switch (opt) {
case 1:ins(R, x);break;
case 2:del(R, x);break;
case 3:cout<<getrank(R, x)<<endl;break;
case 4:cout<<getnum(R, x)<<endl;break;
case 5:cout<<getpre(R, x)<<endl;break;
case 6:cout<<getsuf(R, x)<<endl;break;
}
}
return 0;
}
Splay
#include <iostream>
#include <iterator>
#include <algorithm>
#include <cstdlib>
using namespace std;
const int maxn = 1e5 + 5;
int n;
int ch[maxn][2], fa[maxn], size[maxn], num[maxn], cnt, R, v[maxn], rev[maxn];
void pushdown(int x) {
if (rev[x]) {
swap(ch[x][0], ch[x][1]);
rev[ch[x][0]] ^= 1;
rev[ch[x][1]] ^= 1;
rev[x] = 0;
}
}
void pushup(int x) {
size[x] = num[x] + size[ch[x][0]] + size[ch[x][1]];
}
int kth(int k) {
int cur = R;
if (k > cnt)
cout<<"Err"<<endl;
while (1) {
pushdown(cur);
if (ch[cur][0] && k <= size[ch[cur][0]])
cur = ch[cur][0];
else if (k > size[ch[cur][0]] + num[cur]) {
k -= (size[ch[cur][0]] + num[cur]);
cur = ch[cur][1];
}
else
return cur;
}
}
void output(int x) {
pushdown(x);
if (ch[x][0]) output(ch[x][0]);
if (num[x] != 0 && v[x] <= n && v[x] >= 1)
for (int i = 1; i <= num[x]; ++i)
cout<<v[x]<<' ';
if (ch[x][1]) output(ch[x][1]);
}
void rotate(int x) {
int d = (ch[fa[x]][1] == x), p = fa[x];
pushdown(p);
pushdown(x);
fa[x] = fa[p];
if (fa[p])
ch[fa[p]][ch[fa[p]][1] == p] = x;
ch[p][d] = ch[x][d ^ 1];
if (ch[x][d ^ 1])
fa[ch[x][d ^ 1]] = p;
ch[x][d ^ 1] = p;
fa[p] = x;
pushup(x);
pushup(p);
return;
}
void splay(int x, int goal = 0) {
while (fa[x] != goal) {
int y = fa[x], z = fa[y];
pushdown(z);
pushdown(y);
if (z != goal) {
if ((ch[fa[x]][1] == x) == (ch[fa[y]][1] == y))
rotate(y);
else
rotate(x);
}
rotate(x);
}
if (!goal)
R = x;
}
void insert(int val) {
int cur = R, p = fa[cur];
while (cur && v[cur] != val) {
p = cur;
cur = ch[cur][val > v[cur]];
}
if (cur) {
num[cur]++;
size[cur++];
}
else {
cur = ++cnt;
if (p)
ch[p][val > v[p]] = cur;
v[cur] = val;
fa[cur] = p;
num[cur] = size[cur] = 1;
}
splay(cur);
}
void find(int val) {
if (!R)
return;
int cur = R;
while (v[cur] != val && ch[cur][v[cur] < val])
cur = ch[cur][v[cur] < val]; //
splay(cur);
}
void reverse(int l, int r) {
int x = kth(l - 1), y = kth(r + 1);
splay(x);
splay(y, x);
rev[ch[y][0]] ^= 1;
}
int pre(int val) {
find(val);
if (v[R] < val)
return R;
int cur = ch[R][0];
while (ch[cur][1]) //
cur = ch[cur][1];
return cur;
}
int suc(int val) {
find(val);
if (v[R] > val)
return R;
int cur = ch[R][1];
while (ch[cur][0])
cur = ch[cur][0];
return cur;
}
void remove(int val) {
int nxt = suc(val), lst = pre(val);
splay(lst);
splay(nxt, lst);
int del = ch[lst][0];
if (num[del] > 1) {
num[del]--;
rotate(del);
}
else {
ch[nxt][0] = 0;
rotate(nxt);
}
return;
}
int buildtree(int x, int y, int fat) {
int mid = x + (y - x) / 2;
if (x < mid) {
ch[mid + 1][0] = buildtree(x, mid - 1, mid + 1);
size[mid + 1] += size[ch[mid + 1][0]];
}
size[mid + 1] += 1;
num[mid + 1] = 1;
v[mid + 1] = mid;
fa[mid + 1] = fat;
if (mid < y) {
ch[mid + 1][1] = buildtree(mid + 1, y, mid + 1);
size[mid + 1] += size[ch[mid + 1][1]];
}
return mid + 1;
}
int main() {
int m, x, y;
ios_base::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
cin>>n>>m;
R = buildtree(0, n + 1, 0);
cnt = n + 2;
while (m--) {
cin>>x>>y;
reverse(x + 1, y + 1);
}
output(R);
return 0;
}
图论
Dijkstra
#include <cstdio>
#include <iostream>
#include <queue>
using namespace std;
const int maxn=100001,INF=1e9;
struct Edge {
int from,to,dist;
Edge(int u,int v,int d):
from(u),
to(v),
dist(d){}
};
struct Dijkstra {
int n;
vector <Edge> edges;
vector <int> G[maxn];
int d[maxn];
Dijkstra(int n1) {
n=n1;
for (int i=1;i<=n;++i)
d[i]=INF;
edges.clear();
for (int i=1;i<=n;++i)
G[i].clear();
return;
}
void AddEdge(int u,int v,int dist) {
edges.push_back((Edge) (u,v,dist));
G[u].push_back(edges.size()-1);
return;
}
struct HeapNode{
int u,d;
void HeapNode(int m,int k):
u(m),
d(k) {}
bool operator <(const HeapNode& rhs) const {
return d<rhs.d;
}
};
void dijkstra(int S) {
priority_queue <HeapNode> Q;
d[S]=0;
Q.push((HeapNode) (S,0));
while (!Q.empty()) {
HeapNode x=Q.top();Q.pop();
if (x.d!=d[u]) continue;
int u=x.u,sz=G[u].size();
for (int j=0;j!=sz;++j) {
Edge& e=edges[G[u][j]];
if (d[e.to]>d[u]+e.dist) {
d[e.to]=d[u]+e.dist;
Q.push(HeapNode (e.to,d[e.to]));
}
}
}
return;
}
};
int main() {
int N,M,S,u,v,w;
cin>>N>>M>>S;
Dijkstra D(N);
for (int i=1;i<=M;++i) {
cin>>u>>v>>w;
D.AddEdge(u,v,w);
}
D.dijkstra(S);
for (int i=1;i<=N;++i)
cout<<D.d[i]<<' ';
return 0;
}
Bellman-Ford
const int maxn=100,maxm=1000;
void Bellman-Ford(int n,int m,int S) {
int w[maxn],u[maxn],v[maxn],i,j;
for (i=1;i<=m;++i)
cin>>w[i]>>u[i]>>v[i];
for (k=1;k<n;++k)
for (i=1;i<=m;++i) {
int x=u[i],y=v[i];
if (d[x]<INF)
d[y]=min(d[y],d[x]+w[i]);
}
}
Floyd
树
LCA
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn=500001,maxm=maxn*2;
int neext[maxm],to[maxm],head[maxn],cnt,
p[maxn][21],deep[maxn],lg[21];
void add(int x,int y) {
to[++cnt]=y;
neext[cnt]=head[x];
head[x]=cnt;
return;
}
int LCA(int x,int y) {
int i;
if (deep[x]<deep[y]) swap(x,y);
while (deep[x]>deep[y])
x=p[x][lg[deep[x]-deep[y]]-1];
if (x==y) return x;
for (i=lg[deep[x]]-1;i>=0;--i)
if (p[x][i]!=p[y][i]) {
x=p[x][i];
y=p[y][i];
}
if (p[x][0]==p[y][0]) return p[x][0];
return -1;
}
void dfs(int n,int d) {
for (int i=head[n];i;i=neext[i]) {
int x=to[i];
if (!deep[x]) {
deep[x]=d+i; //tiao zheng shun xu,hou dfs.
p[x][0]=n;
dfs(x,d+1);
}
}
return;
}
int main() {
int N,M,S,x,y,i,j;
scanf("%d%d%d",&N,&M,&S);
for (i=1;i<=N;++i)
lg[i]=lg[i-1]+(1<<lg[i-1]==i); //
for (i=1;i<N;++i) {
scanf("%d%d",&x,&y);
add(x,y);
add(y,x);
}
p[S][0]=S;
deep[S]=1;
dfs(S,0);
for (j=1;j<=20;++j)
for (i=1;i<=N;++i)
p[i][j]=p[p[i][j-1]][j-1];
printf("aa%daa",p[5][0]);
for (i=1;i<=M;++i) {
scanf("%d%d",&x,&y);
printf("%d\n",LCA(x,y));
}
return 0;
}
树链剖分
//BIT when * yao qu moooooooooooooooooo * 6 months.
#include <cstdio>
#include <cassert>
using namespace std;
const int maxn=(int)1e5+1;
int N,R,P;
int nxt[maxn*2],to[maxn*2],head[maxn],cnt;
int size[maxn],fa[maxn],id[maxn],cntid,deep[maxn],son[maxn],rank[maxn],top[maxn];
int vdi[maxn],vd[maxn];
int Rint(int &x) {
char ch=getchar();
x=0;
while (ch<'0'||ch>'9')
ch=getchar();
while (ch>='0'&&ch<='9') {
x=x*10+(ch^48);
ch=getchar();
}
return x;
}
int lowbit(int x) {
return x&(-x);
}
void _add(int x,int vl,int *C) {
while (x<=N + 1) {
C[x]=(0ll + C[x]+vl)%P;
x+=lowbit(x);
}
return;
}
int _sum(int x,int *C) {
int ret=0;
while (x>0) {
ret=(0ll + ret+C[x])%P;
x-=lowbit(x);
}
return ret;
}
void add(int x,int y,int vl) {
if (x==0||y==0) {
return;
}
_add(x,vl,vd);
_add(y+1,P -vl,vd); //-vl
_add(x,1ll * vl*x % P,vdi);
_add(y+1,1ll * (P - vl)*(y+1) % P,vdi);
return;
}
int sum(int x) { //Erred.
return (P+1ll * _sum(x,vd)*(x+1)-_sum(x,vdi))%P;
}
int ask(int x,int y) {
return (0ll+P+sum(y)-sum(x-1))%P;
}
void Adde(int u,int v) {
to[++cnt]=v;
nxt[cnt]=head[u];
head[u]=cnt;
return;
}
void dfs1(int x) {
int i,t;
size[x]=1;//woc
deep[x]=deep[fa[x]]+1;
for (i=head[x];i;i=nxt[i]) {
t=to[i];
if (t!=fa[x]) {
fa[t]=x;
dfs1(t);
size[x]+=size[t];
if (size[son[x]]<size[t]) //kuo hao.
son[x]=t;
}
}
return;
}
void dfs2(int x,int t) {
int i,tto;
id[x]=++cntid;
rank[cntid]=x;
top[x]=t;
if (!son[x])
return;
dfs2(son[x],t);
for (i=head[x];i;i=nxt[i]) {
tto=to[i];
if (tto!=fa[x]&&tto!=son[x])
dfs2(tto,tto);
}
return;
}
void addpath(int x,int y,int vl) {
while (top[x]!=top[y])
if (deep[top[x]]>deep[top[y]]) {
add(id[top[x]],id[x],vl);
x=fa[top[x]];
}
else {
add(id[top[y]],id[y],vl);
y=fa[top[y]];
}
if (id[x]<=id[y]) //same Hchain.
add(id[x],id[y],vl);
else
add(id[y],id[x],vl);
return;
}
int askpath(int x,int y) {
long long ret=0;
while (top[x]!=top[y]) {
if (deep[top[x]]>deep[top[y]]) {
ret+=ask(id[top[x]],id[x]);
x=fa[top[x]];
}
else {
ret+=ask(id[top[y]],id[y]);
y=fa[top[y]];
}
ret%=P;
}
if (deep[x]>deep[y])
ret+=ask(id[y],id[x]);
else
ret+=ask(id[x],id[y]);
return (int)(ret%P);
}
signed main() {
int i,M,u,v,op,x,y,z,v0[maxn];
//freopen("testdata.in", "r", stdin);
//freopen("my.out", "w", stdout);
Rint(N);Rint(M);Rint(R);Rint(P);
for (i=1;i<=N;++i) {
Rint(v0[i]);
}
for (i=1;i<N;++i) {
Rint(u);Rint(v);
Adde(u,v);
Adde(v,u);
}
dfs1(R);
dfs2(R,R);
for (i=1;i<=N;++i)
add(id[i],id[i],v0[i]);
while (M--) {
Rint(op);
switch (op) {
case 1:
Rint(x);Rint(y);Rint(z);
addpath(x,y,(0ll+P + z)%P); //
break;
case 2:
Rint(x);Rint(y);
printf("%d\n",askpath(x,y));
break;
case 3:
Rint(x);Rint(z);
add(id[x],id[x]+size[x]-1,(0ll+P + z)%P);//
break;
case 4:
Rint(x);
printf("%d\n",ask(id[x],id[x]+size[x]-1));
}
}
//fclose(stdin);
//fclose(stdout);
return 0;
}
树上点分治
#include <iostream>
using namespace std;
const int maxn = 2e4 + 1;
int nxt[maxn << 1], head[maxn], to[maxn << 1], w[maxn << 1], ecnt;
int ans, rt, d[3], mnsz, sz[maxn], vis[maxn], tot;
int vv[maxn];
void AddE(int u, int v, int le) {
to[++ecnt] = v;
w[ecnt] = le;
nxt[ecnt] = head[u];
head[u] = ecnt;
return;
}
int getroot(int u, int fa) {
static int cnt = 0;
cnt++;
if (vv[u])
cout<<"Visited! @"<<u<<", fa = "<<fa<<endl;
vv[u] = 1;
int mx = 0;
sz[u] = 1;
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (vis[v] || v == fa)
continue;
sz[u] += getroot(v, u);
mx = max(mx, sz[v]);
}
mx = max(mx, tot - sz[u]);
if (mx < mnsz) {
rt = u;
mnsz = mx;
}
cnt--;
vv[u] = 0;
return sz[u];
}
void getd(int u, int fa, int dis) {
d[dis % 3]++;
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (vis[v] || v == fa) continue;
getd(v, u, (dis + w[i]) % 3);
}
}
int getans(int u, int dis) {
d[0] = d[1] = d[2] = 0;
getd(u, -1, dis);
return d[0] * d[0] + d[1] * d[2] * 2;
}
void solve(int u) {
vis[u] = 1;
ans += getans(u, 0);
for (int x = head[u]; x; x = nxt[x]) {
int v = to[x];
if (vis[v])
continue;
ans -= getans(v, w[x]);
mnsz = tot = sz[v]; rt = 0; getroot(v, -1);
solve(rt);
}
return;
}
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int vid[maxn], id[maxn], cc;
void test(int u, int fa) {
if (vid[u] == 1) {
cout<<"Err "<<cc<<endl;
for (int i = 1; i <= cc; ++i)
cout<<id[i]<<' ';
return;
}
vid[u] = 1;
id[++cc] = u;
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v != fa)
test(v, u);
}
return;
}
signed main() {
int n, u, v, i, t, ww;
#ifndef ONLINE_JUDGE
freopen("testdata.in", "r", stdin);
#endif
cin>>n;
for (i = 0; i < n - 1; ++i) {
cin>>u>>v>>ww;
ww = ww % 3;
AddE(u, v, ww); AddE(v, u, ww);
}
test(1, -1);
mnsz = tot = n; getroot(1, -1);
t = gcd(ans, n * n);
cout<<ans / t<<'/'<<n * n / t<<endl;
return 0;
}
CV-BCC 无向图的双连通分量
#include <iostream>
#include <stack>
#include <vector>
#include <algorithm>
using namespace std;
const int maxn = 2e4 + 1;
int dfs_clock, pre[maxn], iscut[maxn], bccno[maxn], bcc_count;
struct Edge {
int u, v;
};
vector <int> bcc[maxn], G[maxn];
stack <Edge> S;
void AddE(int u, int v) {
G[u].push_back(v);
}
int tarjan(int u, int fa) {
int lowu = pre[u] = ++dfs_clock, child = 0;
for (auto v: G[u]) {
if (!pre[v]) {
child++;
S.push((Edge) {u, v});
int lowv = tarjan(v, u);
lowu = min(lowu, lowv);
if (lowv >= pre[u]) {
iscut[u] = 1;
++bcc_count;
bcc[bcc_count].clear();
//cout<<dfs_clock<<' '<<u<<'>'<<v<<','<<lowv<<'|'<<bcc_count<<endl;
while (1) {
Edge e = S.top(); S.pop();
if (bccno[e.u] != bcc_count) {
bcc[bcc_count].push_back(e.u);
bccno[e.u] = bcc_count;
}
if (bccno[e.v] != bcc_count) {
bcc[bcc_count].push_back(e.v);
bccno[e.v] = bcc_count;
}
if (e.u == u && e.v == v) break;
}
}
} else if (pre[v] < pre[u] && v != fa) {
S.push((Edge) {u, v});
lowu = min(lowu, pre[v]); //Err
}
}
if (fa == -1 && child == 1) iscut[u] = 0; //Err
return lowu;
}
signed main() {
int n, m, u, v, i;
cin>>n>>m;
while (m--) {
cin>>u>>v;
AddE(u, v);
AddE(v, u);
}
for (i = 1; i <= n; ++i)
if (!pre[i])
tarjan(i, -1);
cout<<count(iscut + 1, iscut + n + 1, 1)<<endl;
for (i = 1; i <= n; ++i)
if (iscut[i])
cout<<i<<' ';
return 0;
}
SCC 有向图的强连通分量
#include <iostream>
#include <vector>
#include <stack>
using namespace std;
const int maxn = 1e4 + 1;
int n;
int pre[maxn], dfs_clock, sccno[maxn], scc_count;
int c[maxn], topo[maxn];
vector <int> G[maxn], GA[maxn], scc[maxn];
stack <int> S;
void AddE(int u, int v) {
G[u].push_back(v);
}
void AddED(int u, int v) {
//cout<<"Add"<<u<<' '<<v<<endl;
GA[u].push_back(v);
}
int tarjan(int u) {
int lowlinku = pre[u] = ++dfs_clock;
S.push(u);
for (auto x: G[u])
if (!pre[x]) {
int lowlinkv = tarjan(x);
lowlinku = min(lowlinku, lowlinkv);
} else if (!sccno[x])
lowlinku = min(lowlinku, pre[x]);
if (lowlinku == pre[u]) {
++scc_count;
scc[scc_count].clear();
//cout<<endl<<scc_count<<":";
while (1) {
int v = S.top(); S.pop();
scc[scc_count].push_back(v);
sccno[v] = scc_count;
//cout<<v<<' ';
if (v == u) break;
}
}
return lowlinku;
}
int dfs(int u) {
static int cnt = scc_count;
if (c[u] == -1)
return false;
c[u] = -1;
for (auto v: GA[u])
if (!c[v] && !dfs(v)) return false;
c[u] = 1;
topo[cnt--] = u;
return true;
}
int toposort(int n) {
for (int i = 1; i <= n; ++i)
if (!c[i])
if (!dfs(i))
return false;
return true;
}
signed main() {
int m, i, u, v;
cin>>n>>m;
while (m--) {
cin>>u>>v;
AddE(u, v);
}
for (i = 1; i <= n; ++i) {
if (!pre[i])
tarjan(i);
}
for (i = 1; i <= n; ++i) //Err Impppp
for (int v: G[i]) if (sccno[i] != sccno[v]) //Err2.
AddED(sccno[i], sccno[v]);
if (!toposort(scc_count))
cout<<"Shit!"<<endl;
return 0;
}
网络流
Edmonds-Karp
#include <cstdio>
#include <iostream>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;
const int infinity=1e9,maxn=1e4+1;
struct EdmondsKarp {
struct Edge {
int from,to,cap,flow;
Edge(int u,int v,int c,int f):
from(u),to(v),cap(c),flow(f){}
};
int n,m,aug[maxn],p[maxn];
vector <int> G[maxn];
vector <Edge> edges;
EdmondsKarp(int n) {
for (int i=0;i<=n;++i) G[i].clear();
edges.clear();
}
void AddEdge(int u,int v,int cap) {
edges.push_back(Edge(u,v,cap,0));
edges.push_back(Edge(v,u,0,0));
m=edges.size();
G[u].push_back(m-2);
G[v].push_back(m-1);
return;
}
int MaxFlow(int S,int T) {
int flow=0;
while (1) {
memset(aug,0,sizeof(aug));
queue <int> Q;
Q.push(S);
aug[S]=infinity;
p[S]=-1;
while (!Q.empty()) {
int x=Q.front();
Q.pop();
for (int j=0;j<G[x].size();++j) {
Edge &e=edges[G[x][j]];
if (!aug[e.to]&&e.cap>e.flow) {
p[e.to]=G[x][j];
aug[e.to]=min(aug[x],e.cap-e.flow);
Q.push(e.to);
}
}
if (aug[T]) break;
}
if (!aug[T]) break;
for (int u=T;u!=S;u=edges[p[u]].from) {
edges[p[u]].flow+=aug[T];
edges[p[u]^1].flow-=aug[T];
}
flow+=aug[T];
}
return flow;
}
};
int main() {
int N,M,S,T,u,v,f;
cin>>N>>M>>S>>T;
EdmondsKarp E(N);
for (int i=1;i<=M;++i) {
cin>>u>>v>>f;
E.AddEdge(u,v,f);
}
cout<<E.MaxFlow(S,T)<<endl;
return 0;
}
MinCostMaxFlow
#include <cstdio>
#include <vector>
#include <queue>
#include <cstring>
#define maxn 5001
#define INF 0x7f7f7f7f
using namespace std;
struct MCMF {
int flow,cost,m;
MCMF ():
flow(0),
cost(0){
E.clear();
}
struct Edges {
int to,flow,cost,cap;
};
vector <Edges> E;
vector <int> G[maxn];
void Adde(int u,int v,int w,int f) {
E.push_back(Edges {v,0,f,w});
E.push_back(Edges {u,0,-f,0});
m=E.size();
G[u].push_back(m-2);
G[v].push_back(m-1);
return;
}
void CALC(int S,int T) {
while (M(S,T));
return;
}
int M(int S,int T) {
int i,a[maxn],p[maxn],inq[maxn],d[maxn];
queue <int> Q;
memset(a,0,sizeof(a));
memset(p,0,sizeof(p));
memset(inq,0,sizeof(inq));
memset(d,0x7f,sizeof(d));
inq[S]=1;
a[S]=INF;
d[S]=0;
Q.push(S);
while (!Q.empty()) {
int i,x=Q.front();Q.pop();
inq[x]=0;
for (i=0;i<(int)G[x].size();++i) {
Edges &e=E[G[x][i]];
if (e.cap>e.flow&&d[e.to]>d[x]+e.cost) {
d[e.to]=d[x]+e.cost;
a[e.to]=min(a[x],e.cap-e.flow);
p[e.to]=G[x][i];
if (!inq[e.to]) {
Q.push(e.to);
inq[e.to]=1;
}
}
}
}
if (d[T]==INF) return false;
flow+=a[T];
cost+=a[T]*d[T];
for (i=T;i!=S;i=E[p[i]^1].to) { //!!!!!!!
E[p[i]].flow+=a[T];
E[p[i]^1].flow-=a[T];
}
return true;
}
};
int main() {
int N,M,S,T;
int u,v,w,f,i;
MCMF A;
scanf("%d%d%d%d",&N,&M,&S,&T);
for (i=1;i<=M;++i) {
scanf("%d%d%d%d",&u,&v,&w,&f);
A.Adde(u,v,w,f);
}
A.CALC(S,T);
printf("%d %d\n",A.flow,A.cost);
return 0;
}
其他基本操作
手写快排
void qs(int *a,int x,int y) {
int i=x,j=y,mid=a[x+(y-x)/2];
while (i<=j) {
while (a[i]<mid) i++;
while (a[j]>mid) j--;
if (i<=j)
swap(a[i++],a[j--]);
}
if (i<y) qs(a,i,y);
if (x<j) qs(a,x,j);
return;
}
CDQ分治
//3D seq
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 1e5 + 1, maxk = 2e5 + 1;
int n, k;
int v[maxn], x[maxn], y[maxn], z[maxn], num[maxn], t[maxn], tot, p[maxn], ans[maxn];
int val[maxk];
int cmp(int i, int j) {
return x[i] < x[j] || (x[i] == x[j] && ((y[i] < y[j]) || (y[i] == y[j] && z[i] < z[j])));
}
void read() {
int i, j;
cin>>n>>k;
for (i = 0; i < n; ++i) {
cin>>x[i]>>y[i]>>z[i];
p[i] = i;
}
sort(p, p + n, cmp);
for (i = 0; i < n; i = j) {
int t = p[i];
p[tot++] = t;
j = i + 1;
while (j < n && !((x[p[i]] ^ x[p[j]]) || (y[p[i]] ^ y[p[j]]) || (z[p[i]] ^ z[p[j]]))) {
v[t]++;
j++;
}
v[t]++;
}
}
int lowbit(int x) {
return x & (-x);
}
void add(int pos, int vl) {
while (pos <= k) {
val[pos] += vl;
pos += lowbit(pos);
}
}
int sum(int pos) {
int ret = 0;
while (pos) {
ret += val[pos];
pos -= lowbit(pos);
}
return ret;
}
void CDQ(int L, int R) {
int mid = L + (R - L) / 2, i = L, j = mid + 1, cnt = L;
if (L == R) return;
CDQ(L, mid);CDQ(mid + 1, R);
while (i <= mid || j <= R) {
if (j > R || (i <= mid && y[p[i]] <= y[p[j]])) {
add(z[p[i]], v[p[i]]);
t[cnt++] = p[i++];
}
else {
ans[p[j]] += sum(z[p[j]]);
t[cnt++] = p[j++];
}
}
for (i = L; i <= mid; ++i)
add(z[p[i]], -v[p[i]]);
for (i = L; i <= R; ++i)
p[i] = t[i];
return;
}
void solve() {
CDQ(0, tot - 1);
}
void print() {
int i;
int num[maxn] = { 0 };
for (i = 0; i < tot; ++i)
num[ans[p[i]] + v[p[i]] - 1] += v[p[i]];
for (i = 0; i < n; ++i)
cout<<num[i]<<endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
read();
solve();
print();
return 0;
}
整体二分
void solve(int L, int R, int beg, int end) {
int mid = L + (R - L) / 2, i, bl = 0, br = 0, pl = 0, pr = 0, M;
long long num;
tag++;
//printf("L = %d, R = %d, mid = %d\n", L, R, mid);
if (L > R) return;
if (L == R) {
for (i = beg; i < end; ++i)
if (st[i].opt == 2) //iffffff
ans[st[i].id] = L;
return;
}
for (i = beg; i < end; ++i) {
OPT &e = st[i];
if (e.opt == 1) {
if (e.k > mid) {
add(e.a, e.b, 1);
tr[pr++] = e;
} else tl[pl++] = e;
} else {
num = sum(e.a, e.b);
//cout<<num<<endl;
if (num >= e.k) {
tr[pr++] = e;
br = 1;
} else {
bl = 1;
e.k -= num;
tl[pl++] = e;
}
}
}
end = beg;
for (i = 0; i < pl; ++i) st[end++] = tl[i];
M = end;
for (i = 0; i < pr; ++i) st[end++] = tr[i];
if (bl) solve(L, mid, beg, M);
if (br) solve(mid + 1, R, M, end);
return;
}
signed main() {
int m, Q = 0;
long long mn = 0x7f7f7f7f, mx = -0x7f7f7f7f;
cin>>N>>m;
for (int i = 0; i < m; ++i) {
cin>>st[i].opt>>st[i].a>>st[i].b>>st[i].k;
if (st[i].opt == 2)
st[i].id = Q++;
else {
mn = min(mn, st[i].k);
mx = max(mx, st[i].k);
}
}
solve(mn, mx, 0, m);
for (int i = 0; i < Q; ++i)
cout<<ans[i]<<endl;
return 0;
}
模拟退火
#include <cmath>
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <ctime>
using namespace std;
double x;
time_t t0=clock();
double f(double x) {
//return pow(x,5)*exp(x)+pow(x,2)*(-100)+pow(x,7)*(-81)-18;
//return pow((x+1/x),x);
return log(fabs(x))+log(2);
}
double delta(double d) {
return fabs(f(d))-fabs(f(x));
}
void simulate_anneal();
int main() {
srand(time(NULL));
x=0;
simulate_anneal();
cout<<x<<endl;
return 0;
}
void simulate_anneal() {
double t=2000,k=0.99,i;
while (t>1e-14) {
double d=x+((rand()<<1)-RAND_MAX)*t;
i=delta(d);
if (i<0)
x=d;
else
if (exp(-i/t)*RAND_MAX>rand())
x=d;
t*=k;
if ((clock()-t0/(float)CLOCKS_PER_SEC)>0.15) {
t0=clock();
printf("d=%lf\tnowx=%lf\tf(x)=%lf\n",d,x,f(x));
}
}
return;
}
