大家都很强, 可与之共勉。
#include <queue>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define mid(l, r) ( l >> 1 ) + ( r >> 1 ) + ( l & r & 1 )
#define min(a, b) ((a) < (b) ? (a) : (b))
const int MaxN = 5 ;
const int Inf = ( 1 << 31 ) - 1 ;
int a, b ;
int ans[10] ;
struct edge {
int to, w, nxt ;
edge ( ) { }
edge ( int to, int w, int nxt ) : to ( to ), w ( w ), nxt ( nxt ) { }
} g[MaxN << 1] ;
int head[MaxN], ne = 1 ;
inline void Adde( int u, int v, int w ) { g[++ ne] = edge ( v, w, head[u] ) ; head[u] = ne ; }
inline int Binary_search ( ) {
static int l, r, mid ;
l = -Inf, r = Inf ;
while ( l ^ r ) {
mid = mid(l, r) ;
mid - a < b ? l = mid + 1 : r = mid ;
}
return l ;
}
int fa[MaxN] ;
inline int find ( int x ) {
while ( x ^ fa[x] ) x = fa[x] = fa[fa[x]] ; return x ;
}
struct EDGE {
int u, v, w ;
EDGE ( ) { }
EDGE ( int u, int v, int w ) : u ( u ), v ( v ), w ( w ) { }
inline short operator < ( const EDGE& rhs ) const {
return w < rhs.w ;
}
} E[MaxN];
inline int Kruskal ( ) {
E[1] = EDGE ( 1, 2, a ) ;
E[2] = EDGE ( 2, 3, b ) ;
static int cnt ;
static int ans ;
cnt = ans = 0 ;
std :: sort ( E + 1, E + 1 + 2 ) ;
for ( int i = 1 ; i <= MaxN ; ++ i ) fa[i] = i ;
for ( int i = 1 ; cnt ^ 2 ; ++ i ) {
int u = E[i].u, v = E[i].v ;
int x = find ( u ), y = find ( v ) ;
if ( x ^ y ) {
fa[x] = y ;
ans += E[i].w ;
++ cnt ;
}
}
return ans ;
}
inline int Floyd ( ) {
static int f[MaxN][MaxN], tmp ;
for ( int i = 1 ; i <= 3 ; ++ i )
for ( int j = 0 ; j < 3 ; f[i][++j] = 0x3f3f3f3f ) ;
f[1][2] = a, f[2][3] = b ;
for ( int k = 1 ; k <= 3 ; ++ k )
for ( int i = 1 ; i <= 3 ; ++ i )
for ( int j = 1 ; j <= 3 ; ++ j )
f[i][j] > ( tmp = f[i][k] + f[k][j] ) ? f[i][j] = tmp : 1 ;
return f[1][3] ;
}
class Network_Flows {
private:
struct Edge {
int to, nxt, w ;
Edge ( ) { }
Edge ( int to, int w, int nxt ) : to ( to ), w ( w ), nxt ( nxt ) { }
} G[MaxN << 1];
int hhead[MaxN], nne ;
int S, T, ret ;
int cur[MaxN], dep[MaxN] ;
inline void Adde( int u, int v, int w ) { G[++ nne] = Edge ( v, w, hhead[u] ) ; hhead[u] = nne ; }
inline short Bfs ( ) {
static int fr, tl, q[MaxN << 1] ;
static int u, v;
memset ( dep, 0, sizeof ( int ) * ( T + 1 ) ) ;
fr = tl = 0 ;
q[++ tl] = S ;
dep[S] = 1 ;
while ( fr ^ tl ) {
u = q[++ fr] ;
for ( int i = hhead[u] ; i ; i = G[i].nxt ) {
v = G[i].to;
if ( G[i].w && !dep[v] ) {
dep[v] = dep[u] + 1 ;
q[++ tl] = v ;
}
}
}
return dep[T] != 0 ;
}
int Dfs ( int u, int a ) {
if ( u == T || !a ) return a ;
int v, f, flow = 0 ;
for( int& i = cur[u] ; i ; i = G[i].nxt ) {
v = G[i].to ;
if ( dep[v] == dep[u] + 1 ) {
f = Dfs ( v, min( a - flow, G[i].w ) ) ;
G[i].w -= f ; G[i ^ 1].w += f ;
flow += f ;
if ( flow == a ) return flow ;
}
}
if ( !flow ) dep[u] = -1 ;
return flow;
}
public:
Network_Flows ( ) {
memset ( hhead, 0, sizeof hhead ) ;
nne = 1 ;
}
inline void AddDbe ( int u, int v, int w ) {
Adde ( u, v, w ) ; Adde ( v, u, 0 ) ;
}
inline int Dinic ( int S, int T ) {
this -> S = S, this -> T = T ;
ret = 0 ;
while ( Bfs ( ) ) {
memcpy ( cur, hhead, sizeof ( int ) * ( T + 1 ) ) ;
ret += Dfs ( S, Inf ) ;
}
return ret ;
}
} Lazer ;
inline int Spfa ( ) {
static int dis[MaxN], tmp ;
static short vis[MaxN] ;
static int s = 1, t = 3, u, v ;
static std :: deque < int > q ;
for ( int i = 1 ; i <= t ; ++ i ) vis[i] = 0 ;
for ( int i = 1 ; i <= t ; ++ i ) dis[i] = 0x3f3f3f3f ;
dis[s] = 0 ;
q.push_front ( s ) ;
vis[s] = 1 ;
while ( !q.empty ( ) ) {
u = q.front ( ) ;
q.pop_front ( ) ;
vis[u] = 0 ;
for ( int i = head[u] ; i ; i = g[i].nxt ) {
v = g[i].to ;
if ( dis[v] > ( tmp = dis[u] + g[i].w ) ) {
dis[v] = tmp ;
if ( !vis[v] ) {
( q.empty() || dis[v] < dis[q.front()] ) ? q.push_front ( v ) : q.push_back ( v ) ;
vis[v] = 1 ;
}
}
}
}
return dis[t] ;
}
class SegmentTree {
private :
struct node {
int sum , lazy;
short flag ;
node *ls, *rs ;
inline void pushdown ( int lf, int rg ) {
if ( flag ) {
ls -> flag = rs -> flag = 1 ;
ls -> lazy = rs -> lazy = lazy ;
flag = 0 ;
int mid = mid(lf, rg) ;
ls -> sum = ( mid - lf + 1 ) * lazy ;
rs -> sum = ( rg - mid ) * lazy ;
}
}
inline void update ( ) {
sum = ls -> sum + rs -> sum ;
}
} pool[MaxN << 1], *root, *tail ;
inline void Modify ( node* &nd, int lf, int rg, int L, int R, int delta ) {
if ( L <= lf && rg <= R ) {
nd -> sum = ( lf - rg + 1 ) * delta ;
nd -> flag = 1 ;
nd -> lazy = delta ;
return ;
}
nd -> pushdown ( lf, rg ) ;
int mid = mid(lf, rg) ;
if ( L <= mid ) Modify ( nd -> ls, lf, mid, L, R, delta ) ;
if ( mid < R ) Modify ( nd -> rs, mid + 1, rg, L, R, delta ) ;
nd -> update ( ) ;
}
inline int Query ( node* &nd, int lf, int rg, int L, int R ) {
if ( L <= lf && rg <= R ) return nd -> sum ;
nd -> pushdown ( lf, rg ) ;
int mid = mid(lf, rg) ;
int rt = 0 ;
if ( L <= mid ) rt += Query ( nd -> ls, lf, mid, L, R ) ;
if ( mid < R ) rt += Query ( nd -> rs, mid + 1, rg, L, R ) ;
return rt ;
}
inline node* _Build ( int lf, int rg ) {
node *nd = ++ tail ;
nd -> sum = nd -> flag = 0 ;
if ( lf ^ rg ) {
int mid = mid(lf, rg) ;
nd -> ls = _Build ( lf, mid ) ;
nd -> rs = _Build ( mid + 1, rg ) ;
}
return nd ;
}
public :
SegmentTree ( ) {
tail = pool ;
}
inline void Build ( int lf, int rg ) {
root = _Build ( lf, rg ) ;
}
inline void Modify ( int L, int R, int delta ) {
Modify ( root, 1, 5, L, R, delta ) ;
}
inline int Query ( int L, int R ) {
return Query ( root, 1, 5, L, R ) ;
}
} Seg;
namespace BIT {
#define lowbit(x) ( ( x ) & ( ( ~x ) + 1 ) )
int R[MaxN] ;
inline void Insert ( int pos, int x ) {
for ( int i = pos ; i <= 3; i += lowbit(i) ) R[i] += x ;
}
inline int Query ( int pos ) {
static int rt ;
rt = 0 ;
for ( int i = pos ; i ; i -= lowbit(i) ) rt += R[i] ;
return rt ;
}
}
inline int Dp ( ) {
static int tmp, dp[MaxN], w[MaxN], c[MaxN] ;
w[1] = w[2] = 1 ;
c[1] = a , c[2] = b ;
for ( int i = 1 ; i <= 2 ; ++ i )
for ( int j = MaxN ; j >= w[i] ; -- j )
dp[j] < ( tmp = dp[j - w[i]] + c[i] ) ? dp[j] = tmp : 1 ;
return dp[2] ;
}
inline void Init ( ) {
Adde ( 1, 2, a ) ;
Adde ( 2, 3, b ) ;
Lazer.AddDbe ( 0, 1, Inf ) ;
Lazer.AddDbe ( 0, 2, Inf ) ;
Lazer.AddDbe ( 1, 3, a ) ;
Lazer.AddDbe ( 2, 3, b ) ;
BIT :: Insert ( 1, a ) ;
BIT :: Insert ( 2, b ) ;
Seg.Build ( 1, 5 ) ;
Seg.Modify ( 1, 1, a ) ;
Seg.Modify ( 2, 2, b ) ;
}
struct Dot {
int id, dis ;
Dot ( ) { }
Dot ( int id, int dis ) : id ( id ), dis ( dis ) { }
inline short operator < ( const Dot& rhs ) const {
return dis > rhs.dis ;
}
} d[MaxN];
inline int Dijkstra ( ) {
static std :: priority_queue < Dot > q ;
static int dis[MaxN] ;
static short vis[MaxN] ;
for ( int i = 1 ; i <= MaxN ; ++ i ) dis[i] = 0x3f3f3f3f ;
for ( int i = 1 ; i <= MaxN ; ++ i ) vis[i] = 0 ;
q.push ( Dot ( 1, 0 ) ) ;
vis[1] = 1 ;
dis[1] = 0 ;
while ( !q.empty ( ) ) {
int u = q.top( ).id;
q.pop ( ) ;
for ( int i = head[u] ; i ; i = g[i].nxt ) {
int v = g[i].to ;
if ( dis[v] > dis[u] + g[i].w && !vis[v]) {
dis[v] = dis[u] + g[i].w ;
q.push ( Dot ( v, dis[v] ) ) ;
vis[v] = 1 ;
}
}
}
return dis[3] ;
}
int main ( ) {
scanf ( "%d%d", &a, &b ) ;
Init ( ) ;
ans[0] = Binary_search ( ) ;
ans[1] = Floyd ( ) ;
ans[2] = Spfa ( ) ;
ans[3] = BIT :: Query ( 2 ) ;
ans[4] = Seg.Query ( 1, 2 ) ;
ans[5] = Lazer.Dinic ( 0, 3 ) ;
ans[6] = Dp ( ) ;
ans[7] = Kruskal ( ) ;
ans[8] = Dijkstra ( ) ;
long long rt = 0 ;
for ( int i = 0 ; i < 9 ; ++ i ) rt += ans[i] ;
printf ( "%d\n", rt / 9 ) ;
}