google code jam 2014 RC_D

#include <vector>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <iostream>
#include <algorithm>
using namespace std;

#define N 4011
#define E (3*N)
#define INF 0x7fffffff

int next_node

;
int best_drawoff_score[E][E];
int next_node_score[E][3];
int score[E];
int edge_id

;
int dp[E][E];

vector<int> adj
;
int c
;
int t, n, id;

void init(){
for (int i = 0; i<=3 * n; ++i){
for (int j = 0; j<=3 * n; ++j){
dp[i][j] = -INF;
best_drawoff_score[i][j] = -INF;
}
}
memset(next_node_score, -1, sizeof(next_node_score));
}

int scoreMax(int ps, int s){
if (s < 0) return 0;
return score[edge_id[ps][s]];
}

int precal(int start, int next, int current, int pre){
next_node[start][current] = next;
int res = 0;
vector<pair<int, int> > candi;
for (vector<int>::iterator it = adj[current].begin();
it != adj[current].end(); ++it){
if (*it == pre) continue;
int tmp = precal(start, next, *it, current);
res = max(res, tmp);
candi.push_back(make_pair(-tmp, *it));
}
sort(candi.begin(), candi.end());
for (int i = 0; i<3 && i<candi.size(); ++i){
next_node_score[edge_id[pre][current]][i] = candi[i].second;
}
return score[edge_id[pre][current]] = res + c[current];
}

int nextNode(int ps, int s, int v1, int v2 = -1){
int e = edge_id[ps][s];
int res = 0;
if (v1 == next_node_score[e][res] || v2 == next_node_score[e][res]) ++res;
if (v1 == next_node_score[e][res] || v2 == next_node_score[e][res]) ++res;
return next_node_score[e][res];
}

int calBestDrawoff(int ps, int s, int pt, int t){
int e1 = edge_id[ps][s];
int e2 = edge_id[pt][t];

if (best_drawoff_score[e1][e2] != -INF){
return best_drawoff_score[e1][e2];
}

if (t == s){
int n1 = nextNode(ps, s, pt);
int n2 = nextNode(pt, t, ps, n1);
return best_drawoff_score[e1][e2] = scoreMax(t,n2);
}
int n1 = nextNode(pt, t, next_node[t][s]);
best_drawoff_score[e1][e2] = scoreMax(t,n1)+c[t];

best_drawoff_score[e1][e2] = max(best_drawoff_score[e1][e2], c[t] + calBestDrawoff(ps, s, t, next_node[t][s]));

return best_drawoff_score[e1][e2];
}

int gao(int ps, int s, int pt, int t){
int e1 = edge_id[ps][s];
int e2 = edge_id[pt][t];

if (dp[e1][e2] != -INF) return dp[e1][e2];

if (s == t){
int n1 = nextNode(ps, s, pt);
int n2 = nextNode(ps, s, pt, n1);
return dp[e1][e2] = scoreMax(s,n1) - scoreMax(s,n2) + c[s];
}

int tmp = next_node[s][t];
dp[e1][e2] = -gao(pt, t, s, tmp) + c[s];

int n1 = nextNode(ps, s, tmp);
dp[e1][e2] = max(dp[e1][e2], c[s] + scoreMax(s,n1) - calBestDrawoff(ps,s,pt,t));

return dp[e1][e2];
}

ofstream out("case.txt");

int main(){
freopen("D-large-practice.in","r",stdin);
freopen("my_D.out","w",stdout);
cin >> t;
for (int cas = 1; cas <= t; ++cas){
cin >> n;
if(cas<=11&&cas>=7) out<<n<<endl;
for (int i = 0; i<n; ++i){
cin >> c[i];
if(cas<=11&&cas>=7) out<<c[i]<<endl;
adj[i].clear();
}
id = 0;
for (int i = 0; i<n; ++i){
edge_id
[i] = id++;
}
for (int i = 0, j; i<n - 1; ++i){
cin >> j;
if(cas<=11&&cas>=7) out<<j<<endl;
--j;
adj[i].push_back(j);
adj[j].push_back(i);
edge_id[i][j] = id++;
edge_id[j][i] = id++;
}

init();

for (int i = 0; i<n; ++i){
precal(n, i, i, n);
for (vector<int>::iterator it = adj[i].begin();
it != adj[i].end(); ++it){
precal(i, *it, *it, i);
}
}

int ans = -INF;
for (int i = 0; i<n; ++i){
int tmp = INF;
for (int j = 0; j<n; ++j){
int tmp2 = gao(n, i, n, j);
tmp = min(tmp, tmp2);
}
ans = max(ans, tmp);
}

printf("Case #%d: %d\n", cas, ans);
}
}