uestc_retarded 模板
虽然这个队，以后再也没有了，但是他的模板，是永垂不朽的！【误
#include <ext/pb_ds/priority_queue.hpp>
__gnu_pbds::priority_queue < int > Q;
优先队列，配对堆默认，从小到大!
__gnu_pbds::priority_queue < int , greater < int > , pairing_heap_tag > Q;
__gnu_pbds::priority_queue < int , greater < int > , pairing_heap_tag > :: point_iterator id[ maxn ];
id[x] = Q.push( 5 ) ;
Q.modify( id[x] , 6) ; //直接修改
支持join , push , pop操作
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> rbt;
tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> :: iterator it ;
find_by_order(size_type order)
找第order+1小的元素的迭代器
order_of_key(int val)
问有多少个比val小
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/hash_policy.hpp>
__gnu_pbds::gp_hash_table < key , value > hs;
哈希
支持[]和find操作
三角形:
1. 半周长 P=(a+b+c)/2
2. 面积 S=aHa/2=absin(C)/2=sqrt(P(P-a)(P-b)(P-c))
3. 中线 Ma=sqrt(2(b^2+c^2)-a^2)/2=sqrt(b^2+c^2+2bccos(A))/2
4. 角平分线 Ta=sqrt(bc((b+c)^2-a^2))/(b+c)=2bccos(A/2)/(b+c)
5. 高线 Ha=bsin(C)=csin(B)=sqrt(b^2-((a^2+b^2-c^2)/(2a))^2)
6. 内切圆半径 r=S/P=asin(B/2)sin(C/2)/sin((B+C)/2)
=4Rsin(A/2)sin(B/2)sin(C/2)=sqrt((P-a)(P-b)(P-c)/P)
=Ptan(A/2)tan(B/2)tan(C/2)
7. 外接圆半径 R=abc/(4S)=a/(2sin(A))=b/(2sin(B))=c/(2sin(C))
四边形:
D1,D2为对角线,M对角线中点连线,A为对角线夹角
1. a^2+b^2+c^2+d^2=D1^2+D2^2+4M^2
2. S=D1D2sin(A)/2
(以下对圆的内接四边形)
3. ac+bd=D1D2
4. S=sqrt((P-a)(P-b)(P-c)(P-d)),P为半周长
正n边形:
R为外接圆半径,r为内切圆半径
1. 中心角 A=2PI/n
2. 内角 C=(n-2)PI/n
3. 边长 a=2sqrt(R^2-r^2)=2Rsin(A/2)=2rtan(A/2)
4. 面积 S=nar/2=nr^2tan(A/2)=nR^2sin(A)/2=na^2/(4tan(A/2))
圆:
1. 弧长 l=rA
2. 弦长 a=2sqrt(2hr-h^2)=2rsin(A/2)
3. 弓形高 h=r-sqrt(r^2-a^2/4)=r(1-cos(A/2))=atan(A/4)/2
4. 扇形面积 S1=rl/2=r^2A/2
5. 弓形面积 S2=(rl-a(r-h))/2=r^2(A-sin(A))/2
棱柱:
1. 体积 V=Ah,A为底面积,h为高
2. 侧面积 S=lp,l为棱长,p为直截面周长
3. 全面积 T=S+2A
棱锥:
1. 体积 V=Ah/3,A为底面积,h为高
(以下对正棱锥)
2. 侧面积 S=lp/2,l为斜高,p为底面周长
3. 全面积 T=S+A
棱台:
1. 体积 V=(A1+A2+sqrt(A1A2))h/3,A1.A2为上下底面积,h为高
(以下为正棱台)
2. 侧面积 S=(p1+p2)l/2,p1.p2为上下底面周长,l为斜高
3. 全面积 T=S+A1+A2
圆柱:
1. 侧面积 S=2PIrh
2. 全面积 T=2PIr(h+r)
3. 体积 V=PIr^2h
圆锥:
1. 母线 l=sqrt(h^2+r^2)
2. 侧面积 S=PIrl
3. 全面积 T=PIr(l+r)
4. 体积 V=PIr^2h/3
圆台:
1. 母线 l=sqrt(h^2+(r1-r2)^2)
2. 侧面积 S=PI(r1+r2)l
3. 全面积 T=PIr1(l+r1)+PIr2(l+r2)
4. 体积 V=PI(r1^2+r2^2+r1r2)h/3
球:
1. 全面积 T=4PIr^2
2. 体积 V=4PIr^3/3
球台:
1. 侧面积 S=2PIrh
2. 全面积 T=PI(2rh+r1^2+r2^2)
3. 体积 V=PIh(3(r1^2+r2^2)+h^2)/6
球扇形:
1. 全面积 T=PIr(2h+r0),h为球冠高,r0为球冠底面半径
2. 体积 V=2PIr^2h/3
从左边的未匹配点开始进行BFS，对于左边的点，依次检查所有向连的点并加入BFS（判断是否加过），右边的点只能走匹配边，然后对访问到的点进行标记，取左边没被标记的，右边标记了的
如果一个图是二分图，那么它的最大独立集就是多项式时间可以解决的问题了 |最大独立集| = |V|-|最大匹配数|
二分图的最大团 = 补图的最大独立集
先做一次最大匹配 然后对于已经匹配的点 如果他存在与之相连 但是不是被匹配的点 那么他总是在最小覆盖集里面
1.给一张图，问有多少条边肯定在 MST 上？
对所有边排序,每次扫出权值相同的边,然后跑tarjan_dcc(求割边),有多少条割边，表示对答案的贡献就是多少，之后将这些边的两边点进行缩点(并查集维护)
for(int i = 0 ; i < m ; ++ i)
{
int base = e[i].w;
for(int j = i + 1 ; j < m ; ++ j){
//扫描相同权值的边
//进行tarjan_dcc算法
//合并
}
}
2.给一张图，问有多少条边可能在 MST 上？
对所有边排序，每次新加入一条边之后，向后扫描所有相同权值的边，如果有边也可以合并两端，则打上标记
for(int i = 0 ; i < m ; ++ i)
{
if (find_set(e[i].u) == find_set(e[i].v) ) continue;
int a1 = find_set(e[i].u) ,a2 = find_set(e[i].v);
if (a1 > a2)
swap(a1,a2);
for(int j = i + 1 ; j < m ; ++ j)
{
if (e[j].w != e[i].w ) break;
int b1 = find_set(e[j].u) , b2 =find_set(e[j].v);
if (b1 > b2)
swap(b1,b2);
if ( a1 == b1 && a2 == b2)
flag[j] = 1;
}
union_set(e[i].u ,e[i].v);
flag[i] = 1;
}
3.可以一次dfs用n^2的时间预处理出树上任意两点的某个属性，用dp做
dfs(int u)
{
vis[u] = 1;
for(int i = head[u] ; ~i ; i =e[i].nxt)
{
int v = e[i].v;
for(int j = 1 ; j <= n ; ++ j)
if(vis[j])
更新dp
}
}
KM算法
const int maxn = 300 ;
const int inf = 1e9;
int mat[maxn + 1][maxn + 1] , N ;
int lx[maxn + 1];
int ly[maxn + 1];
int slack[maxn + 1];
int S[maxn + 1];
int T[maxn + 1];
int lft[maxn + 1];
bool dfs( int x ){
S[x] = 1;
for(int i = 1 ; i <= N ; ++ i)
if( !T[i] ){
int gap = lx[x] + ly[i] - mat[x][i];
if( gap == 0 ){
T[i] = 1;
if( lft[i] == 0 || dfs( lft[i] ) ){
lft[i] = x;
return true;
}
}else slack[i] = min( slack[i] , gap );
}
return false;
}
int solve(){
for(int i = 1 ; i <= N ; ++ i){
lx[i] = ly[i] = lft[i] = 0;
for(int j = 1 ; j <= N ; ++ j) lx[i] = max( lx[i] , mat[i][j] );
}
for(int i = 1 ; i <= N ; ++ i){
while( 1 ){
for(int j = 1 ; j <= N ; ++ j) slack[j] = inf , S[j] = T[j] = 0;
if( dfs( i ) ) break;
int d = inf;
for(int j = 1 ; j <= N ; ++ j) if( !T[j] ) d = min( d , slack[j] );
for(int j = 1 ; j <= N ; ++ j){
if( S[j] ) lx[j] -= d;
if( T[j] ) ly[j] += d;
}
}
}
int res = 0;
for(int i = 1 ; i <= N ; ++ i) res += lx[i] + ly[i];
return res;
}
Tarjan_bcc
int tarjan_dfs(int u,int fa)
{
dfn[u] = low[u] = ++T;
for(int i = head[u] ; ~i ; i = e[i].nxt)
{
int v = e[i].v;
if(v == fa) continue;
if(!dfn[v])
{
s.push(make_pair(u,v));
int lowv = tarjan_dfs(v,u);
low[u] = min(low[u],lowv);
if(lowv >= dfn[u])
{
bcc_cnt++;bcc[bcc_cnt].clear();
while(1)
{
dl ss = s.top();s.pop();
int x = ss.first , y = ss.second;
if(belong[x] != bcc_cnt)
{
bcc[bcc_cnt].push_back(x);
belong[x] = bcc_cnt;
}
if(belong[y] != bcc_cnt)
{
bcc[bcc_cnt].push_back(y);
belong[y] = bcc_cnt;
}
if(x==u&&y==v) break;
}
}
}
else if(dfn[v] < dfn[u])
{
s.push(make_pair(u,v));
low[u] = min(low[u] , dfn[v]);
}
}
return low[u];
}
辛普森积分
double F(double x){ return exp(-x*x/2); }
double simpson( double a , double b ){
double c = a + ( b - a ) / 2;
return (F(a) + 4*F(c) + F(b))*(b-a) / 6;
}
double asr( double a , double b , double eps , double A){
double c = a + ( b - a ) / 2;
double L = simpson( a , c ) , R = simpson( c , b );
if(fabs(L+R-A) <= 15*eps) return L + R + (L+R-A)/15.0;
return asr( a , c , eps / 2 , L ) + asr( c , b , eps / 2 , R);
}
double asr( double a , double b , double eps ){
return asr( a , b , eps , simpson( a , b ) );
}
Xor为K的方案数
int n , p[maxn] , dp[maxn][2] , dp2[maxn][2] , target ;
int solve( int target ){
int rs = 0 , bit ;
for(bit = 30 ; bit >= 0 ; -- bit){
memset( dp , 0 , sizeof( dp ) );
memset( dp2 , 0 , sizeof( dp2 ) );
dp[0][0] = dp2[n + 1][0] = 1;
for(int i = 0 ; i < n ; ++ i) for(int f = 0 ; f < 2 ; ++ f) if( dp[i][f] ){
if( p[i + 1] >> bit & 1 ){
up( dp[i + 1][f ^ 1] , mul( dp[i][f] , (p[i + 1]&((1<<bit)-1))+1 ));
up( dp[i + 1][f] , mul( dp[i][f] , 1 << bit ) );
}else up( dp[i + 1][f] , mul( dp[i][f] , (p[i + 1]&((1<<bit)-1))+1 ));
}
for(int i = n + 1 ; i > 1 ; -- i) for(int f = 0 ; f < 2 ; ++ f) if( dp2[i][f] ){
if( p[i - 1] >> bit & 1 ) up( dp2[i - 1][f ^ 1] , mul( dp2[i][f] , (p[i - 1]&((1<<bit)-1))+1 ));
else up( dp2[i - 1][f] , mul( dp2[i][f] , (p[i - 1]&((1<<bit)-1))+1 ));
}
int pre = 0 ;
for(int i = n; i >= 1 ; -- i){
if( p[i] >> bit & 1 ) for(int j = 0 ; j < 2 ; ++ j) up( rs , mul( dp[i - 1][j] , dp2[i + 1][ (target >> bit & 1) ^ j ] ) );
pre ^= ( p[i] >> bit & 1 );
}
if( pre != ( target >> bit & 1 ) ) break;
}
return rs + (bit == -1);
}
1e9内素数和
long long dp[maxn][105];
int vis[maxn * 100] , tot , prime[maxn * 100] ;
int cal(long long x){
int l = 0 , r = tot - 1;
while(l <= r){
int mid = l + ( (r-l) >> 1);
if( 1LL * (long long)prime[mid] * prime[mid] <= x) l = mid + 1;
else r = mid - 1;
}
return prime[l-1];
}
long long dfs(int x , int y){
if(y <= 1) return ( 1LL * (x + 2) * (x - 1) ) >> 1LL; //边界条件
int flag = ( x <= 1e4 && y <= 1e2);
if( 1LL * y * y > x) return dfs( x , cal(x)); //find
if( vis[y] ) return dfs( x , prime[upper_bound(prime , prime + tot , y ) - prime - 1] );
if(flag && ~dp[x][y]) return dp[x][y];
long long ans = 0;
ans = dfs( x , y - 1 ) - 1LL * y * ( dfs(x / y , y - 1 ) - dfs( y - 1 , cal( y - 1 )) );
if(flag) dp[x][y] = ans;
return ans;
}
void init(){
for(int i = 2 ; i <= 1e6 ; ++ i)
if(!vis[i]){
prime[tot++] = i;
for(int j = i * 2 ; j <= 1e6 ; j += i) vis[j] = 1;
}
}
快速求第一类斯特林数
int seq[60][maxn << 1] , ptr = 0;
long long B[maxn << 1] , C[maxn << 1];
int DFS( int l , int r ){
if( l == r ){
int id = ptr ++ ;
seq[id][1] = l ;
seq[id][0] = 1 ;
return id;
}else{
int mid = l + r >> 1;
int lid = DFS( l , mid );
int rid = DFS( mid + 1 , r );
ptr -= 2;
int newid = ptr ++ ;
int len = 1;
while( len <= r - l + 1 ) len <<= 1;
for(int i = 0 ; i < len ; ++ i) B[i] = seq[lid][i] , C[i] = seq[rid][i] , seq[lid][i] = seq[rid][i] = 0;
NTT( B , len , 1 );
NTT( C , len , 1 );
for(int i = 0 ; i < len ; ++ i) B[i] = B[i] * C[i] % Mod;
NTT( B , len , -1 );
for(int i = 0 ; i < len ; ++ i) seq[newid][i] = B[i];
return newid;
}
}
int id = DFS( 0 , N - 1 );
for(int i = N ; i >= 0 ; -- i){
printf( "f[%d] is %d \n" , N - i , seq[id][i] );
}
FFT
const double PI = acos(-1.0);
//复数结构体
struct Complex
{
double r,i;
Complex(double _r = 0.0,double _i = 0.0)
{
r = _r; i = _i;
}
Complex operator +(const Complex &b)
{
return Complex(r+b.r,i+b.i);
}
Complex operator -(const Complex &b)
{
return Complex(r-b.r,i-b.i);
}
Complex operator *(const Complex &b)
{
return Complex(r*b.r-i*b.i,r*b.i+i*b.r);
}
};
/*
* 进行FFT和IFFT前的反转变换。
* 位置i和 （i二进制反转后位置）互换
* len必须去2的幂
*/
void change(Complex y[],int len)
{
int i,j,k;
for(i = 1, j = len/2;i < len-1; i++)
{
if(i < j)swap(y[i],y[j]);
//交换互为小标反转的元素，i<j保证交换一次
//i做正常的+1，j左反转类型的+1,始终保持i和j是反转的
k = len/2;
while( j >= k)
{
j -= k;
k /= 2;
}
if(j < k) j += k;
}
}
/*
* 做FFT
* len必须为2^k形式，
* on==1时是DFT，on==-1时是IDFT
*/
void fft(Complex y[],int len,int on)
{
change(y,len);
for(int h = 2; h <= len; h <<= 1)
{
Complex wn(cos(-on*2*PI/h),sin(-on*2*PI/h));
for(int j = 0;j < len;j+=h)
{
Complex w(1,0);
for(int k = j;k < j+h/2;k++)
{
Complex u = y[k];
Complex t = w*y[k+h/2];
y[k] = u+t;
y[k+h/2] = u-t;
w = w*wn;
}
}
}
if(on == -1)
for(int i = 0;i < len;i++)
y[i].r /= len;
}
FWT
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
int a[N];
void tfand(int a[], int n) {
if(n == 1) return;
int x = n >> 1;
tfand(a, x); tfand(a + x, x);
for(int i = 0; i < x; ++ i)
a[i] += a[i + x];
}
void utfand(long long a[], int n) {
if(n == 1) return;
int x = n >> 1;
for(int i = 0; i < x; ++ i)
a[i] -= a[i + x];
utfand(a, x); utfand(a + x, x);
}
void tfor(int a[], int n) {
if(n == 1) return;
int x = n >> 1;
tfor(a, x); tfor(a + x, x);
for(int i = 0; i < x; ++ i)
a[i + x] += a[i];
}
void utfor(long long a[], int n) {
if(n == 1) return;
int x = n >> 1;
for(int i = 0; i < x; ++ i)
a[i + x] -= a[i];
utfor(a, x); utfor(a + x, x);
}
long long t[N];
void utfxor(long long a[], int n) {
if(n == 1) return;
int x = n >> 1;
for(int i = 0; i < x; ++ i) {
t[i] = (a[i] + a[i + x]) >> 1;
t[i + x] = (a[i + x] - a[i]) >> 1;
}
memcpy(a, t, n * sizeof(long long));
utfxor(a, x); utfxor(a + x, x);
}
int tmp[N];
void tfxor(int a[], int n) {
if(n == 1) return;
int x = n >> 1;
tfxor(a, x); tfxor(a + x, x);
for(int i = 0; i < x; ++ i) {
tmp[i] = a[i] - a[i + x];
tmp[i + x] = a[i] + a[i + x];
}
memcpy(a, tmp, n * sizeof(int));
}
long long b[N];
int c[N];
NTT
typedef long long ll;
const ll Mod=998244353; // 模数
const ll SpMul=3; // 原根
ll qpow(ll a,ll k)
{
ll res=1LL;
while(k>0)
{
if(k&1)res=res*a%Mod;
a=a*a%Mod;
k>>=1;
}
return res;
}
void Change(ll y[],int len)
{
for(int i=1,j=len/2;i<len-1;i++)
{
if(i<j)swap(y[i],y[j]);
int k=len/2;
while(j>=k)
{
j-=k;
k/=2;
}
if(j<k)j+=k;
}
}
void NTT(ll y[],int len,int on)
{
Change(y,len);
for(int h=2;h<=len;h<<=1)
{
ll wn=qpow(SpMul,(Mod-1)/h);
if(on==-1)wn=qpow(wn,Mod-2);
for(int j=0;j<len;j+=h)
{
ll w=1LL;
for(int k=j;k<j+h/2;k++)
{
ll u=y[k];
ll t=w*y[k+h/2]%Mod;
y[k]=(u+t)%Mod;
y[k+h/2]=(u-t+Mod)%Mod;
w=w*wn%Mod;
}
}
}
if(on==-1)
{
ll t=qpow(len,Mod-2);
for(int i=0;i<len;i++)
y[i]=y[i]*t%Mod;
}
}
CRT与Ex_GCD 和 求逆
X / y % p = X % (y*p) / y
void extend_gcd(long long a , long long b , long long& d , long long & x , long long &y )
{
if (!b)
{
d = a;
x = 1;
y = 0;
}
else
{
extend_gcd(b,a%b,d,y,x);
y -= x*(a/b);
}
}
long long inv(long long a,long long n)
{
long long d , x , y;
extend_gcd(a,n,d,x,y);
return d==1? (x+n) % n : -1;
}
// n个方程,x=a[i] (mod m[i]) ( 0 <= i < n)
long long CRT(int n ,long long * a , long long * m)
{
long long M = 1 , d , y , x = 0;
for(int i = 0 ; i < n ; ++ i) M*=m[i];
for(int i = 0 ; i < n ; ++ i)
{
long long w = M / m[i];
extend_gcd(m[i],w,d,d,y);
x = (x + y*w*a[i])%M;
}
return (x+M)%M;
}
高斯消元（高精度）
const int MatrixSize = 50;
const double eps = 1e-8;
typedef double Matrix[MatrixSize][MatrixSize];
void Gauss(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(fabs(A[r][i]) < eps) continue;
if(r != i) for(j = 0; j <= n; j++) swap(A[r][j], A[i][j]);
for(k = 0; k < n; k++) if(k != i)
for(j = n; j >= i; j--) A[k][j] -= A[k][i]/A[i][i] * A[i][j];
}
for(i = 0 ; i < n ; ++ i)
{
if(fabs(A[i][n]) < eps) A[i][n] = 0;
else A[i][n] /= A[i][i];
}
}
算原根
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
using namespace std;
int P;
const int NUM = 32170;
int prime[NUM/4];
bool f[NUM];
int pNum = 0;
void getPrime()//线性筛选素数
{
for (int i = 2; i < NUM; ++ i)
{
if (!f[i])
{
f[i] = 1;
prime[pNum++] = i;
}
for (int j = 0; j < pNum && i*prime[j] < NUM; ++ j)
{
f[i*prime[j]] = 1;
if (i%prime[j] == 0)
{
break;
}
}
}
}
__int64 getProduct(int a,int b,int P)//快速求次幂mod
{
__int64 ans = 1;
__int64 tmp = a;
while (b)
{
if (b&1)
{
ans = ans*tmp%P;
}
tmp = tmp*tmp%P;
b>>=1;
}
return ans;
}
bool judge(int num)//求num的所有的质因子
{
int elem[1000];
int elemNum = 0;
int k = P - 1;
for (int i = 0; i < pNum; ++ i)
{
bool flag = false;
while (!(k%prime[i]))
{
flag = true;
k /= prime[i];
}
if (flag)
{
elem[elemNum ++] = prime[i];
}
if (k==1)
{
break;
}
if (k/prime[i]<prime[i])
{
elem[elemNum ++] = prime[i];
break;
}
}
bool flag = true;
for (int i = 0; i < elemNum; ++ i)
{
if (getProduct(num,(P-1)/elem[i],P) == 1)
{
flag = false;
break;
}
}
return flag;
}
int main()
{
getPrime();
while (cin >> P)
{
for (int i = 2; i <= P ;++i)
{
if (judge(i))
{
cout << i<< endl;
break;
}
}
}
return 0;
}
降幂公式
A^x = A^(x % Phi(C) + Phi(C)) (mod C)，其中x≥Phi(C) 这个降幂公式适用于C不是素数的情况
A ^ X % C = A ^ ( X % ( C - 1 ) ) 这个降幂公式只适用于C是素数的情况
回文自动机
struct Palindromic_Auto{
const static int maxn = 2e5 + 15;
const static int lettersz = 26;
int link[maxn] , len[maxn] , last , tot , nxt[maxn][lettersz] , s[maxn] , n ;
void init( int id , int l ){ memset( nxt[id] , 0 , sizeof( nxt[id] ) ); len[id] = l; }
void init(){ n = last = 0 , s[0] = -1 , link[0] = tot = 1; init( 0 , 0 ) , init( 1 , -1 ); }
int gethash( char c ){ return c -'a' ;}
int extend( char c ){
s[ ++ n ] = gethash( c );
int cur = last ;
while( s[n - len[cur] - 1] != s[n] ) cur = link[cur];
if( !nxt[cur][s[n]] ){
int id = ++ tot , t = link[cur] ; init( id , len[cur] + 2 );
while( s[n - len[t] - 1] != s[n] ) t = link[t];
link[id] = nxt[t][s[n]] , nxt[cur][s[n]] = id;
}
last = nxt[cur][s[n]];
return len[last];
}
}pa_auto;
后缀自动机
struct Suffix_Auto{
const static int maxn = ( 1e5 + 50 ) * 2;
const static int lettersz = 26;
int tot , last , link[maxn] , nxt[maxn][lettersz] , len[maxn];
int gethash( char c ){ return c -'a' ;}
void init( int idx ){ link[idx] = len[idx] = 0 , memset( nxt[idx] , 0 , sizeof( nxt[idx] ) ); }
void init(){ memset(nxt[0],0,sizeof(nxt[0])) ; last = tot = len[0] = 0 , link[0] = -1 ; }
void extend( char c ){
int cur = ++ tot , p , q , id = gethash( c ) ;
init( cur ) ;
len[cur] = len[last] + 1;
for( p = last ; ~p && !nxt[p][id] ; p = link[p] ) nxt[p][id] = cur;
if( ~p ){
q = nxt[p][id];
if( len[p] + 1 == len[q] ) link[cur] = q;
else{
// Pay attention to init for clone , such as cnt array
int clone = ++ tot ;
len[clone] = len[p] + 1 , memcpy( nxt[clone] , nxt[q] , sizeof(int)*lettersz ) , link[clone] = link[q];
for( ; ~p && nxt[p][id] == q ; p = link[p] ) nxt[p][id] = clone;
link[q] = link[cur] = clone;
}
}
last = cur;
}
}Sam;
后缀数组
struct SuffixArray{
const static int maxn = 1e5 + 50;
int sa[maxn],c[maxn],sq[maxn],sw[maxn],rank[maxn],height[maxn];
void Build(int *s,int n,int m){
++ n;
int * x = sq , *y = sw , p = 1 ;
for(int i = 0 ; i < m ; ++ i) c[i] = 0;
for(int i = 0 ; i < n ; ++ i) c[x[i]=s[i]]++;
for(int i = 1 ; i < m ; ++ i) c[i] += c[i - 1];
for(int i = n - 1 ; i >= 0 ; -- i) sa[--c[x[i]]] = i;
for(int k = 1 ; p < n ; k <<= 1){
p = 0;
for(int i = n - k ; i < n ; ++ i) y[p ++] = i;
for(int i = 0 ; i < n ; ++ i) if( sa[i] >= k ) y[p ++] = sa[i] - k;
for(int i = 0 ; i < m ; ++ i) c[i] = 0;
for(int i = 0 ; i < n ; ++ i) c[x[y[i]]]++;
for(int i = 1 ; i < m ; ++ i) c[i] += c[i-1];
for(int i = n - 1 ; i >= 0 ; -- i) sa[--c[x[y[i]]]]=y[i];
swap( x , y ) ; p = 1 , x[sa[0]] = 0;
for(int i = 1 ; 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++;
m = p;
}
-- n;
for(int i = 0 ; i < n ; ++ i) sa[i] = sa[i + 1] , rank[sa[i]] = i;
for(int i = 0 , k = 0 ; i < n ; ++ i ){
if( !rank[i] ) continue;
int j = sa[rank[i] - 1];
if( k ) -- k;
while( s[i + k] == s[j + k] ) ++ k;
height[rank[i]] = k;
}
}
}Sa;
马拉车
void manacher(char s[],int l)
{
int i,j,k,ans=0;
for(i=1;i<=l;++i)str[i<<1]=s[i],str[(i<<1)+1]='#';
str[1]='#';str[l*2+1]='#';str[0]='&';str[l*2+2]='$';
l=l*2+1;j=0;
for(i=1;i<=l;)
{
while(str[i-j-1]==str[i+j+1])++j;
p[i]=j;if(j>ans)ans=j;
for(k=1;k<=j&&p[i]-k!=p[i-k];++k)p[i+k]=min(p[i-k],p[i]-k);
i+=k;j=max(j-k,0);
}
}
LCT 动态树
Push是往下传，update是往上传
const int MAXN = 200500;struct Node {
Node *ch[2], *p; int size, value;
bool rev;
Node(int t = 0);
inline bool dir(void) {return p->ch[1] == this;}
inline void SetC(Node *x, bool d) {
ch[d] = x; x->p = this;
}
inline void Rev(void) {
swap(ch[0], ch[1]); rev ^= 1;
}
inline void Push(void) {
if (rev) {
ch[0]->Rev();
ch[1]->Rev();
rev = 0;
}
}
inline void Update(void) {
size = ch[0]->size + ch[1]->size + 1;
}
}Tnull, *null = &Tnull, *fim[MAXN];// 要记得额外更新null的信息
Node::Node(int _value){ch[0] = ch[1] = p = null; rev = 0;}
inline bool isRoot(Node *x) {return x->p == null || (x != x->p->ch[0] && x != x->p->ch[1]);}
inline void rotate(Node *x) {
Node *p = x->p; bool d = x->dir();
p->Push(); x->Push();
if (!isRoot(p)) p->p->SetC(x, p->dir()); else x->p = p->p;
p->SetC(x->ch[!d], d);
x->SetC(p, !d);
p->Update();
}
inline void splay(Node *x) {
x->Push();
while (!isRoot(x)) {
if (isRoot(x->p)) rotate(x);
else {
if (x->dir() == x->p->dir()) {rotate(x->p); rotate(x);}
else {rotate(x); rotate(x);}
}
}
x->Update();
}
inline Node* Access(Node *x) {
Node *t = x, *q = null;
for (; x != null; x = x->p) {
splay(x); x->ch[1] = q; q = x;
}
splay(t); //info will be updated in the splay;
return q;
}
inline void Evert(Node *x) {
Access(x); x->Rev();
}
inline void link(Node *x, Node *y) {
Evert(x); x->p = y;
}
inline Node* getRoot(Node *x) {
Node *tmp = x;
Access(x);
while (tmp->Push(), tmp->ch[0] != null) tmp = tmp->ch[0];
splay(tmp);
return tmp;
}// 一定要确定x和y之间有边
inline void cut(Node *x, Node *y) {
Access(x); splay(y);
if (y->p != x) swap(x, y);
Access(x); splay(y);
y->p = null;
}
inline Node* getPath(Node *x, Node *y) {
Evert(x); Access(y);
return y;
}
inline void clear(void) {
null->rev = 0; null->size = 0; null->value = 0;
}int a[maxn];int main()
{
clear();
int n=read();
for(int i=0;i<=n+1;i++)
fim[i] = new Node();
for(int i=1;i<=n;i++)
a[i]=read();
for(int i=1;i<=n;i++)
{
int p = i+a[i];
if(p>n)p=n+1;
link(fim[i],fim[p]);
}
int m = read();
while(m--)
{
int op = read();
if(op == 1)
{
int x = read();
x++;
Access(fim[x]);
splay(fim[x]);
printf("%d\n",fim[x]->size - 1);
}
else
{
int x=read(),y=read();
x++;
int p = x+a[x];
if(p>n)p=n+1;
cut(fim[x],fim[p]);
a[x]=y;
p = x+a[x];
if(p>n)p=n+1;
link(fim[x],fim[p]);
}
}
}
Splay
struct SplayTree{
const static int maxn = 2e5 + 15;
int ch[maxn][2] , s[maxn] , tot , root , fa[maxn];
long long sum[maxn] , lzy[maxn] ;
int index[maxn] , key[maxn];
void init( int x , int id = 0 , int val = 0 , int par = 0 ){
ch[x][0]=ch[x][1]=0 , fa[x]= par , key[x] = val , index[x] = id , s[x] = 1;
}
void init(){
init( 0 , 0 , 0 , 0 ); s[0] = 0;
tot = root = 0 ;
}
inline void up(int x){
s[x] = s[ch[x][0]] + s[ch[x][1]] + 1;
sum[x] = key[x];
if( ch[x][0] ) sum[x] += sum[ch[x][0]];
if( ch[x][1] ) sum[x] += sum[ch[x][1]];
}
void update( int x , long long v ){
lzy[x] += v;
sum[x] += s[x] * v;
key[x] += v;
}
void ReleaseLabel( int x ){
if( lzy[x] ){
if( ch[x][0] ) update( ch[x][0] , lzy[x] );
if( ch[x][1] ) update( ch[x][1] , lzy[x] );
lzy[x] = 0;
}
}
void rotate( int x, int d ){
int y = fa[x];
//cout << "y is " << y << " lzy is " << lzy[y] << endl;
ReleaseLabel( y );
ReleaseLabel( x );
ch[y][d ^ 1] = ch[x][d];
if ( ch[x][d]) fa[ch[x][d]] = y;
fa[x] = fa[y];
if (fa[y]){
if (y == ch[fa[y]][d]) ch[fa[y]][d] = x;
else ch[fa[y]][d ^ 1] = x;
}
ch[x][d] = y , fa[y] = x;
up( y );
up( x );
}
// Splay x to target's son
void Splay( int x , int target ){
ReleaseLabel( x ); // Very Improtant !!!!
while( fa[x] != target ){
int y = fa[x];
if( x == ch[y][0] ){
if( fa[y] != target && y == ch[fa[y]][0])
rotate( y , 1 );
rotate( x , 1 );
}else{
if( fa[y] != target && y == ch[fa[y]][1])
rotate( y , 0 );
rotate( x , 0 );
}
}
if( !target ) root = x;
}
int insert( int & x , int id , int val , int par = 0 ){
int rs;
if( x == 0 ){
x = ++ tot;
rs = x;
init( tot , id , val , par );
}else{
int cur = x;
ReleaseLabel( cur );
if( id < index[x] ) rs = insert( ch[x][0] , id , val , x );
else rs = insert( ch[x][1] , id , val , x );
}
up( x );
return rs;
}
int pred( int t , int v ){
if( t == 0 ) return -1;
if( v <= index[t] ) return pred( ch[t][0] , v );
else{
int rs = pred( ch[t][1] , v );
if( rs == -1 ) return t;
return rs;
}
}
int succ( int t , int v ){
if( t == 0 ) return -1;
if( v >= index[t] ) return succ( ch[t][1] , v );
else{
int rs = succ( ch[t][0] , v );
if( rs == -1 ) return t;
return rs;
}
}
// After GotSegement( l , r ) must use Splay funtion to Modify son's information to the root
int GetSegement( int l , int r ){
int s1 = pred( root , l ) , s2 = succ( root , r );
if( s1 == -1 && s2 == -1 ) return root;
else if( s1 == -1 ){
Splay( s2 , 0 );
return ch[s2][0];
}else if( s2 == -1 ){
Splay( s1 , 0 );
return ch[s1][1];
}else{
Splay( s1 , 0 );
Splay( s2 , s1 );
return ch[s2][0];
}
}
void Delete( int l , int r ){
int s1 = pred( root , l ) , s2 = succ( root , r );
if( s1 == -1 && s2 == -1 ){
fa[ch[root][0]] = 0;
fa[ch[root][1]] = 0;
root = 0;
}
else if( s1 == -1 ){
Splay( s2 , 0 );
fa[ch[s2][0]] = 0;
ch[s2][0] = 0;
up( s2 );
}else if( s2 == -1 ){
Splay( s1 , 0 );
fa[ch[s1][1]] = 0;
ch[s1][1] = 0 ;
up( s1 );
}else{
Splay( s1 , 0 );
Splay( s2 , s1 );
fa[ch[s2][0]] = 0;
ch[s2][0] = 0;
up( s2 );
up( s1 );
}
}
}splay;
FWT
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
int a[N];
void tfand(int a[], int n) {
if(n == 1) return;
int x = n >> 1;
tfand(a, x); tfand(a + x, x);
for(int i = 0; i < x; ++ i)
a[i] += a[i + x];
}
void utfand(long long a[], int n) {
if(n == 1) return;
int x = n >> 1;
for(int i = 0; i < x; ++ i)
a[i] -= a[i + x];
utfand(a, x); utfand(a + x, x);
}
void tfor(int a[], int n) {
if(n == 1) return;
int x = n >> 1;
tfor(a, x); tfor(a + x, x);
for(int i = 0; i < x; ++ i)
a[i + x] += a[i];
}
void utfor(long long a[], int n) {
if(n == 1) return;
int x = n >> 1;
for(int i = 0; i < x; ++ i)
a[i + x] -= a[i];
utfor(a, x); utfor(a + x, x);
}
long long t[N];
void utfxor(long long a[], int n) {
if(n == 1) return;
int x = n >> 1;
for(int i = 0; i < x; ++ i) {
t[i] = (a[i] + a[i + x]) >> 1;
t[i + x] = (a[i + x] - a[i]) >> 1;
}
memcpy(a, t, n * sizeof(long long));
utfxor(a, x); utfxor(a + x, x);
}
int tmp[N];
void tfxor(int a[], int n) {
if(n == 1) return;
int x = n >> 1;
tfxor(a, x); tfxor(a + x, x);
for(int i = 0; i < x; ++ i) {
tmp[i] = a[i] - a[i + x];
tmp[i + x] = a[i] + a[i + x];
}
memcpy(a, tmp, n * sizeof(int));
}
long long b[N];
int c[N];
int main() {
int T, cas = 1;
scanf("%d", &T);
while(T --) {
int n, op;
scanf("%d%d", &n, &op);
memset(a, 0, sizeof(a));
for(int i = 0; i < n; ++ i) {
scanf("%d", c + i);
++ a[c[i]];
}
if(op == 1) {
tfand(a, 1 << 20);
} else if(op == 2) {
tfxor(a, 1 << 20);
} else {
tfor(a, 1 << 20);
}
for(int i = 0; i < 1 << 20; ++ i)
b[i] = (long long)a[i] * a[i];
if(op == 1) {
utfand(b, 1 << 20);
} else if(op == 2) {
utfxor(b, 1 << 20);
} else {
utfor(b, 1 << 20);
}
if(op != 2) {
for(int i = 0; i < n; ++ i) -- b[c[i]];
}
int ans = 0;
for(int i = (1 << 20) - 1; i >= 0; -- i) if(b[i]) {
ans = i;
break;
}
printf("Case #%d: %d\n", cas ++, ans);
}
return 0;
}
博弈论
Nim Game
最经典最基础的博弈.
n堆石子,双方轮流从任意一堆石子中取出至少一个,不能取的人输.
对于一堆x个石子的情况,容易用归纳法得到SG(x)=x.
所以所有石子个数的异或和为0是必败态,否则为必胜态.
Bash Game
每人最多一次只能取m个石子,其他规则同Nim Game.
依旧数学归纳…SG(x)=xmod(m+1).
NimK Game
每人一次可以从最多K堆石子中取出任意多个,其他规则同Nim Game.
结论:在二进制下各位上各堆石子的数字之和均为(K+1)的倍数的话则为必败态,否则为必胜态.
这个证明要回到原始的方法上去.
补:这个游戏还可以推广,即一个由n个子游戏组成的游戏,每次可以在最多K个子游戏中进行操作.
然后只要把结论中各堆石子的个数改为各个子游戏的SG值即可,证明也还是一样的.
Anti-Nim Game
似乎又叫做Misère Nim.
不能取的一方获胜,其他规则同Nim Game.
关于所谓的”Anti-SG游戏”及”SJ定理”贾志鹏的论文上有详细说明,不过似乎遇到并不多.
结论是一个状态是必胜态当且仅当满足以下条件之一:
SG值不为0且至少有一堆石子数大于1;
SG值为0且不存在石子数大于1的石子堆.
Staircase Nim
每人一次可以从第一堆石子中取走若干个,或者从其他石子堆的一堆中取出若干个放到左边一堆里(没有石子的石子堆不会消失),其他规则同Nim Game.
这个游戏的结论比较神奇:
当且仅当奇数编号堆的石子数异或和为0时为必败态.
简单的理解是从偶数编号堆中取石子对手又可以放回到奇数编号堆中,而且不会让对手不能移动.比较意识流,然而可以归纳证明.
Wythoff Game
有两堆石子,双方轮流从某一堆取走若干石子或者从两堆中取走相同数目的石子,不能取的人输.
容易推理得出对任意自然数k,都存在唯一的一个必败态使得两堆石子数差为k,设其为Pk=(ak,bk),表示石子数分别为ak,bk(ak⩽bk).
那么ak为在Pk0(k0<k)中未出现过的最小自然数,bk=ak+k.
数学班的说,用Betty定理以及显然的单调性就可以推出神奇的结论:
ak=⌊k⋅5√+12⌋,bk=⌊k⋅5√+32⌋.
Take & Break
有n堆石子,双方轮流取出一堆石子,然后新增两堆规模更小的石子堆(可以没有石子),无法操作者输.
这个游戏似乎只能暴力SG,知道一下就好.
树上删边游戏
给出一个有n个结点的树，有一个点作为树的根节点,双方轮流从树中删去一条边边，之后不与根节点相连的部分将被移走,无法操作者输.
结论是叶子结点的SG值为0,其他结点SG值为其每个儿子结点SG值加1后的异或和,证明也并不复杂.
下面两个游戏我不太会,于是偷懒引用贾志豪《组合游戏略述——浅谈 SG 游戏的若干拓展及变形》中的内容了.
翻硬币游戏
n枚硬币排成一排，有的正面朝上，有的反面朝上。
游戏者根据某些约束翻硬币（如：每次只能翻一或两枚，或者每次只能翻连续的几枚），但他所翻动的硬币中，最右边的必须是从正面翻到反面。
谁不能翻谁输。
需要先开动脑筋把游戏转化为其他的取石子游戏之类的,然后用如下定理解决:
局面的 SG 值等于局面中每个正面朝上的棋子单一存在时的 SG 值的异或和。
无向图删边游戏
一个无向连通图，有一个点作为图的根。
游戏者轮流从图中删去边， 删去一条边后，不与根节点相连的部分将被移走。
谁无路可走谁输。
对于这个模型，有一个著名的定理——Fusion Principle:
我们可以对无向图做如下改动：将图中的任意一个偶环缩成一个新点，任意一个奇环缩成一个新点加一个新边；所有连到原先环上的边全部改为与新点相连。 这样的改动不会影响图的 SG 值。
数学
奇怪的数学公式系列：
欧拉函数：
在数论，对正整数n，欧拉函数是小于n的数中与n互质的数的数目。此函数以其首名研究者欧拉命名，它又称为Euler's totient function、φ函数、欧拉商数等。 例如φ(8)=4，因为1,3,5,7均和8互质。 从欧拉函数引伸出来在环论方面的事实和拉格朗日定理构成了欧拉定理的证明。
φ函数的值：通式：φ(x)=x(1-1/p1)(1-1/p2)(1-1/p3)(1-1/p4)…..(1-1/pn),其中p1, p2……pn为x的所有质因数，x是不为0的整数。φ(1)=1（唯一和1互质的数(小于等于1)就是1本身）。 (注意：每种质因数只一个。比如12=2*2*3那么φ（12）=12*（1-1/2）*(1-1/3)=4
若n是质数p的k次幂，φ(n)=p^k-p^(k-1)=(p-1)p^(k-1)，因为除了p的倍数外，其他数都跟n互质。
设n为正整数，以 φ(n)表示不超过n且与n互素的正整数的个数，称为n的欧拉函数值，这里函数
φ：N→N，n→φ(n)称为欧拉函数。
欧拉函数是积性函数——若m,n互质，φ(mn)=φ(m)φ(n)。
特殊性质：当n为奇数时，φ(2n)=φ(n), 证明与上述类似。
若n为质数则φ(n)=n-1。
long long phi[maxn];
void phi1()
{
memset(phi,0,sizeof(phi));
phi[1]=1;
for(long long i=2;i<=n;i++)
{
if(!phi[i])
{
for(long long j=i;j<=n;j+=i)
{
if(!phi[j]) phi[j]=j;
phi[j]=phi[j]/i*(i-1);
}
}
}
}
另外一种：
long long phi(long long n)
{
long long tmp=n;
for(long long i=2;i*i<=n;i++)
if(n%i==0)
{
tmp/=i;tmp*=i-1;
while(n%i==0)n/=i;
}
if(n!=1)tmp/=n,tmp*=n-1;
return tmp;
}
排列组合
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e6+7;
const int mod = 1e9+7;
long long fac[maxn];
long long qpow(long long a,long long b)
{
long long ans=1;a%=mod;
for(long long i=b;i;i>>=1,a=a*a%mod)
if(i&1)ans=ans*a%mod;
return ans;
}
long long C(long long n,long long m)
{
if(m>n||m<0)return 0;
long long s1=fac[n],s2=fac[n-m]*fac[m]%mod;
return s1*qpow(s2,mod-2)%mod;
}
int main()
{
fac[0]=1;
for(int i=1;i<maxn;i++)
fac[i]=fac[i-1]*i%mod;
}
逆元
int gcd(int a, int b, int& x, int& y) {
if (!a) {
x = 0, y = 1;
return b;
}
int xx, yy, g = gcd(b % a, a, xx, yy);
x = yy - b / a * xx;
y = xx;
return g;
}
inline int normal(int n) {
n %= mod;
(n < 0) && (n += mod);
return n;
}
inline int inv(int a) {
int x, y;
assert(gcd(a, mod, x, y) == 1);
return normal(x);
}
inline int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
inline int sub(int a, int b) { return a - b < 0 ? a - b + mod : a - b; }
inline int mul(int a, int b) { return int(a * 1ll * b % mod); }
inline int _div(int a, int b) { return mul(a, inv(b)); }
统计二进制有多少个1
cnt[i]＝cnt[i>>1]+(i&1);
popcount(int x){
return cnt[x>>16]+cnt[x&((1<<16)-1)];
}
网络流
namespace NetFlow
{
const int MAXN=100000,MAXM=100000,inf=1e9;
struct Edge
{
int v,c,f,nx;
Edge() {}
Edge(int v,int c,int f,int nx):v(v),c(c),f(f),nx(nx) {}
} E[MAXM];
int G[MAXN],cur[MAXN],pre[MAXN],dis[MAXN],gap[MAXN],N,sz;
void init(int _n)
{
N=_n,sz=0; memset(G,-1,sizeof(G[0])*N);
}
void link(int u,int v,int c)
{
E[sz]=Edge(v,c,0,G[u]); G[u]=sz++;
E[sz]=Edge(u,0,0,G[v]); G[v]=sz++;
}
int ISAP(int S,int T)
{//S -> T
int maxflow=0,aug=inf,flag=false,u,v;
for (int i=0;i<N;++i)cur[i]=G[i],gap[i]=dis[i]=0;
for (gap[S]=N,u=pre[S]=S;dis[S]<N;flag=false)
{
for (int &it=cur[u];~it;it=E[it].nx)
{
if (E[it].c>E[it].f&&dis[u]==dis[v=E[it].v]+1)
{
if (aug>E[it].c-E[it].f) aug=E[it].c-E[it].f;
pre[v]=u,u=v; flag=true;
if (u==T)
{
for (maxflow+=aug;u!=S;)
{
E[cur[u=pre[u]]].f+=aug;
E[cur[u]^1].f-=aug;
}
aug=inf;
}
break;
}
}
if (flag) continue;
int mx=N;
for (int it=G[u];~it;it=E[it].nx)
{
if (E[it].c>E[it].f&&dis[E[it].v]<mx)
{
mx=dis[E[it].v]; cur[u]=it;
}
}
if ((--gap[dis[u]])==0) break;
++gap[dis[u]=mx+1]; u=pre[u];
}
return maxflow;
}
bool bfs(int S,int T)
{
static int Q[MAXN]; memset(dis,-1,sizeof(dis[0])*N);
dis[S]=0; Q[0]=S;
for (int h=0,t=1,u,v,it;h<t;++h)
{
for (u=Q[h],it=G[u];~it;it=E[it].nx)
{
if (dis[v=E[it].v]==-1&&E[it].c>E[it].f)
{
dis[v]=dis[u]+1; Q[t++]=v;
}
}
}
return dis[T]!=-1;
}
int dfs(int u,int T,int low)
{
if (u==T) return low;
int ret=0,tmp,v;
for (int &it=cur[u];~it&&ret<low;it=E[it].nx)
{
if (dis[v=E[it].v]==dis[u]+1&&E[it].c>E[it].f)
{
if (tmp=dfs(v,T,min(low-ret,E[it].c-E[it].f)))
{
ret+=tmp; E[it].f+=tmp; E[it^1].f-=tmp;
}
}
}
if (!ret) dis[u]=-1; return ret;
}
int dinic(int S,int T)
{
int maxflow=0,tmp;
while (bfs(S,T))
{
memcpy(cur,G,sizeof(G[0])*N);
while (tmp=dfs(S,T,inf)) maxflow+=tmp;
}
return maxflow;
}
}
费用流
struct ZKW_MinCostMaxFlow{
const static int maxn = 1e5 + 50;
const static int maxE = 1e5 + 50;
const static int INF = 0x3f3f3f3f;
struct Edge{
int to,next,cap,flow,cost;
Edge(int _to=0,int _next=0,int _cap=0,int _flow=0,int _cost=0):
to(_to),next(_next),cap(_cap),flow(_flow),cost(_cost){}
}edge[maxE * 2];
int head[maxn],tot;
int cur[maxn];
int dis[maxn];
bool vis[maxn];
int ss,tt,N;
int min_cost,max_flow;
void init(int N){
tot=0;
for( int i = 0 ; i < N ; ++ i ) head[i] = -1;
}
int addedge(int u,int v,int cap,int cost){
edge[tot]=Edge(v,head[u],cap,0,cost);
int rs = tot;
head[u]=tot++;
edge[tot]=Edge(u,head[v],0,0,-cost);
head[v]=tot++;
return rs;
}
int aug(int u,int flow){
if(u==tt) return flow;
vis[u]=true;
for(int i=cur[u];i!=-1;i=edge[i].next){
int v=edge[i].to;
if( edge[i].cap>edge[i].flow && !vis[v] && dis[u]==dis[v]+edge[i].cost ){
int tmp=aug(v,min(flow,edge[i].cap-edge[i].flow));
edge[i].flow+=tmp;
edge[i^1].flow-=tmp;
cur[u]=i;
if(tmp) return tmp;
}
}
return 0;
}
bool modify_label(){
int d=INF;
for(int u=0;u<N;u++){
if(vis[u])
for(int i=head[u];i!=-1;i=edge[i].next){
int v=edge[i].to;
if(edge[i].cap>edge[i].flow && !vis[v])
d=min(d,dis[v]+edge[i].cost-dis[u]);
}
}
if(d==INF) return false;
for(int i=0;i<N;i++)
if(vis[i]){
vis[i]=false;
dis[i]+=d;
}
return true;
}
pair < int , int > mincostmaxflow(int start,int ed,int n ){
ss=start,tt=ed,N=n;
min_cost=max_flow=0;
for(int i=0;i<n;i++) dis[i]=0;
while(1){
for(int i=0;i<n;i++) cur[i]=head[i];
while(1){
for(int i=0;i<n;i++) vis[i]=false;
int tmp=aug(ss,INF);
if(tmp==0) break;
max_flow+=tmp;
min_cost+=tmp*dis[ss];
}
if(!modify_label()) break;
}
return mp( max_flow , min_cost );
}
}solver;
////////////////////////另外一种
const int inf = 1e9;
const int MAXN = 10000;
const int MAXM = 100000;
const int INF = 0x3f3f3f3f;
struct Edge
{
int to, next, cap, flow, cost;
int x, y;
} edge[MAXM],HH[MAXN],MM[MAXN];
int head[MAXN],tol;
int pre[MAXN],dis[MAXN];
bool vis[MAXN];
int N, M;
char map[MAXN][MAXN];
void init()
{
N = MAXN;
tol = 0;
memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int cap, int cost)//左端点，右端点，容量，花费
{
edge[tol]. to = v;
edge[tol]. cap = cap;
edge[tol]. cost = cost;
edge[tol]. flow = 0;
edge[tol]. next = head[u];
head[u] = tol++;
edge[tol]. to = u;
edge[tol]. cap = 0;
edge[tol]. cost = -cost;
edge[tol]. flow = 0;
edge[tol]. next = head[v];
head[v] = tol++;
}
bool spfa(int s, int t)
{
queue<int>q;
for(int i = 0; i < N; i++)
{
dis[i] = INF;
vis[i] = false;
pre[i] = -1;
}
dis[s] = 0;
vis[s] = true;
q.push(s);
while(!q.empty())
{
int u = q.front();
q.pop();
vis[u] = false;
for(int i = head[u]; i != -1; i = edge[i]. next)
{
int v = edge[i]. to;
if(edge[i]. cap > edge[i]. flow &&
dis[v] > dis[u] + edge[i]. cost )
{
dis[v] = dis[u] + edge[i]. cost;
pre[v] = i;
if(!vis[v])
{
vis[v] = true;
q.push(v);
}
}
}
}
if(pre[t] == -1) return false;
else return true;
}
//返回的是最大流， cost存的是最小费用
int minCostMaxflow(int s, int t, int &cost)
{
int flow = 0;
cost = 0;
while(spfa(s,t))
{
int Min = INF;
for(int i = pre[t]; i != -1; i = pre[edge[i^1]. to])
{
if(Min > edge[i]. cap - edge[i]. flow)
Min = edge[i]. cap - edge[i]. flow;
}
for(int i = pre[t]; i != -1; i = pre[edge[i^1]. to])
{
edge[i]. flow += Min;
edge[i^1]. flow -= Min;
cost += edge[i]. cost * Min;
}
flow += Min;
}
return flow;
}
SBT
struct SBT{
const static int maxn = 1e5 + 15;
int lft[maxn] , rht[maxn] , key[maxn] , s[maxn] , tot , root ;
void init(){ tot = root = 0 ; }
void init( int x , int val = 0 ){
lft[x] = rht[x] = 0 , key[x] = val , s[x] = 1;
}
inline void up(int x){
s[x] = s[lft[x]] + s[rht[x]] + 1;
}
void lr(int &t){
int k = rht[t];
rht[t] = lft[k];
lft[k] = t;
s[k] = s[t];
up(t);
t = k;
}
void rr(int &t){
int k = lft[t];
lft[t] = rht[k];
rht[k]= t;
s[k] = s[t];
up(t);
t = k;
}
void Maintain(int &t,bool dir){
if(dir == false){
if(s[lft[lft[t]]] > s[rht[t]])
rr(t);
else if(s[rht[lft[t]]] > s[rht[t]]){
lr(lft[t]);
rr(t);
}
else return;
}
else{
if(s[rht[rht[t]]] > s[lft[t]]) lr(t);
else if(s[lft[rht[t]]] > s[lft[t]]){
rr(rht[t]);
lr(t);
}
else return;
}
Maintain(lft[t],false);
Maintain(rht[t],true);
Maintain(t,true);
Maintain(t,false);
}
void Insert( int & t , int val ){
if( t == 0 ){
t = ++ tot;
init( t , val );
}else{
++ s[t];
if( val < key[t] ) Insert( lft[t] , val );
else Insert( rht[t] , val );
Maintain( t , val >= key[t] );
}
}
// 删除操作必须保证元素存在
int Delete(int &t , int v){
int ret = 0;
s[t] --;
if((v == key[t]) || (v<key[t] && lft[t] == 0) ||(v > key[t] && rht[t] == 0) ){
ret = key[t];
if(lft[t] == 0 || rht[t] == 0) t = lft[t] + rht[t];
else key[t] = Delete(lft[t],key[t] + 1);
}
else{
if(v < key[t]) ret = Delete(lft[t] , v);
else ret = Delete(rht[t] , v);
}
return ret;
}
bool find( int t , int val ){
if( t == 0 ) return false;
else if( key[t] == val ) return true;
else if( val < key[t] ) return find( lft[t] , val );
else return find( rht[t] , val );
}
void preorder( int x ){
if( lft[x] ) preorder( lft[x] );
printf("%d " , key[x]);
if( rht[x] ) preorder( rht[x] );
}
int size(){
return s[root];
}
// 查第 k 小 , 必须保证合法
int kth( int x , int k ){
if( k == s[lft[x]] + 1 ) return key[x];
else if( k <= s[lft[x]] ) return kth( lft[x] , k );
else return kth( rht[x] , k - s[lft[x]] - 1 );
}
//找前驱
int pred( int t , int v ){
if( t == 0 ) return v;
else{
if( v <= key[t] ) return pred( lft[t] , v );
else{
int ans = pred( rht[t] , v );
if( ans == v ) ans = key[t];
return ans;
}
}
}
// 严格小于 v 的有多少个
int less( int t , int v ){
if( t == 0 ) return 0;
if( v <= key[t] ) return less( lft[t] , v );
else return s[lft[t]] + 1 + less( rht[t] , v );
}
//找后继
int succ( int t , int v ){
if( t == 0 ) return v;
else{
if( v >= key[t] ) return succ( rht[t] , v );
else{
int ans = succ( lft[t] , v );
if( ans == v ) ans = key[t];
return ans;
}
}
}
}sbt;
行列式
int Det(){
int cur = 0 , sgn = 1;
for( int i = 0 ; i < N ; ++ i){
int nxt = -1;
for( int j = cur ; j < N ; ++ j) if( mat[j][i]){
nxt = j ;
break ;
}
if( nxt == -1 ) return 0;
if( nxt != cur ) sgn = - sgn;
for( int j = 0 ; j < N ; ++ j) swap( mat[cur][j] , mat[nxt][j] );
for( int j = cur + 1 ; j < N ; ++ j){
while( mat[j][i] ){
int x = mat[j][i] / mat[cur][i];
if( x ){
for( int k = i ; k < N ; ++ k){
mat[j][k] -= mul( mat[cur][k] , x ) ;
Maintain(mat[j][k]);
}
}else{
for( int k = i ; k < N ; ++ k) swap( mat[j][k] , mat[cur][k] );
sgn = - sgn;
}
}
}
++ cur;
}
int ans = 1;
for( int i = 0 ; i < N ; ++ i ) ans = mul( ans , mat[i][i] );
if( sgn == -1 ) ans = P - ans;
return ans;
}
double Det(){
//-- N;
double ans = 1;
int cur = 0 , sgn = 1;
for(int i = 0 ; i < N ; ++ i){
int nxt = -1;
for( int j = cur ; j < N ; ++ j) if( fabs(mat[j][i]) > eps ){
nxt = j ;
break ;
}
if( nxt == -1 ) continue;
for( int j = 0 ; j < N ; ++ j) swap( mat[cur][j] , mat[nxt][j] );
if( nxt != cur ) sgn = - sgn;
for( int j = 0 ; j < N ; ++ j ) if( j != cur ){
double s = mat[j][i] / mat[cur][i];
for( int k = i ; k < N ; ++ k) mat[j][k] -= s * mat[cur][k];
}
++ cur ;
}
for( int i = 0 ; i < N ; ++ i) ans = ans * mat[i][i];
return ans * sgn;
}uestc_retarded 模板的更多相关文章
- Jade模板引擎让你飞
写在前面:现在jade改名成pug了 一.安装 npm install jade 二.基本使用 1.简单使用 p hello jade! 渲染后: <p>hello jade!</p ...
- ABP入门系列（2）——通过模板创建MAP版本项目
一.从官网创建模板项目 进入官网下载模板项目 依次按下图选择: 输入验证码开始下载 下载提示: 二.启动项目 使用VS2015打开项目,还原Nuget包: 设置以Web结尾的项目,设置为启动项目: 打 ...
- CMS模板应用调研问卷
截止目前,已经有数十家网站与我们合作,进行了MIP化改造,在搜索结果页也能看到"闪电标"的出现.除了改造方面的问题,MIP项目组被问到最多的就是:我用了wordpress,我用了织 ...
- PHP-自定义模板-学习笔记
1. 开始 这几天,看了李炎恢老师的<PHP第二季度视频>中的“章节7:创建TPL自定义模板”,做一个学习笔记,通过绘制架构图.UML类图和思维导图,来对加深理解. 2. 整体架构图 ...
- 【原创分享·微信支付】C# MVC 微信支付之微信模板消息推送
微信支付之微信模板消息推送 今天我要跟大家分享的是“模板消息”的推送,这玩意呢,你说用途嘛,那还是真真的牛逼呐.原因在哪?就是因为它是依赖微信生存的呀,所以他能不 ...
- OpenCV模板匹配算法详解
1 理论介绍 模板匹配是在一幅图像中寻找一个特定目标的方法之一,这种方法的原理非常简单,遍历图像中的每一个可能的位置,比较各处与模板是否“相似”,当相似度足够高时,就认为找到了我们的目标.OpenCV ...
- 前端MVC学习总结（一）——MVC概要与angular概要、模板与数据绑定
一.前端MVC概要 1.1.库与框架的区别 框架是一个软件的半成品,在全局范围内给了大的约束.库是工具,在单点上给我们提供功能.框架是依赖库的.AngularJS是框架而jQuery则是库. 1.2. ...
- ThinkPHP+Smarty模板中截取包含中英文混合的字符串乱码的解决方案
好几天没写博客了,其实有好多需要总结的,因为最近一直在忙着做项目,但是困惑了几天的Smarty模板中截取包含中英文混合的字符串乱码的问题,终于解决了,所以记录下来,需要的朋友看一下: 出现乱码的原因: ...
- ThinkPHP 模板substr的截取字符串函数
ThinkPHP 模板substr的截取字符串函数在Common/function.php加上以下代码 /** ** 截取中文字符串 **/ function msubstr($str, $start ...
随机推荐
- spring随想
//不定时持续更新 1.拦截器通过配置文件,在某方法前后添加一些处理,如权限判断等,减少了改方法需要处理的事,是其更专注,由配置文件来设定责任链,更灵活,而且责任链能够复用(一方面是这样能由sprin ...
- Hyper-V初涉_早期Windows安装虚拟硬件驱动
虽然微软已经一再强调将要对Windows XP停止提供服务,但是难免在一些特殊场合需要早期的系统进行测试.为了测试需要,我在Hyper-V中安装了Windows XP. 按照之前的方法,对Hyper- ...
- UITableView动态存放、重用机制
一.UITableView动态存放 #import "ViewController.h"@interface ViewController ()<UITableViewDel ...
- linux下解决端口被占用问题
查找被占用的端口: netstat -tln netstat -tln | grep 8080 查看端口属于哪个程序 lsof -i :8080 杀掉占用端口的进程: kill -9 进程ID ...
- PostgreSQL学习记录-- 2016-03-11
1.日期字段 “年月日” 使用 date “年月日 时分秒” 使用 timestamp without time zone 2.布尔字段 使用 boolean 3.字符字段 使用 character ...
- EL表达式的操作符
表9.1 EL表达式的操作符 操作符 功能和作用 . 访问一个bean属性或者Map entry [] 访问一个数组或者链表元素 () 对子表达式分组,用来改变赋值顺序 ? : 条件语句,比如:条件? ...
- eclipse运行maven的jetty插件内存溢出
系统运行在Maven中的Jetty插件下,当在Eclipse运行clean jetty:run时,系统提示OutOfMemoryError: PermGen space.解决办法:设置run as - ...
- 解析json实例
解析项目目录中的一个json文件,将之转化为List的一个方法. package com.miracles.p3.os.util; import com.miracles.p3.os.mode.Vid ...
- JavaScript 中的 this ,看着一篇就够了
tip 在 js 中,this 这个上下文总是变化莫测,很多时候出现 bug 总是一头雾水,其实,只要分清楚不同的情况下如何执行就 ok 了. 全局执行 首先,我们在全局环境中看看它的 this 是什 ...
- atitit. hb 原生sql跨数据库解决原理 获得hb 数据库类型运行期获得Dialect
atitit. hb 原生sql跨数据库解决原理 获得hb 数据库类型运行期获得Dialect #-----原理 Hibernate 运行期获得Dialect 2010-07-28 12:59 ...