Submission #36289

#	Time	Username	Problem	Language	Result	Execution time	Memory
36289		funcsr	경주 (Race) (IOI11_race)	C++14	43 / 100	833 ms	190720 KiB

race

#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <cassert>
#include "race.h"
using namespace std;
#define INF 1145141919
#define rep(i, n) for (int i=0; i<(n); i++)
#define _1 first
#define _2 second
#define all(x) x.begin(), x.end()
#define pb push_back
typedef pair<int, int> P;
inline void chmin(int &x, int v) { if (x > v) x = v; }

int N, K;
int ans;
vector<P> G[200000];
void dfs(int x, int p, int r, int d) {
  if (d == K) ans = min(ans, r);
  for (P pp : G[x]) {
    int t = pp._1, nd = min(d+pp._2, INF);
    if (t == p) continue;
    dfs(t, x, r+1, nd);
  }
}

//int dp[200000][101][2];
//int src[200000][101];
const long long A = 200001, B = 40000400001LL; // A=N+1, B=(N+1)^2
long long data[200000][101];
inline long long encode(int dp0, int dp1, int src) { return dp1 + A*dp0 + B*src; }
inline void update(int x, int k, int v, int s) {
  long long d = data[x][k];
  int dp1 = d % A; d /= A;
  if (v >= dp1) return;
  int dp0 = d % A; d /= A;
  int src = d;

  if (v < dp0) {
    dp1 = dp0;
    dp0 = v;
    src = s;
  }
  else dp1 = v;
  data[x][k] = encode(dp0, dp1, src);
}
inline int get(int x, int k, int s) {
  long long d = data[x][k];
  int dp1 = d % A; d /= A;
  int dp0 = d % A; d /= A;
  int src = d;
  if (src == s) return dp1;
  return dp0;
}

void dfs2(int x, int p) {
  update(x, 0, 0, N);
  for (P pp : G[x]) {
    int t = pp._1, l = pp._2;
    if (t == p) continue;
    dfs2(t, x);
    for (int k=0; k<=K-l; k++) update(x, k+l, min(get(t, k, -1)+1, N), t);
  }
}

void dfs3(int x, int p, int pd) {
  if (p != -1) {
    for (int k=0; k<=K-pd; k++) update(x, k+pd, min(get(p, k, x)+1, N), p);
  }
  for (P pp : G[x]) {
    int t = pp._1, l = pp._2;
    if (t == p) continue;
    dfs3(t, x, l);
  }
  ans = min(ans, get(x, K, -1));
}

int best_path(int n, int k, int H[][2], int L[]) {
  N = n, K = k;
  rep(i, N) G[i].clear();
  rep(i, N-1) {
    G[H[i][0]].pb(P(H[i][1], L[i]));
    G[H[i][1]].pb(P(H[i][0], L[i]));
  }
  ans = INF;
  if (K <= 100) {
    // subtask 3
    rep(i, N) rep(j, K+1) data[i][j] = encode(N, N, N);
    dfs2(0, -1);
    dfs3(0, -1, -1);
    //rep(i, N) ans = min(ans, (int)dp[i][K][0]);
    if (ans >= N) ans = INF;
  }
  else if (N <= 1000) {
    // subtask 1&2
    rep(i, N) dfs(i, -1, 0, 0);
  }
  else abort();

  if (ans == INF) ans = -1;
  return ans;
}

• Subtask 1: 9 / 9
• Subtask 2: 12 / 12
• Subtask 3: 22 / 22
• Subtask 4: 0 / 57