Submission #840823

#	Time	Username	Problem	Language	Result	Execution time	Memory
840823		MohamedAliSaidane	Closing Time (IOI23_closing)	C++17	9 / 100	190 ms	542540 KiB

closing

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

typedef  long long ll;

#define pb push_back
#define ff first
#define ss second
#define all(x) (x).begin(),(x).end()

const int nax = 205;
const ll INF = 1e18 + 2;

int n, x, y;
ll k;
vector<pair<int,ll>> A[nax];
vector<int> adj[nax];
ll dx[nax], dy[nax];
ll dp[nax][2 * nax][4], memo[nax][2 * nax][4][nax];
int tx[nax], ty[nax];

void dfsx(int u, int par)
{
    for(auto e: A[u])
    {
        if(e.ff == par)
            continue;
        dx[e.ff] = dx[u] + e.ss;
        tx[e.ff] = u;
        dfsx(e.ff, u);
    }
}
void dfsy(int u, int par)
{
    for(auto e: A[u])
    {
        if(e.ff == par)
            continue;
        dy[e.ff] = dy[u] + e.ss;
        ty[e.ff] = u;
        dfsy(e.ff, u);
    }
}
ll f(int u, int ans, int typ);

ll g(int u, int rem, int typ, int idx)
{
    if(rem < 0)
        return INF;
    if(idx == (int)(adj[u].size()))
        return rem > 0? INF: 0ll;
    if(memo[u][rem][typ][idx] != -1)
        return memo[u][rem][typ][idx];
    if(rem == 0)
        return memo[u][rem][typ][idx] = 0ll;
    ll rep = INF;
    for(int j = 0; j <= rem; j++)
    {
        ll nxt = g(u, rem - j, typ, idx + 1);
        if(typ == 0)
        {
            if(ty[u] == adj[u][idx] && ty[adj[u][idx]] != u)
                rep = min(rep, g(u, rem-j, typ, idx + 1) + f(adj[u][idx], j - 1, 2));
            rep = min(rep, nxt + f(adj[u][idx], j, 0));
        }
        else if(typ == 1)
        {
            rep = min(rep, nxt + f(adj[u][idx], j - 1, 1));
            rep = min(rep, nxt + f(adj[u][idx], j, 0));
            if(ty[u] == adj[u][idx] && ty[adj[u][idx]] != u)
            {
                rep = min(rep, nxt + f(adj[u][idx], j - 1, 2));
                rep = min(rep, nxt + f(adj[u][idx], j - 2, 3));
            }
        }
        else if(typ == 2)
        {
            rep = min(rep, nxt + f(adj[u][idx], j - 1, 2));
            if(ty[u] != adj[u][idx])
                rep = min(rep, nxt + f(adj[u][idx], j, 0));
        }
        else 
        {
            rep = min(rep, nxt + f(adj[u][idx], j - 2, 3));
            rep = min(rep, nxt + f(adj[u][idx], j - 1, 2));
            if(ty[u] != adj[u][idx])
            {
                rep = min(rep, nxt + f(adj[u][idx], j - 1, 1));
                rep = min(rep, nxt + f(adj[u][idx], j, 0));
            }
        }
    }
    return memo[u][rem][typ][idx] = rep;
}
ll f(int u, int ans, int typ)
{
    if(ans < 0)
        return INF;
    if(dp[u][ans][typ] != -1)
        return dp[u][ans][typ];
    ll deplt = typ == 0? 0: typ == 1? dx[u]: typ == 2? dy[u]: max(dx[u], dy[u]);
    if(adj[u].empty())
        return dp[u][ans][typ] = ans > 0? INF: deplt;
    
    return dp[u][ans][typ] = g(u, ans, typ, 0)  + deplt;
}
int max_score(int N, int X, int Y, long long K,
              std::vector<int> U, std::vector<int> V, std::vector<int> W)
{
    n = N, x = X, y = Y, k = K;
    for(int i = 0; i < N; i ++)
    {
        A[i].clear();
        adj[i].clear();
    }
    memset(dp, -1, sizeof(dp));
    memset(memo, -1, sizeof(memo));
    for(int i = 0; i < n - 1; i++)
    {
        A[U[i]].pb({V[i], W[i]});
        A[V[i]].pb({U[i], W[i]});
    }
    tx[x] = x, ty[y] = y;
    dx[x] = dy[y] = 0ll;
    dfsx(x, x);
    dfsy(y, y);
    for(int i = 0; i < n; i++)
    {
        vector<int> v;
        for(auto e: A[i])
            if(e.ff != tx[i])
                adj[i].pb(e.ff);
    }
    for(int ans = 2; ans <= 2 * n; ans++)
    {
        ll cost = INF;
        cost = min(cost, f(x, ans, 0));
        cost = min(cost, f(x, ans - 1, 1));
        cost = min(cost, f(x, ans - 1, 2));
        cost = min(cost, f(x, ans - 2, 3));
        if(cost > k)
            return ans - 1;
    }
    
    return 2 * n;
}

• Subtask 0: 0 / 0
• Subtask 1: 0 / 8
• Subtask 2: 0 / 9
• Subtask 3: 0 / 12
• Subtask 4: 0 / 14
• Subtask 5: 9 / 9
• Subtask 6: 0 / 11
• Subtask 7: 0 / 10
• Subtask 8: 0 / 10
• Subtask 9: 0 / 17