Submission #911787

#	Time	Username	Problem	Language	Result	Execution time	Memory
911787		GrindMachine	Hard route (IZhO17_road)	C++17	0 / 100	1 ms	860 KiB

road

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

template<typename T> using Tree = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long int ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL)
#define pb push_back
#define endl '\n'
#define sz(a) (int)a.size()
#define setbits(x) __builtin_popcountll(x)
#define ff first
#define ss second
#define conts continue
#define ceil2(x,y) ((x+y-1)/(y))
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define yes cout << "Yes" << endl
#define no cout << "No" << endl

#define rep(i,n) for(int i = 0; i < n; ++i)
#define rep1(i,n) for(int i = 1; i <= n; ++i)
#define rev(i,s,e) for(int i = s; i >= e; --i)
#define trav(i,a) for(auto &i : a)

template<typename T>
void amin(T &a, T b) {
    a = min(a,b);
}

template<typename T>
void amax(T &a, T b) {
    a = max(a,b);
}

#ifdef LOCAL
#include "debug.h"
#else
#define debug(x) 42
#endif

/*



*/

const int MOD = 1e9 + 7;
const int N = 5e3 + 5;
const int inf1 = int(1e9) + 5;
const ll inf2 = ll(1e18) + 5;

template<typename T>
struct two_max{
    pair<T,T> a;
    
    two_max(){
        a = {{-inf2,-inf2},{-inf2,-inf2}};
    }

    void insert(T p){
        if(p > a.ff){
            a.ss = a.ff;
            a.ff = p;
        }
        else if(p > a.ss){
            a.ss = p;
        }
    }

    T first_max(){
        return a.ff;
    }

    T second_max(){
        return a.ss;
    }
};

vector<ll> adj[N];
vector<ll> depth(N), deepest(N);

void dfs1(ll u, ll p){
    trav(v,adj[u]){
        if(v == p) conts;
        depth[v] = depth[u]+1;
        dfs1(v,u);
        amax(deepest[u],deepest[v]+1);
    }
}

vector<ll> deepest_outside(N);
vector<two_max<pll>> deepest_par(N);

void dfs2(ll u, ll p){
    vector<ll> children;
    children.pb(0);
    trav(v,adj[u]){
        if(v == p) conts;
        children.pb(v);
    }

    ll siz = sz(children)-1;
    vector<two_max<pll>> pmx(siz+5), smx(siz+5);

    rep1(i,siz){
        ll v = children[i];
        pmx[i] = pmx[i-1];
        pmx[i].insert({deepest[v]+1,v});
    }

    rev(i,siz,1){
        ll v = children[i];
        smx[i] = smx[i+1];
        smx[i].insert({deepest[v]+1,v});
    }

    rep1(i,siz){
        two_max tm = pmx[i-1];
        tm.insert(smx[i+1].a.ff);
        tm.insert(smx[i+1].a.ss);

        ll v = children[i];
        deepest_par[v] = tm;
        deepest_outside[v] = max(deepest_outside[u]+1,tm.first_max().ff+1);

        dfs2(v,u);
    }
}

vector<pll> leaves[N];
ll mx_val = -inf2, mx_cnt = 0;

void dfs3(ll u, ll p){
    if(sz(adj[u]) == 1){
        leaves[u].pb({u,0});
        return;
    }

    vector<ll> children;
    trav(v,adj[u]){
        if(v == p) conts;
        dfs3(v,u);
        children.pb(v);
    }

    ll siz = sz(children);

    rep(i,siz){
        for(int j = i+1; j < siz; ++j){
            ll v1 = children[i], v2 = children[j];
            for(auto [x,mx_x] : leaves[v1]){
                for(auto [y,mx_y] : leaves[v2]){
                    ll len = depth[x]+depth[y]-2*depth[u];
                    ll mx = max(mx_x,mx_y);
                    amax(mx,deepest_outside[u]);
                    if(deepest_par[x].first_max().ss != v2){
                        amax(mx,deepest_par[x].first_max().ff);
                    }
                    else{
                        assert(deepest_par[x].second_max().ss != v2);
                        amax(mx,deepest_par[x].second_max().ff);
                    }

                    // debug(x);
                    // debug(y);
                    // debug(len);
                    // debug(mx);
                    // debug(deepest_par[x].first_max());
                    // cout << endl;

                    ll val = len*mx;
                    if(val > mx_val){
                        mx_val = val;
                        mx_cnt = 1;
                    }
                    else if(val == mx_val){
                        mx_cnt++;
                    }
                }
            }
        }
    }

    trav(v,children){
        for(auto [x,mx_x] : leaves[v]){
            leaves[u].pb({x,max(mx_x,deepest_par[x].first_max().ff)});
        }

        leaves[v].clear();
    }
}

void solve(int test_case)
{
    ll n; cin >> n;
    rep1(i,n-1){
        ll u,v; cin >> u >> v;
        adj[u].pb(v), adj[v].pb(u);
    }

    if(n == 2){
        cout << 0 << " " << 1 << endl;
        return;
    }

    ll root = -1;
    rep1(i,n){
        if(sz(adj[i]) >= 2){
            root = i;
            break;
        }
    }

    assert(root != -1);

    dfs1(root,-1);
    dfs2(root,-1);

    // rep1(i,n){
    //     debug(i);
    //     debug(deepest[i]);
    //     debug(deepest_outside[i]);
    //     debug(deepest_par[i]);
    //     cout << endl;
    // }

    dfs3(root,-1);

    cout << mx_val << " " << mx_cnt << endl;
}

int main()
{
    fastio;

    int t = 1;
    // cin >> t;

    rep1(i, t) {
        solve(i);
    }

    return 0;
}

• Subtask 1: 0 / 19
• Subtask 2: 0 / 33
• Subtask 3: 0 / 48