oj.uz

Submission #273849

# Submission time Handle Problem Language Result Execution time Memory
273849 2020-08-19T07:35:40 Z 최은수(#5105) Mountains and Valleys (CCO20_day1problem3) C++17
2 / 25
 42 ms 46336 KB 
#include<iostream>
#include<vector>
#include<algorithm>
#define ep emplace
#define eb emplace_back
#define fi first
#define se second
#define all(x) (x).begin(),(x).end()
using namespace std;
typedef long long ll;
typedef pair<int,int>pi;
typedef pair<ll,ll>pl;
const int inf=1e9+7;
const ll INF=1e18;
struct max4
{
    int a,b,c,d;
    max4(){a=b=c=d=0;}
    inline void upd(int x)
    {
        if(x>a)
            d=c,c=b,b=a,a=x;
        else if(x>b)
            d=c,c=b,b=x;
        else if(x>c)
            d=c,c=x;
        else if(x>d)
            d=x;
        return;
    }
    inline int get()
    {
        return a;
    }
    inline int get(int x)
    {
        return x==a?b:a;
    }
    inline int get(int x,int y)
    {
        if(x<y)
            swap(x,y);
        return x==a?(y==b?c:b):(y==a?b:a);
    }
    inline int get(int x,int y,int z)
    {
        if(x<y)
            swap(x,y);
        if(x<z)
            swap(x,z);
        if(y<z)
            swap(y,z);
        return x==a?(y==b?(z==c?d:c):(z==b?c:b)):(y==a?(z==b?c:b):(z==a?b:a));
    }
};
vector<int>adj[500010];
int depth[500010];
void ddfs(int x,int p)
{
    depth[x]=depth[p]+1;
    for(int&t:adj[x])
        if(t!=p)
            ddfs(t,x);
    return;
}
int dep[500010];
int spa[500010][19];
inline int kpa(int x,int k)
{
    for(;k>0;k^=k&-k)
        x=spa[x][__builtin_ctz(k)];
    return x;
}
inline int lca(int x,int y)
{
    if(dep[x]>dep[y])
        x=kpa(x,dep[x]-dep[y]);
    else
        y=kpa(y,dep[y]-dep[x]);
    if(x==y)
        return x;
    for(int i=19;i-->0;)
        if(spa[x][i]!=spa[y][i])
            x=spa[x][i],y=spa[y][i];
    return spa[x][0];
}
max4 dp1[500010],dp2[500010];
max4 dp3[500010],dp4[500010];
void sdfs(int x,int p)
{
    spa[x][0]=p;
    for(int i=0;i<18;i++)
        spa[x][i+1]=spa[spa[x][i]][i];
    dep[x]=dep[p]+1;
    for(int&t:adj[x])
        if(t!=p)
            sdfs(t,x),dp1[x].upd(dp1[t].get()+1),
            dp2[x].upd(max(dp2[t].get(),dp1[t].get()+dp1[t].get(dp1[t].get())));
    dp3[x]=dp1[x];
    dp4[x]=dp2[x];
    return;
}
int child[500010][19];
int spd[500010][19];
int dpth(int x,int k)
{
    int ret=max({dp2[x].get(),dp1[x].get()+dp1[x].get(dp1[x].get())});
    bool chk=0;
    int y=x;
    while(k>0)
    {
        int i=__builtin_ctz(k);
        k^=k&-k;
        if(!chk)
        {
            chk=1;
            ret=max(ret,spd[x][i]);
            y=child[x][i];
            x=spa[x][i];
            continue;
        }
        {
            int fc1=dp1[y].get()+1;
            int fc2=max(dp2[y].get(),dp1[y].get()+dp1[y].get(dp1[y].get()));
            ret=max({ret,spd[x][i],dp2[x].get(fc2),
            dp1[x].get(fc1)+dp1[x].get(dp1[x].get(fc1),fc1)});
        }
        y=child[x][i];
        x=spa[x][i];
    }
    return ret;
}
int cm[500010][19];
pi cut[500010][19];
pair<pi,int>pth(int x,int k)
{
    pair<pi,int>ret;
    ret.fi.fi=ret.fi.se=dp1[x].get();
    int len=0;
    int y=x;
    while(k>0)
    {
        int i=__builtin_ctz(k);
        k^=k&-k;
        if(len==0)
        {
            len=1<<i;
            ret.se=max(cm[x][i],ret.fi.fi+cut[x][i].se);
            ret.fi.fi=max(ret.fi.fi,cut[x][i].fi);
            ret.fi.se=max(ret.fi.se+len,cut[x][i].se);
            y=child[x][i];
            x=spa[x][i];
            continue;
        }
        {
            pi c1=ret.fi;
            pi c2=cut[x][i];
            int cur=dp1[x].get(dp1[y].get()+1);
            ret.se=max({ret.se+(1<<i),cm[x][i]+len,
            c1.fi+c2.se,c1.fi+cur+(1<<i),c2.se+cur+len});
            ret.fi.fi=max({c1.fi,c2.fi+len,cur+len});
            ret.fi.se=max({c2.se,c1.se+(1<<i),cur+(1<<i)});
        }
        len+=1<<i;
        y=child[x][i];
        x=spa[x][i];
    }
    return ret;
}
void dfs2(int x,int p)
{
    spd[x][0]=cm[x][0]=cut[x][0].fi=cut[x][0].se=0;
    for(int i=0,y=x;i<18;y=spa[y][i++])
    {
        if(spa[x][i]==0)
            break;
        child[x][i]=y;
        {
            int fc1=dp1[y].get()+1;
            int fc2=max(dp2[y].get(),dp1[y].get()+dp1[y].get(dp1[y].get()));
            spd[x][i+1]=max({spd[x][i],spd[spa[x][i]][i],dp2[spa[x][i]].get(fc2),
            dp1[spa[x][i]].get(fc1)+dp1[spa[x][i]].get(dp1[spa[x][i]].get(fc1),fc1)});
        }
        {
            pi c1=cut[x][i];
            pi c2=cut[spa[x][i]][i];
            int cur=dp1[spa[x][i]].get(dp1[y].get()+1);
            cm[x][i+1]=max({cm[x][i]+(1<<i),cm[spa[x][i]][i]+(1<<i),
            c1.fi+c2.se,c1.fi+cur+(1<<i),c2.se+cur+(1<<i)});
            cut[x][i+1].fi=max({c1.fi,c2.fi+(1<<i),cur+(1<<i)});
            cut[x][i+1].se=max({c2.se,c1.se+(1<<i),cur+(1<<i)});
        }
    }
    for(int&t:adj[x])
    {
        if(t!=p)
        {
            int mx=dp3[x].get(dp3[t].get()+1);
            dp3[t].upd(mx);
            int mx2=dp3[x].get(mx,dp3[t].get()+1);
            int td2=max(dp4[t].get(),dp3[t].get()+dp3[t].get(dp3[t].get()));
            dp4[t].upd(max(dp4[x].get(td2),mx+mx2));
            dfs2(t,x);
        }
    }
    return;
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    int n,m;
    cin>>n>>m;
    vector<pair<pi,int> >ev;
    for(int i=0;i<m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        u++,v++;
        if(w==1)
            adj[u].eb(v),adj[v].eb(u);
        else if(w*2<n)
            ev.eb(pi(u,v),w);
    }
    sdfs(1,0);
    int ans=inf;
    {
        int d1=max_element(dep+1,dep+n+1)-dep;
        ddfs(d1,0);
        ans=2*n-1-*max_element(depth+1,depth+n+1);
    }
    dfs2(1,0);
    for(auto&t:ev)
    {
        int u=t.fi.fi;
        int v=t.fi.se;
        int w=t.se;
        int l=lca(u,v);
        int len=dep[u]+dep[v]-dep[l]*2;
        int dmax=0,cmax=0;
        if(v==l)
            swap(u,v);
        if(u==l)
        {
            auto q1=dpth(v,dep[v]-dep[l]);
            auto q2=pth(v,dep[v]-dep[l]);
            int y=kpa(v,dep[v]-dep[l]-1);
            {
                int fc1=dp1[y].get()+1;
                int fc2=max(dp2[y].get(),dp1[y].get()+dp1[y].get(dp1[y].get()));
                dmax=max({q1,dp4[l].get(fc2),
                dp3[l].get(fc1)+dp3[l].get(dp3[l].get(fc1),fc1)});
            }
            {
                int cur=dp3[l].get(dp1[y].get()+1);
                cmax=max(q2.se,q2.fi.fi+cur);
            }
        }
        else
        {
            int qu1=dpth(u,dep[u]-dep[l]);
            int qv1=dpth(v,dep[v]-dep[l]);
            auto qu2=pth(u,dep[u]-dep[l]);
            auto qv2=pth(v,dep[v]-dep[l]);
            int yu=kpa(u,dep[u]-dep[l]-1);
            int yv=kpa(v,dep[v]-dep[l]-1);
            {
                int fcu1=dp1[yu].get()+1;
                int fcu2=max(dp2[yu].get(),dp1[yu].get()+dp1[yu].get(dp1[yu].get()));
                int fcv1=dp1[yv].get()+1;
                int fcv2=max(dp2[yv].get(),dp1[yv].get()+dp1[yv].get(dp1[yv].get()));
                dmax=max({qu1,qv1,dp4[l].get(fcu2,fcv2),
                dp3[l].get(fcu1,fcv1)+dp3[l].get(dp3[l].get(fcu1,fcv1),fcu1,fcv1)});
            }
            {
                int cur=dp3[l].get(dp1[yu].get()+1,dp1[yv].get()+1);
                cmax=max({qu2.se,qv2.se,qu2.fi.fi+qv2.fi.fi,
                qu2.fi.fi+cur+(dep[v]-dep[l]),qv2.fi.fi+cur+(dep[u]-dep[l])});
            }
        }
        ans=min(ans,n*2-1-dmax-len+w);
        ans=min(ans,n*2-4-cmax+w);
    }
    cout<<ans<<endl;
    return 0;
}

Subtask #1
0.0 / 1.0

# Verdict Execution time Memory Grader output
1 Correct 28 ms 43392 KB Output is correct
2 Correct 30 ms 43384 KB Output is correct
3 Correct 31 ms 43392 KB Output is correct
4 Correct 28 ms 43392 KB Output is correct
5 Correct 28 ms 43444 KB Output is correct
6 Correct 28 ms 43488 KB Output is correct
7 Correct 29 ms 43392 KB Output is correct
8 Correct 29 ms 43384 KB Output is correct
9 Correct 29 ms 43384 KB Output is correct
10 Correct 29 ms 43392 KB Output is correct
11 Correct 29 ms 43392 KB Output is correct
12 Correct 29 ms 43384 KB Output is correct
13 Correct 29 ms 43392 KB Output is correct
14 Incorrect 32 ms 43512 KB Output isn't correct
15 Halted 0 ms 0 KB -

Subtask #2
0.0 / 2.0

# Verdict Execution time Memory Grader output
1 Correct 28 ms 43392 KB Output is correct
2 Correct 30 ms 43384 KB Output is correct
3 Correct 31 ms 43392 KB Output is correct
4 Correct 28 ms 43392 KB Output is correct
5 Correct 28 ms 43444 KB Output is correct
6 Correct 28 ms 43488 KB Output is correct
7 Correct 29 ms 43392 KB Output is correct
8 Correct 29 ms 43384 KB Output is correct
9 Correct 29 ms 43384 KB Output is correct
10 Correct 29 ms 43392 KB Output is correct
11 Correct 29 ms 43392 KB Output is correct
12 Correct 29 ms 43384 KB Output is correct
13 Correct 29 ms 43392 KB Output is correct
14 Incorrect 32 ms 43512 KB Output isn't correct
15 Halted 0 ms 0 KB -

Subtask #3
2.0 / 2.0

# Verdict Execution time Memory Grader output
1 Correct 36 ms 46328 KB Output is correct
2 Correct 37 ms 46336 KB Output is correct
3 Correct 36 ms 46200 KB Output is correct
4 Correct 40 ms 46072 KB Output is correct
5 Correct 36 ms 46080 KB Output is correct
6 Correct 34 ms 45952 KB Output is correct
7 Correct 37 ms 46328 KB Output is correct
8 Correct 36 ms 46200 KB Output is correct
9 Correct 36 ms 46336 KB Output is correct
10 Correct 36 ms 46072 KB Output is correct
11 Correct 42 ms 46200 KB Output is correct
12 Correct 40 ms 45944 KB Output is correct
13 Correct 36 ms 46208 KB Output is correct
14 Correct 41 ms 46080 KB Output is correct

Subtask #4
0.0 / 6.0

# Verdict Execution time Memory Grader output
1 Correct 28 ms 43392 KB Output is correct
2 Correct 30 ms 43384 KB Output is correct
3 Correct 31 ms 43392 KB Output is correct
4 Correct 28 ms 43392 KB Output is correct
5 Correct 28 ms 43444 KB Output is correct
6 Correct 28 ms 43488 KB Output is correct
7 Correct 29 ms 43392 KB Output is correct
8 Correct 29 ms 43384 KB Output is correct
9 Correct 29 ms 43384 KB Output is correct
10 Correct 29 ms 43392 KB Output is correct
11 Correct 29 ms 43392 KB Output is correct
12 Correct 29 ms 43384 KB Output is correct
13 Correct 29 ms 43392 KB Output is correct
14 Incorrect 32 ms 43512 KB Output isn't correct
15 Halted 0 ms 0 KB -

Subtask #5
0.0 / 2.0

# Verdict Execution time Memory Grader output
1 Correct 28 ms 43392 KB Output is correct
2 Correct 30 ms 43384 KB Output is correct
3 Correct 31 ms 43392 KB Output is correct
4 Correct 28 ms 43392 KB Output is correct
5 Correct 28 ms 43444 KB Output is correct
6 Correct 28 ms 43488 KB Output is correct
7 Correct 29 ms 43392 KB Output is correct
8 Correct 29 ms 43384 KB Output is correct
9 Correct 29 ms 43384 KB Output is correct
10 Correct 29 ms 43392 KB Output is correct
11 Correct 29 ms 43392 KB Output is correct
12 Correct 29 ms 43384 KB Output is correct
13 Correct 29 ms 43392 KB Output is correct
14 Incorrect 32 ms 43512 KB Output isn't correct
15 Halted 0 ms 0 KB -

Subtask #6
0.0 / 3.0

# Verdict Execution time Memory Grader output
1 Correct 28 ms 43392 KB Output is correct
2 Correct 30 ms 43384 KB Output is correct
3 Correct 31 ms 43392 KB Output is correct
4 Correct 28 ms 43392 KB Output is correct
5 Correct 28 ms 43444 KB Output is correct
6 Correct 28 ms 43488 KB Output is correct
7 Correct 29 ms 43392 KB Output is correct
8 Correct 29 ms 43384 KB Output is correct
9 Correct 29 ms 43384 KB Output is correct
10 Correct 29 ms 43392 KB Output is correct
11 Correct 29 ms 43392 KB Output is correct
12 Correct 29 ms 43384 KB Output is correct
13 Correct 29 ms 43392 KB Output is correct
14 Incorrect 32 ms 43512 KB Output isn't correct
15 Halted 0 ms 0 KB -

Subtask #7
0.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 28 ms 43392 KB Output is correct
2 Correct 30 ms 43384 KB Output is correct
3 Correct 31 ms 43392 KB Output is correct
4 Correct 28 ms 43392 KB Output is correct
5 Correct 28 ms 43444 KB Output is correct
6 Correct 28 ms 43488 KB Output is correct
7 Correct 29 ms 43392 KB Output is correct
8 Correct 29 ms 43384 KB Output is correct
9 Correct 29 ms 43384 KB Output is correct
10 Correct 29 ms 43392 KB Output is correct
11 Correct 29 ms 43392 KB Output is correct
12 Correct 29 ms 43384 KB Output is correct
13 Correct 29 ms 43392 KB Output is correct
14 Incorrect 32 ms 43512 KB Output isn't correct
15 Halted 0 ms 0 KB -

Subtask #8
0.0 / 4.0

# Verdict Execution time Memory Grader output
1 Correct 28 ms 43392 KB Output is correct
2 Correct 30 ms 43384 KB Output is correct
3 Correct 31 ms 43392 KB Output is correct
4 Correct 28 ms 43392 KB Output is correct
5 Correct 28 ms 43444 KB Output is correct
6 Correct 28 ms 43488 KB Output is correct
7 Correct 29 ms 43392 KB Output is correct
8 Correct 29 ms 43384 KB Output is correct
9 Correct 29 ms 43384 KB Output is correct
10 Correct 29 ms 43392 KB Output is correct
11 Correct 29 ms 43392 KB Output is correct
12 Correct 29 ms 43384 KB Output is correct
13 Correct 29 ms 43392 KB Output is correct
14 Incorrect 32 ms 43512 KB Output isn't correct
15 Halted 0 ms 0 KB -