Submission #961018

#	Time	Username	Problem	Language	Result	Execution time	Memory
961018		tudor_costin	Cat Exercise (JOI23_ho_t4)	C++11	100 / 100	421 ms	64448 KiB

Main

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int Nmax=3e5;
int a[Nmax];
int nodes[Nmax],pos[Nmax],p[Nmax];
pair<int,int> maxi[Nmax];
int dp[Nmax];
int nodedepth[Nmax];
int aint[4*Nmax];
vector<int> euler;
vector<int> depths;
vector<int> v[Nmax];
int n;
int sol=0;
int sef(int x)
{
    if(p[x]==x) return x;
    p[x]=sef(p[x]);
    return p[x];
}
bool cmp(int x,int y)
{
    return a[x]<a[y];
}
void build(int nod,int l,int r)
{
    if(l==r)
    {
        aint[nod]=euler[l];
        return;
    }
    int mid=(l+r)/2;
    build(2*nod,l,mid);
    build(2*nod+1,mid+1,r);
    if (nodedepth[aint[2*nod]]<nodedepth[aint[2*nod+1]]) aint[nod]=aint[2*nod];
    else aint[nod]=aint[2*nod+1];
    return;
}
int query(int nod,int l,int r,int st,int dr)
{
    if(st<=l && r<=dr) return aint[nod];
    int mid=(l+r)/2;
    if(dr<=mid) return query(2*nod,l,mid,st,dr);
    if(mid<st) return query(2*nod+1,mid+1,r,st,dr);
    int op1=query(2*nod,l,mid,st,mid),op2=query(2*nod+1,mid+1,r,mid+1,dr);
    if(nodedepth[op1]<nodedepth[op2]) return op1;
    return op2;
}
void dfs(int nod,int prev,int depth)
{
    euler.push_back(nod);
    depths.push_back(depth);
    nodedepth[nod]=depth;
    pos[nod]=euler.size()-1;
    for(auto u:v[nod])
    {
        if(u!=prev)
        {
            dfs(u,nod,depth+1);
            euler.push_back(nod);
            depths.push_back(depth);
        }
    }
}
int lca(int u,int v)
{
    if(pos[u]>pos[v]) swap(u,v);
    return query(1,0,euler.size()-1,pos[u],pos[v]);
}
void calclca()
{
    dfs(1,0,0);
    build(1,0,euler.size()-1);
}
int dist(int u,int v)
{
    int nod=lca(u,v);
    return nodedepth[u]+nodedepth[v]-2*nodedepth[nod];
}
void unite(int x,int y)
{
    int sefx=sef(x);
    int sefy=sef(y);
    p[sefy]=sefx;
    maxi[sefx]=max(maxi[sefx],maxi[sefy]);
    return;
}
void activate(int nod)
{
    p[nod]=nod;
    maxi[nod]={a[nod],nod};
    for(auto u:v[nod])
    {
        if(p[u]!=0)
        {
            int nxt=maxi[sef(u)].second;
            dp[nod]=max(dp[nod],dist(nod,nxt)+dp[nxt]);
            unite(nod,u);
        }
    }
}
signed main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        nodes[i]=i;
    }
    sort(nodes+1,nodes+n+1,cmp);
    for(int i=1;i<n;i++)
    {
        int x,y;
        cin>>x>>y;
        v[x].push_back(y);
        v[y].push_back(x);
    }
    calclca();
    for(int i=1;i<=n;i++)
    {
        activate(nodes[i]);
    }
    cout<<dp[nodes[n]]<<'\n';
    return 0;
}

• Subtask 1: 7 / 7
• Subtask 2: 7 / 7
• Subtask 3: 7 / 7
• Subtask 4: 10 / 10
• Subtask 5: 20 / 20
• Subtask 6: 23 / 23
• Subtask 7: 26 / 26