【HDU】5736 Call It What You Want【暴力+dp】

题目链接：Call It What You Want

暴力枚举经过的顺序，然后起点终点在一个子树的做个dp即可。

#include <bits/stdc++.h>
using namespace std ;

typedef long long LL ;

#define clr( a , x ) memset ( a , x , sizeof a )

const int MAXN = 100005 ;
const int MAXE = 200005 ;
const int INF = 0x3f3f3f3f ;

struct Edge {
    int v , n ;
    Edge () {}
    Edge ( int v , int n ) : v ( v ) , n ( n ) {}
} ;

Edge E[MAXE] ;
int H[MAXN] , cntE ;
int d[10][MAXN] , f[10][MAXN] ;
int p[MAXN] ;
int a[10] , cnt , G[10][10] ;
int n , m ;
int dis , idx ;
vector < int > edge , path ;
int use[10] ;
int vis[MAXN] , Time ;
int ans ;
int S[MAXN] , val[MAXN] , top ;
int L[MAXN] , R[MAXN] ;
int T ;

void init () {
    cntE = 0 ;
    clr ( H , -1 ) ;
}

void addedge ( int u , int v ) {
    E[cntE] = Edge ( v , H[u] ) ;
    H[u] = cntE ++ ;
}

int F ( int x ) {
    return p[x] == x ? x : ( p[x] = F ( p[x] ) ) ;
}

void bfs ( int s ) {
    queue < int > q ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        d[s][i] = INF ;
    }
    q.push ( a[s] ) ;
    d[s][a[s]] = 0 ;
    f[s][a[s]] = 0 ;
    while ( !q.empty () ) {
        int u = q.front () ;
        q.pop () ;
        for ( int i = H[u] ; ~i ; i = E[i].n ) {
            int v = E[i].v ;
            if ( d[s][v] == INF ) {
                d[s][v] = d[s][u] + 1 ;
                f[s][v] = u ;
                q.push ( v ) ;
            }
        }
    }
}

void get_dis ( int u , int fa , int dist ) {
    if ( dist > dis ) {
        idx = u ;
        dis = dist ;
    }
    for ( int i = H[u] ; ~i ; i = E[i].n ) {
        int v = E[i].v ;
        if ( v == fa ) continue ;
        get_dis ( v , u , dist + 1 ) ;
    }
}

int paint () {
    int dist = 0 ;
    ++ Time ;
    vis[a[path[0]]] = Time ;
    for ( int o = 1 ; o < path.size () ; ++ o ) {
        int x = path[o - 1] , y = a[path[o]] ;
        if ( o % 2 == 0 ) {
            if ( a[x] == y ) continue ;
        }
        if ( vis[y] == Time ) return 0 ;
        if ( o & 1 ) {
            vis[y] = Time ;
            dist ++ ;
            continue ;
        }
        while ( y != a[x] ) {
            if ( vis[y] == Time ) return 0 ;
            vis[y] = Time ;
            y = f[x][y] ;
            dist ++ ;
        }
    }
    return dist ;
}

int max_dis ( int u , int fa ) {
    int dist = 0 ;
    for ( int i = H[u] ; ~i ; i = E[i].n ) {
        int v = E[i].v ;
        if ( v == fa || vis[v] == Time ) continue ;
        dist = max ( dist , max_dis ( v , u ) + 1 ) ;
    }
    return dist ;
}

int in_one_tree ( int u , int o , int fa ) {
    for ( int i = H[u] ; ~i ; i = E[i].n ) {
        int v = E[i].v ;
        if ( v == fa ) continue ;
        if ( v == o ) return 1 ;
        if ( vis[v] == Time ) continue ;
        if ( in_one_tree ( v , o , u ) ) return 1 ;
    }
    return 0 ;
}

int dfs2 ( int u , int t , int fa ) {
    S[++ top] = u ;
    for ( int i = H[u] ; ~i ; i = E[i].n ) {
        int v = E[i].v ;
        if ( v == fa ) continue ;
        if ( v == t ) {
            S[++ top] = v ;
            return 1 ;
        }
        if ( vis[v] == Time ) continue ;
        vis[v] = Time ;
        if ( dfs2 ( v , t , u ) ) return 1 ;
        vis[v] = Time - 1 ;
    }
    -- top ;
    return 0 ;
}

int calc ( int s , int t ) {
    int dist = 0 ;
    top = 0 ;
    dfs2 ( s , t , s ) ;
    for ( int i = 1 ; i <= top ; ++ i ) {
        val[i] = max_dis ( S[i] , S[i] ) ;
    }
    L[0] = R[top + 1] = 0 ;
    for ( int i = 1 ; i <= top ; ++ i ) {
        L[i] = max ( L[i - 1] , val[i] + i - 1 ) ;
    }
    for ( int i = top ; i >= 1 ; -- i ) {
        R[i] = max ( R[i + 1] , val[i] + top - i ) ;
    }
    for ( int i = 1 ; i < top ; ++ i ) {
        dist = max ( dist , L[i] + R[i + 1] ) ;
    }
    return dist ;
}

void dfs ( int cur ) {
    int x = path.size () ;
    if ( cur == edge.size () ) {
        int dist = paint () ;
        if ( !dist ) return ;
        if ( in_one_tree ( a[path[0]] , a[path[x - 1]] , a[path[1]] ) ) {
            ans = max ( ans , dist + calc ( a[path[0]] , a[path[x - 1]] ) ) ;
        } else {
            int tmpx = max_dis ( a[path[0]] , a[path[1]] ) ;
            int tmpy = max_dis ( a[path[x - 1]] , a[path[x - 2]] ) ;
            ans = max ( ans , dist + tmpx + tmpy ) ;
        }
        return ;
    }
    for ( int i = 0 ; i < edge.size () ; ++ i ) if ( !use[i] ) {
        use[i] = 1 ;
        path.push_back ( edge[i] * 2 ) ;
        path.push_back ( edge[i] * 2 + 1 ) ;
        dfs ( cur + 1 ) ;
        swap ( path[x] , path[x + 1] ) ;
        dfs ( cur + 1 ) ;
        path.pop_back () ;
        path.pop_back () ;
        use[i] = 0 ;
    }
}

void solve () {
    init () ;
    cnt = 0 ;
    clr ( use , 0 ) ;
    scanf ( "%d%d" , &n , &m ) ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        p[i] = i ;
    }
    for ( int i = 0 ; i < m ; ++ i ) {
        int u , v ;
        scanf ( "%d%d" , &u , &v ) ;
        int x = F ( u ) ;
        int y = F ( v ) ;
        if ( x != y ) {
            p[x] = y ;
            addedge ( u , v ) ;
            addedge ( v , u ) ;
        } else {
            a[cnt ++] = u ;
            a[cnt ++] = v ;
        }
    }
    for ( int i = 0 ; i < cnt ; ++ i ) {
        bfs ( i ) ;
        for ( int j = 0 ; j < cnt ; ++ j ) {
            G[i][j] = d[i][a[j]] ;
        }
    }
    m -= n - 1 ;
    dis = 0 ;
    get_dis ( 1 , 1 , 0 ) ;
    dis = 0 ;
    get_dis ( idx , idx , 0 ) ;
    ans = dis ;
    for ( int o = 1 ; o < 1 << m ; ++ o ) {
        edge.clear () ;
        path.clear () ;
        for ( int j = 0 ; j < m ; ++ j ) if ( o & ( 1 << j ) ) {
            edge.push_back ( j ) ;
        }
        dfs ( 0 ) ;
    }

    printf ( "%d\n" , ans ) ;
}

int main () {
    clr ( vis , 0 ) ;
    Time = 0 ;
    scanf ( "%d" , &T ) ;
    for ( int i = 1 ; i <= T ; ++ i ) solve () ;
    return 0 ;
}