每一项按顺序理解之后裸敲，每个代码最多15分钟，用模板题来测，超过15分钟算未理解
线段树
平衡树（ Treap , sbt , spt ）
二叉堆
const int N = 1000010 ;
int h[N] , size ;
void Modify( int p ) {
if( p == 1 ) return ;
if( h[p>>1] > h[p] ) swap( h[p>>1] , h[p] ) , Modify( p>>1 ) ;
}
void Update( int p ) {
int l = p<<1 , r = p<<1|1 , f = p ;
if( l <= size && h[l] < h[f] ) f = l ;
if( r <= size && h[r] < h[f] ) f = r ;
if( p != f ) swap( h[f] , h[p] ) , Update(f) ;
}
void Pop() {
swap( h[1] , h[size--] ) ; Update(1) ;
}
void Push( int x ) {
h[++size] = x ; Modify( size ) ;
}
左偏树
最短路( Dij , Spfa )
匈牙利
HK
带花树
Dinic
const int N = 404;
const int M = 30030 ;
const int inf = 1e9 ;
int s , t , n , m ;
int eh[N] , ef[M] , et[M] , ec[M] , nxt[M] , tot ;
int cur[N] , d[N] ;
bool vis[N] ;
void init() {
memset( eh , -1 , sizeof eh ) ;
tot = 0 ;
}
void addedge( int u , int v, int c , int f ) {
et[tot] = v , ec[tot] = c , ef[tot] = f , nxt[tot] = eh[u] , eh[u] = tot++ ;
et[tot] = u , ec[tot] = 0 , ef[tot] = f , nxt[tot] = eh[v] , eh[v] = tot++ ;
}
bool bfs() {
memset( vis , false , sizeof vis ) ;
queue<int>que;
que.push(s);
vis[s] = true ;
d[s] = 0 ;
while( !que.empty() ) {
int u = que.front() ; que.pop() ;
for( int i = eh[u] ; ~i ; i = nxt[i] ) {
int v = et[i] ;
if( !vis[v] && ef[i] < ec[i] ) {
vis[v] = true ;
d[v] = d[u] + 1 ;
que.push(v);
}
}
}
return vis[t] ;
}
int dfs( int x , int a ) {
if( x == t || a == 0 ) return a ;
int flow = 0 , F ;
for( int &i = cur[x] ; ~i ; i = nxt[i] ) {
int v = et[i] , c = ec[i] , &f = ef[i] ;
if( d[x] + 1 == d[v] && ( F = dfs( v , min( a , c - f ) ) ) > 0 ) {
f += F , ef[i^1] -= F , a -= F , flow += F ;
if( a == 0 ) break ;
}
}
return flow ;
}
int MF() {
int flow = 0 ;
while( bfs() ) {
memcpy( cur , eh , sizeof eh ) ;
flow += dfs( s , 10000000 );
}
return flow ;
}
ISAP
const int N = 1020 ;
const int M = 300010 ;
const int INF = 0x3f3f3f3f;
int n , m , s , t ;
int eh[N] , et[M] , nxt[M] , ef[M] , ec[M] , tot ;
void init() {
memset( eh , -1 , sizeof eh ) ;
tot = 0 ;
}
void addedge( int u , int v , int c ) {
et[tot] = v ; ec[tot] = c ; ef[tot] = 0 ; nxt[tot] = eh[u] ; eh[u] = tot++;
et[tot] = u ; ec[tot] = 0 ; ef[tot] = 0 ; nxt[tot] = eh[v] ; eh[v] = tot++;
}
int d[N] , cur[N] , pre[N] , gap[N] ;
int Q[M] , S[M] ;
void bfs() {
memset( d , -1 , sizeof d ) ;
memset( gap , 0 , sizeof gap ) ;
int head = 0 , tail = 0 ;
d[t] = 0 ; gap[0]++ ;
Q[tail++] = t ;
while( head < tail ) {
int u = Q[head++] ;
for( int i = eh[u] ; ~i ; i = nxt[i] ) {
int v = et[i] ;
if( d[v] != -1 ) continue ;
Q[tail++] = v ;
d[v] = d[u] + 1;
gap[ d[v] ]++;
}
}
}
int Sap( int n ) {
bfs();
memcpy( cur , eh , sizeof eh ) ;
int top = 0 , u = s , flow = 0 ;
while( d[s] < n ) {
if( u == t ) {
int Min = INF , inser ;
for( int i = 0 ; i < top ; ++i ) {
if( Min > ec[ S[i] ] - ef[ S[i] ] ) {
Min = ec[ S[i] ] - ef[ S[i] ] ;
inser = i ;
}
}
for( int i = 0 ; i < top ; ++i ) {
ef[ S[i] ] += Min ;
ef[ S[i]^1 ] -= Min ;
}
flow += Min ;
top = inser ;
u = et[ S[top]^1 ];
continue ;
}
bool flag = false ;
int v ;
for( int i = cur[u] ; ~i ; i = nxt[i] ) {
v = et[i] ;
if( ec[i] > ef[i] && d[v] + 1 == d[u] ) {
flag = true ;
cur[u] = i ;
break ;
}
}
if( flag ) {
S[top++] = cur[u] ;
u = v ;
continue ;
}
int Min = n ;
for( int i = eh[u] ; ~i ; i = nxt[i] ) {
if( ec[i] > ef[i] && d[ et[i] ] < Min ) {
Min = d[ et[i] ] ;
cur[u] = i ;
}
}
gap[ d[u] ]-- ;
if( !gap[ d[u] ] ) return flow ;
d[u] = Min + 1 ;
gap[ d[u] ]++ ;
if( u != s ) u = et[ S[--top]^1 ] ;
}
return flow ;
}
MCMF
const int N = 10000;
const int M = 100000;
const int INF = 0x3f3f3f3f;
int eh[N] , ec[M] , et[M] , ef[M] , ew[M] , nxt[M] , tot ;
int pre[N] , dis[N] ;
bool vis[N] ;
int s , t , n , m , k ;
void init() {
memset( eh, -1 , sizeof eh );
tot = 0 ;
}
void addedge( int u , int v , int cap , int cost ) {
et[tot] = v ; ef[tot] = 0 ; ec[tot] = cap ; ew[tot] = cost ; nxt[tot] = eh[u] ; eh[u] = tot++ ;
et[tot] = u ; ef[tot] = 0 ; ec[tot] = 0 ; ew[tot] = -cost ; nxt[tot] = eh[v] ; eh[v] = tot++ ;
}
bool spfa() {
memset( vis, false, sizeof vis ) ;
memset( dis ,0x3f , sizeof dis ) ;
memset( pre , -1 ,sizeof pre ) ;
queue<int>que;
dis[s] = 0 ;
vis[s] = true ;
que.push(s) ;
while( !que.empty() ) {
int u = que.front() ; que.pop() ;
vis[u] =false ;
for( int i = eh[u] ; ~i ; i = nxt[i] ) {
int v = et[i] ;
if( ec[i] > ef[i] && dis[v] > dis[u] + ew[i] ) {
dis[v] = dis[u] + ew[i] ;
pre[v] = i ;
if( !vis[v] ) {
vis[v] = true ;
que.push(v) ;
}
}
}
}
return pre[t] != -1 ;
}
int MCMF( int &cost ) {
int flow = 0 ;
cost = 0 ;
while( spfa() ) {
int Min = INF ;
for( int i = pre[t] ; ~i ; i = pre[ et[i^1] ] ) {
if( Min > ec[i] - ef[i] ) {
Min = ec[i] - ef[i] ;
}
}
for( int i = pre[t] ; ~i ; i = pre[ et[i^1] ] ) {
ef[i] += Min ;
ef[i^1] -= Min ;
cost += ew[i] * Min ;
}
flow += Min ;
}
return flow ;
}
BCC
SCC
KMP
Manancher
AC自动机
后缀数组
后缀自动机
DXL（精确覆盖，模糊覆盖）
时间： 2024-10-24 17:18:45