BZOJ-1000 A + B Problem 丧心病狂

大家都很强， 可与之共勉。

#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 ; // cannot be 0; 
        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 ) ;
}