text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
const int N = 180;
const int INF = int(1e9);
int n, m, d[N], dp[N][N], opt[N], dist[N][N], sum[N][N];
int first_edge[N], next_edge[N << 1], to[N << 1], edge_count;
int opt_record[N], sum_opt[N];
bool ancestor[N][N];
void add_edge(int s, int t) {
to[edge_count] = t;
next_edge[edge_count] = first_edge[s];
first_edge[s] = edge_count++;
}
void dfs(int x, int parent, int* dist, int d) {
dist[x] = d;
for (int itr = first_edge[x]; itr != -1; itr = next_edge[itr]) {
int y = to[itr];
if (y != parent) {
dfs(y, x, dist, d + 1);
}
}
}
void solve(int x, int parent) {
for (int itr = first_edge[x]; itr != -1; itr = next_edge[itr]) {
int y = to[itr];
if (y != parent) {
solve(y, x);
for (int i = 0; i < n; i++) {
if (i == y || ancestor[y][i]) {
ancestor[x][i] = true;
}
}
}
}
sum_opt[x] = 0;
for (int itr = first_edge[x]; itr != -1; itr = next_edge[itr]) {
int y = to[itr];
if (y != parent) {
sum_opt[x] += opt[y];
for (int i = 0; i < n; i++) {
if (ancestor[x][i]) {
dp[x][i] += ancestor[y][i] || y == i ? dp[y][i]
: std::min(opt[y], dp[y][i] - m);
} else if (i == x) {
dp[x][i] += std::min(opt[y], dp[y][i] - m);
}
sum[x][i] += std::min(opt[y], dp[y][i] - m);
}
}
}
for (int i = 0; i < n; i++) {
if (i != x && !ancestor[x][i]) {
dp[x][i] = std::min(sum_opt[x], sum[x][i]) + m;
}
}
dp[x][x] += m;
opt[x] = INF;
for (int i = 0; i < n; i++) {
dp[x][i] += d[dist[x][i]];
if (dp[x][i] < opt[x]) {
opt[x] = dp[x][i];
opt_record[x] = i;
}
}
}
int belong[N];
void find(int x, int t, int parent) {
belong[x] = t;
for (int itr = first_edge[x]; itr != -1; itr = next_edge[itr]) {
int y = to[itr];
if (y != parent) {
if (ancestor[x][t]) {
find(y,
(ancestor[y][t] || y == t ? t
: opt[y] < dp[y][t] - m ? opt_record[y]
: t),
x);
} else if (t == x) {
find(y, (dp[y][t] - m < opt[y] ? t : opt_record[y]), x);
} else {
find(y,
(sum_opt[x] < sum[x][t] ? opt_record[y]
: opt[y] < dp[y][t] - m ? opt_record[y]
: t),
x);
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
scanf("%d", d + i);
}
std::fill(first_edge, first_edge + n, -1);
edge_count = 0;
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
add_edge(x, y);
add_edge(y, x);
}
for (int i = 0; i < n; i++) {
dfs(i, -1, dist[i], 0);
}
solve(0, -1);
printf("%d\n", opt[0]);
find(0, opt_record[0], -1);
for (int i = 0; i < n; i++) {
printf("%d%c", belong[i] + 1, i < n - 1 ? ' ' : '\n');
}
}
|
#include <bits/stdc++.h>
using namespace std;
int x, y, n, k, cnt;
int val[1010], nxt[1010], id[1010];
int f[1010][1010];
int f1[1010];
int ans[1010];
int dis[1010][1010];
int a[1010];
inline void Build(int x, int y) {
cnt++;
val[cnt] = y;
nxt[cnt] = id[x];
id[x] = cnt;
}
inline void dfs(int x, int fa) {
for (int i = 1; i <= n; ++i) f[i][x] = a[dis[i][x]] + k;
for (int i = id[x]; i; i = nxt[i]) {
int y = val[i];
if (y == fa) continue;
dfs(y, x);
for (int j = 1; j <= n; ++j)
f[j][x] = f[j][x] + min(f[j][y] - k, f[f1[y]][y]);
}
f1[x] = 1;
for (int i = 1; i <= n; ++i)
if (f[i][x] < f[f1[x]][x]) f1[x] = i;
}
inline void tong(int x, int fa, int v) {
for (int i = id[x]; i; i = nxt[i]) {
int y = val[i];
if (y == fa) continue;
if (f[f1[y]][y] > f[v][y] - k)
ans[y] = v;
else
ans[y] = f1[y];
tong(y, x, ans[y]);
}
}
int main() {
scanf("%d%d", &n, &k);
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i < n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) dis[i][i] = 0;
for (int i = 1; i < n; ++i) {
scanf("%d%d", &x, &y);
dis[x][y] = 1;
dis[y][x] = 1;
Build(x, y), Build(y, x);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= n; ++k)
if (dis[j][k] > dis[j][i] + dis[i][k])
dis[j][k] = dis[j][i] + dis[i][k];
dfs(1, 0);
printf("%d\n", f[f1[1]][1]);
ans[1] = f1[1];
tong(1, 0, ans[1]);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 200;
vector<int> E[MaxN];
int depth[MaxN];
int v[MaxN];
int n, k;
void build(int x, int dad) {
for (int i = 0; i < E[x].size(); ++i) {
int y = E[x][i];
if (y == dad) continue;
build(y, x);
depth[x] = max(depth[x], depth[y] + 1);
}
}
int dp[MaxN][2 * MaxN][2];
int kako[MaxN][2 * MaxN][2], rd[MaxN][2 * MaxN][2], rp[MaxN][2 * MaxN][2];
int f(int x, int dad, int d, int p) {
int ret = 1 << 30;
int how = -1;
if (dp[x][d][p] != -1) return dp[x][d][p];
if (p == 0) {
int t1 = v[d];
if (d > 0) {
for (int j = 0; j < E[x].size(); ++j) {
int y = E[x][j];
if (y == dad) continue;
t1 += f(y, x, d + 1, 0);
}
if (ret > t1) how = 0;
ret = min(ret, t1);
}
t1 = k;
for (int j = 0; j < E[x].size(); ++j) {
int y = E[x][j];
if (y == dad) continue;
t1 += f(y, x, 1, 0);
}
if (ret > t1) how = 1;
ret = min(ret, t1);
for (int i = 1; i <= depth[x]; ++i) {
int ans = v[i];
for (int j = 0; j < E[x].size(); ++j) {
int y = E[x][j];
if (y == dad) continue;
ans += f(y, x, i + 1, 0);
}
for (int j = 0; j < E[x].size(); ++j) {
int y = E[x][j];
if (y == dad) continue;
if (depth[y] + 1 >= i) {
int sum = 0;
sum = ans - f(y, x, i + 1, 0) + f(y, x, i - 1, 1);
if (ret > sum) {
how = 2;
rd[x][d][p] = i;
rp[x][d][p] = y;
}
ret = min(ret, sum);
}
}
}
}
if (p == 1) {
if (d == 0) {
int t2 = k;
for (int j = 0; j < E[x].size(); ++j) {
int y = E[x][j];
if (y == dad) continue;
t2 += f(y, x, 1, 0);
}
if (ret > t2) how = 3;
ret = min(ret, t2);
}
if (d > 0) {
for (int i = d; i <= d; ++i) {
int ans = v[i];
for (int j = 0; j < E[x].size(); ++j) {
int y = E[x][j];
if (y == dad) continue;
ans += f(y, x, i + 1, 0);
}
for (int j = 0; j < E[x].size(); ++j) {
int y = E[x][j];
if (y == dad) continue;
if (depth[y] + 1 >= i) {
int sum = 0;
sum = ans - f(y, x, i + 1, 0) + f(y, x, i - 1, 1);
if (ret > sum) {
rd[x][d][p] = i;
rp[x][d][p] = y;
how = 4;
}
ret = min(ret, sum);
}
}
}
}
}
kako[x][d][p] = how;
dp[x][d][p] = ret;
return ret;
}
int from[MaxN];
int rec(int x, int dad, int tko, int d, int p) {
int how = kako[x][d][p];
if (how == 0) {
from[x] = tko;
for (int j = 0; j < E[x].size(); ++j) {
int y = E[x][j];
if (y == dad) continue;
rec(y, x, tko, d + 1, 0);
}
}
if (how == 1) {
from[x] = x;
for (int j = 0; j < E[x].size(); ++j) {
int y = E[x][j];
if (y == dad) continue;
rec(y, x, x, 1, 0);
}
return x;
}
if (how == 2) {
int pr = rec(rp[x][d][p], x, 0, rd[x][d][p] - 1, 1);
for (int j = 0; j < E[x].size(); ++j) {
int y = E[x][j];
if (y == dad || y == rp[x][d][p]) continue;
rec(y, x, pr, rd[x][d][p] + 1, 0);
}
from[x] = pr;
return pr;
}
if (how == 3) {
from[x] = x;
for (int j = 0; j < E[x].size(); ++j) {
int y = E[x][j];
if (y == dad) continue;
rec(y, x, x, 1, 0);
}
return x;
}
if (how == 4) {
int pr = rec(rp[x][d][p], x, 0, rd[x][d][p] - 1, 1);
for (int j = 0; j < E[x].size(); ++j) {
int y = E[x][j];
if (y == dad || y == rp[x][d][p]) continue;
rec(y, x, pr, rd[x][d][p] + 1, 0);
}
from[x] = pr;
return pr;
}
}
int main(void) {
memset(dp, -1, sizeof dp);
scanf("%d%d", &n, &k);
for (int i = 1; i < n; ++i) scanf("%d", &v[i]);
for (int i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
--x;
--y;
E[x].push_back(y);
E[y].push_back(x);
}
build(0, -1);
printf("%d\n", f(0, -1, 0, 0));
rec(0, -1, 0, 0, 0);
for (int i = 0; i < n; ++i) printf("%d ", from[i] + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 180 + 10;
const int oo = 1000000000;
int opt[maxn][maxn * 2];
int c[maxn][maxn * 2], cc[maxn][maxn * 2];
int e[maxn][maxn];
int n, kk, d[maxn];
int father[maxn];
int res[maxn];
void dp(int u) {
for (int v = 1; v <= n; v++)
if (e[u][v] && v == father[u]) e[u][v] = 0;
for (int v = 1; v <= n; v++)
if (e[u][v]) {
father[v] = u;
dp(v);
}
for (int i = 1; i <= n; i++) {
int w = i - n, o = 0;
for (int v = 1; v <= n; v++)
if (e[u][v]) {
int o2 = opt[v][i - 1];
for (int j = n; j <= n * 2; j++) o2 = min(o2, opt[v][j]);
o += o2;
o = min(o, oo);
}
if (w == 0)
o += kk;
else
o += d[-w];
opt[u][i] = o;
}
int best[maxn];
for (int i = n + 1; i < n * 2; i++) {
for (int v = 1; v <= n; v++)
if (e[u][v]) {
best[v] = oo;
for (int j = i - 1; j <= n * 2; j++) best[v] = min(best[v], opt[v][j]);
best[v] = min(best[v], opt[v][n + n - i - 1]);
}
for (int v = 1; v <= n; v++)
if (e[u][v]) {
int o = opt[v][i - 1];
for (int w = 1; w <= n; w++)
if (w != v && e[u][w]) {
o += best[w];
o = min(o, oo);
}
o += d[i - n];
if (o < opt[u][i]) {
opt[u][i] = o;
cc[u][i] = v;
}
}
}
}
void dfs(int u, int w, int p) {
if (w == n) p = u;
if (w <= n) {
res[u] = p;
for (int v = 1; v <= n; v++)
if (e[u][v]) {
int o = w - 1;
for (int j = n; j <= n * 2; j++)
if (opt[v][j] < opt[v][o]) o = j;
dfs(v, o, p);
}
} else {
int o = cc[u][w];
dfs(o, w - 1, p);
res[u] = res[o];
for (int v = 1; v <= n; v++)
if (v != o && e[u][v]) {
int _o = n + n - w - 1;
for (int j = w - 1; j <= n * 2; j++)
if (opt[v][j] < opt[v][_o]) _o = j;
dfs(v, _o, res[u]);
}
}
}
int main() {
scanf("%d%d", &n, &kk);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
e[u][v] = e[v][u] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 0; j <= n * 2 + 1; j++) opt[i][j] = oo;
dp(1);
int best = n;
for (int i = n; i <= n * 2; i++)
if (opt[1][i] < opt[1][best]) best = i;
dfs(1, best, 0);
printf("%d\n", opt[1][best]);
for (int i = 1; i <= n; i++) printf("%d%c", res[i], i == n ? '\n' : ' ');
}
|
#include <bits/stdc++.h>
const int N = 200;
using namespace std;
struct edge {
int v, nxt;
} e[N * 2];
int n, k, a[N], head[N], cnt, dep[N], f[N][20];
int p[N], g[N][N], dp[N][N], ans[N];
void adde(int u, int v) {
e[++cnt].v = v;
e[cnt].nxt = head[u];
head[u] = cnt;
}
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
f[u][0] = fa;
for (int i = 1; i <= 15; ++i) f[u][i] = f[f[u][i - 1]][i - 1];
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
dfs(v, u);
}
}
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 15; i >= 0; --i)
if (dep[f[u][i]] >= dep[v]) u = f[u][i];
if (u == v) return u;
for (int i = 15; i >= 0; --i)
if (f[u][i] != f[v][i]) {
u = f[u][i];
v = f[v][i];
}
return f[u][0];
}
int dis(int u, int v) { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; }
void dfs2(int u, int fa) {
for (int i = 1; i <= n; ++i) dp[u][i] = a[dis(i, u)] + k;
p[u] = 1;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
dfs2(v, u);
for (int j = 1; j <= n; ++j) dp[u][j] += min(dp[v][j] - k, dp[v][p[v]]);
}
for (int i = 1; i <= n; ++i)
if (dp[u][i] < dp[u][p[u]]) p[u] = i;
}
void getans(int u, int fa, int x) {
ans[u] = x;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
getans(v, u, dp[v][x] - k < dp[v][p[v]] ? x : p[v]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; ++i) scanf("%d", &a[i]);
for (int i = 1, u, v; i < n; ++i) {
scanf("%d%d", &u, &v);
adde(u, v);
adde(v, u);
}
dfs(1, 0);
dfs2(1, 0);
printf("%d\n", dp[1][p[1]]);
getans(1, 0, p[1]);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200;
int i, j, k, l, m, n, o, tot, p, K, f[N][N], g[N][N], d[N], e[3 * N], e1[3 * N],
nex[3 * N], sta[N], vist[N], s1[N], n1[N * 3], best[N], id[N];
int cen[N], dist[N], len[N][N];
void add(int u, int v) {
nex[++l] = sta[u];
sta[u] = l;
e[l] = v;
}
void Init() {
scanf("%d%d", &n, &K);
l = 1;
for (i = 1; i <= n - 1; i++) scanf("%d", &d[i]);
for (i = 1; i <= n - 1; i++) {
scanf("%d%d", &o, &p);
add(o, p);
add(p, o);
}
for (i = 1; i <= n; i++)
for (j = 0; j <= n; j++) f[i][j] = g[i][j] = 1 << 30;
l = 1;
}
void travel(int x, int u) {
vist[u] = 1;
for (int i = sta[u]; i; i = nex[i])
if (!vist[e[i]]) {
len[x][e[i]] = len[x][u] + 1;
travel(x, e[i]);
}
}
void prepare_len() {
for (i = 1; i <= n; i++) {
len[i][i] = 0;
for (j = 1; j <= n; j++) vist[j] = 0;
travel(i, i);
}
for (i = 1; i <= n; i++) vist[i] = 0;
}
void MakeDrive(int u) {
vist[u] = 1;
for (int i = sta[u]; i; i = nex[i])
if (!vist[e[i]]) {
n1[++l] = s1[u];
s1[u] = l;
e1[l] = e[i];
MakeDrive(e[i]);
}
}
void Dp(int u) {
int i, j, s, o, p, v, sum;
best[u] = 1 << 30;
if (!s1[u]) {
best[u] = f[u][0] = K;
for (s = 1; s <= n - 1; s++) g[u][s] = d[s];
} else {
for (i = s1[u]; i; i = n1[i]) Dp(e1[i]);
for (s = 0; s <= n - 1; s++) {
sum = 0;
for (i = s1[u]; i; i = n1[i]) {
v = e1[i];
sum += min(g[v][s + 1], best[v]);
}
for (i = s1[u]; i; i = n1[i]) {
v = e1[i];
f[u][s] = min(f[u][s], f[v][s - 1] + sum - min(g[v][s + 1], best[v]));
}
if (s) {
g[u][s] = sum + d[s];
f[u][s] += d[s];
} else {
f[u][s] = K + sum;
g[u][s] = 1 << 30;
}
if (f[u][s] < best[u]) {
best[u] = f[u][s];
id[u] = s;
}
}
}
}
void dfs(int isf, int u, int s) {
int i, j, v, sum, t;
dist[u] = s;
if (!s) cen[++tot] = u;
sum = 0;
for (i = s1[u]; i; i = n1[i]) {
v = e1[i];
sum += min(g[v][s + 1], best[v]);
}
if (s) {
if (isf)
for (i = s1[u]; i; i = n1[i]) {
v = e1[i];
if ((f[u][s] - d[s]) ==
(f[v][s - 1] + sum - min(g[v][s + 1], best[v]))) {
dfs(1, v, s - 1);
for (j = s1[u]; j; j = n1[j])
if (e1[j] != v) {
t = e1[j];
if (g[t][s + 1] < best[t])
dfs(0, t, s + 1);
else
dfs(1, t, id[t]);
}
break;
}
}
else
for (i = s1[u]; i; i = n1[i]) {
t = e1[i];
if (g[t][s + 1] < best[t])
dfs(0, t, s + 1);
else
dfs(1, t, id[t]);
}
} else if (isf)
for (i = s1[u]; i; i = n1[i]) {
t = e1[i];
if (g[t][s + 1] < best[t])
dfs(0, t, s + 1);
else
dfs(1, t, id[t]);
}
}
void PutAnswer() {
int ans = 1 << 30, t;
for (i = 0; i <= n - 1; i++)
if (f[1][i] < ans) {
ans = f[1][i];
t = i;
}
cout << ans << endl;
dfs(1, 1, t);
for (i = 1; i <= n; i++) {
for (j = 1; j <= tot; j++)
if (len[i][cen[j]] == dist[i]) {
printf("%d", cen[j]);
break;
}
if (i < n)
printf(" ");
else
printf("\n");
}
}
int main() {
Init();
prepare_len();
MakeDrive(1);
Dp(1);
PutAnswer();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, nn, head[200], a[200][200], belong[200], b[200], dp[200][200], d[200];
struct arr {
int aa, bb;
} na[400];
int min(int l, int r) {
if (l < r)
return l;
else
return r;
}
void add(int x, int y) {
nn = nn + 1;
na[nn].aa = y;
na[nn].bb = head[x];
head[x] = nn;
}
void fdp(int u, int fa) {
for (int i = 1; i <= n; i++) dp[u][i] = d[a[u][i]];
for (int i = head[u]; i; i = na[i].bb) {
int j = na[i].aa;
if (j == fa) continue;
fdp(j, u);
for (int k = 1; k <= n; k++)
dp[u][k] = dp[u][k] + min(dp[j][b[j]] + m, dp[j][k]);
}
b[u] = -1;
for (int i = 1; i <= n; i++) {
if (b[u] == -1) {
b[u] = i;
continue;
}
if (dp[u][i] < dp[u][b[u]]) b[u] = i;
}
}
void shuchu(int u, int fa, int v) {
belong[u] = v;
for (int i = head[u]; i; i = na[i].bb) {
int j = na[i].aa;
if (j == fa) continue;
if (dp[j][b[j]] + m < dp[j][v])
shuchu(j, u, b[j]);
else
shuchu(j, u, v);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n - 1; i++) scanf("%d", &d[i]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i == j)
a[i][j] = 0;
else
a[i][j] = 2019201920 / 2;
for (int i = 1; i <= n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
a[x][y] = 1;
a[y][x] = 1;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if ((k != i) && (k != j) && (i != j))
a[i][j] = min(a[i][j], a[i][k] + a[k][j]);
fdp(1, 0);
printf("%d\n", dp[1][b[1]] + m);
shuchu(1, 0, b[1]);
for (int i = 1; i <= n; i++) printf("%d ", belong[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
const int N = 201;
const int INF = 1e9;
vector<int> G[N];
set<int> se[N];
int d[N], dep[N], fa[N][11], dist[N][N], dp[N][N], dp2[N], bes[N], ans[N];
void dfs_dep(int x, int F) {
fa[x][0] = F;
for (int i = 1; i <= 10; i++) fa[x][i] = fa[fa[x][i - 1]][i - 1];
dep[x] = dep[F] + 1;
se[x].insert(x);
for (int i = 0; i < G[x].size(); i++) {
int tmp = G[x][i];
if (tmp == F) continue;
dfs_dep(tmp, x);
for (set<int>::iterator it = se[tmp].begin(); it != se[tmp].end(); it++) {
se[x].insert(*it);
}
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 10; i >= 0; i--) {
if (dep[x] - dep[y] >= (1 << i)) x = fa[x][i];
}
if (x == y) return x;
for (int i = 10; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
}
return fa[x][0];
}
void dfs_dp(int x, int F) {
for (int i = 0; i < G[x].size(); i++) {
int tmp = G[x][i];
if (tmp == F) continue;
dfs_dp(tmp, x);
}
dp2[x] = INF;
for (int i = 1; i <= n; i++) {
if (x == i) dp[x][x] += k;
dp[x][i] += d[dep[x] + dep[i] - 2 * dep[lca(x, i)]];
for (int j = 0; j < G[x].size(); j++) {
int tmp = G[x][j];
if (tmp == F) continue;
if (se[tmp].count(i))
dp[x][i] += dp[tmp][i];
else if (dp2[tmp] < dp[tmp][i])
dp[x][i] += dp2[tmp];
else
dp[x][i] += dp[tmp][i];
}
if (se[x].count(i) && dp2[x] > dp[x][i]) dp2[x] = dp[x][i], bes[x] = i;
}
}
void pr(int x, int F, int ne) {
ans[x] = ne;
for (int i = 0; i < G[x].size(); i++) {
int tmp = G[x][i];
if (tmp == F) continue;
if (se[tmp].count(ne))
pr(tmp, x, ne);
else if (dp2[tmp] <= dp[tmp][ne])
pr(tmp, x, bes[tmp]);
else
pr(tmp, x, ne);
}
}
int main() {
cin >> n >> k;
for (int i = 1; i < n; i++) cin >> d[i];
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
dfs_dep(1, 0);
dfs_dp(1, 0);
int minv = INF, mini = 0;
for (int i = 1; i <= n; i++) {
if (dp[1][i] < minv) minv = dp[1][i], mini = i;
}
pr(1, 0, mini);
cout << minv << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int n, t, d[190], dp[190][190], dist[190][190], best[190], ans[190];
vector<int> g[190];
void dfs(int pos, int par) {
for (int i = 0; i < g[pos].size(); ++i)
if (g[pos][i] != par) dfs(g[pos][i], pos);
int mn = 1e9;
for (int i = 1; i <= n; ++i) {
dp[pos][i] = d[dist[pos][i]];
for (int j = 0; j < g[pos].size(); ++j)
if (g[pos][j] != par)
dp[pos][i] += min(dp[g[pos][j]][i], dp[g[pos][j]][best[g[pos][j]]] + t);
if (dp[pos][i] < mn) {
mn = dp[pos][i];
best[pos] = i;
}
}
}
void getAns(int pos, int to, int par) {
ans[pos] = to;
for (int i = 0; i < g[pos].size(); ++i)
if (g[pos][i] != par) {
if (dp[g[pos][i]][to] < dp[g[pos][i]][best[g[pos][i]]] + t)
getAns(g[pos][i], to, pos);
else
getAns(g[pos][i], best[g[pos][i]], pos);
}
}
int main() {
cin >> n >> t;
for (int i = 0; i < n + 5; ++i)
for (int j = 0; j < n + 5; ++j)
if (i != j) dist[i][j] = 1e9;
for (int i = 1; i <= n - 1; ++i) scanf("%d", &d[i]);
int x, y;
for (int i = 0; i < n - 1; ++i) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
dist[x][y] = dist[y][x] = 1;
}
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dist[i][j] = min(dist[i][k] + dist[k][j], dist[i][j]);
dfs(1, 0);
cout << dp[1][best[1]] + t << endl;
getAns(1, best[1], 0);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, tmp, nw, id[185], w[185], in[185], pin[185], ax[185][185],
f[185][185][2], head[185];
struct edge {
int v, nxt, p[185][2];
} e[185 * 2];
void dfs(int, int);
void find(int, int, int, int);
void adde(int, int);
int main() {
int i, u, v, ans = 1000000000, ps;
scanf("%d %d", &n, &nw);
for (i = 1; i < n; ++i) scanf("%d", &w[i]);
for (i = 1; i < n; ++i) {
scanf("%d %d", &u, &v);
adde(u, v);
adde(v, u);
}
dfs(1, 0);
for (i = 0; i < n; ++i)
if (ans > f[1][i][0]) {
ans = f[1][i][0];
ps = i;
}
find(1, 0, ps, 0);
printf("%d\n", ans);
for (i = 1; i <= n; ++i) printf("%d ", id[i]);
return 0;
}
void dfs(int u, int fa) {
int i, d, v, ww;
for (i = head[u]; i; i = e[i].nxt)
if ((v = e[i].v) != fa) dfs(v, u);
for (d = 0; d < n; ++d) in[d] = 1000000000;
for (i = head[u]; i; i = e[i].nxt)
if ((v = e[i].v) != fa) {
f[u][0][0] += min(f[v][1][1], f[v][0][0]);
if (f[v][1][1] == min(f[v][1][1], f[v][0][0]))
e[i].p[0][0] = 3;
else if (f[v][0][0] == min(f[v][1][1], f[v][0][0]))
e[i].p[0][0] = 0;
for (d = 1; d < n; ++d) {
ww = min(f[v][d + 1][1], min(f[v][d][0], f[v][d - 1][0]));
f[u][d][0] += ww;
f[u][d][1] += ww;
if (ww == f[v][d + 1][1])
e[i].p[d][0] = e[i].p[d][1] = (d + 1) * 2 + 1;
else if (ww == f[v][d][0])
e[i].p[d][0] = e[i].p[d][1] = d * 2;
else
e[i].p[d][0] = e[i].p[d][1] = (d - 1) * 2;
if (in[d] > f[v][d - 1][0] - ww) {
in[d] = f[v][d - 1][0] - ww;
pin[d] = i;
}
}
}
f[u][0][0] += nw;
for (d = 1; d < n; ++d) {
f[u][d][0] += in[d] + w[d];
f[u][d][1] += w[d];
e[pin[d]].p[d][0] = 2 * (d - 1);
}
}
void find(int u, int fa, int d, int fl) {
int i, v;
if (!fl && !d)
id[u] = u;
else if (fl)
id[u] = id[fa];
for (i = head[u]; i; i = e[i].nxt)
if ((v = e[i].v) != fa)
if (e[i].p[d][fl] % 2 == 0) {
find(v, u, e[i].p[d][fl] / 2, e[i].p[d][fl] % 2);
if (!fl && d == e[i].p[d][fl] / 2 + 1) id[u] = id[v];
}
for (i = head[u]; i; i = e[i].nxt)
if ((v = e[i].v) != fa)
if (e[i].p[d][fl] % 2) find(v, u, e[i].p[d][fl] / 2, e[i].p[d][fl] % 2);
}
void adde(int u, int v) {
e[++tmp].v = v;
e[tmp].nxt = head[u];
head[u] = tmp;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 250;
long long dp[2][MAX][MAX];
long long gdeep;
long long deeps[MAX], deeps2[MAX], vist[MAX], store[MAX][MAX], stidx[MAX][MAX],
parent[MAX];
vector<long long> childs[MAX];
long long head[MAX], nxt[MAX << 1], to[MAX << 1], ent, cur;
long long n, k, d[MAX];
struct node {
long long mask, v, deep;
node() {}
node(long long a, long long b, long long c) : mask(a), v(b), deep(c) {}
};
vector<node> ss[2][MAX][MAX];
void add(long long a, long long b) {
nxt[ent] = head[a], to[ent] = b, head[a] = ent++;
nxt[ent] = head[b], to[ent] = a, head[b] = ent++;
}
void dfs1(long long v, long long pa) {
vist[v] = 1;
deeps[v] = 0;
for (long long i = head[v]; ~i; i = nxt[i]) {
long long u = to[i];
if (u != pa && vist[u] == 0) {
parent[u] = v;
dfs1(u, v);
deeps[v] = std::max(deeps[v], deeps[u] + 1);
}
}
}
void dfs2(long long v, long long pa) {
vist[v] = 1;
for (long long i = head[v]; ~i; i = nxt[i]) {
long long u = to[i];
if (u != pa && vist[u] == 0) {
childs[v].push_back(u);
dfs2(u, v);
}
}
}
bool debug = 0;
long long sol(long long mask, long long v, long long deep) {
auto &ele = dp[mask][v][deep];
auto &ve = ss[mask][v][deep];
if (ele != -1) return ele;
if (mask == 0) {
if (vist[v] == 0) {
vist[v] = 1;
for (long long i = 0; i < childs[v].size(); i++) {
long long u = childs[v][i];
for (long long dd = 0; dd <= deeps[u]; dd++) {
sol(mask, u, dd);
}
store[u][deeps[u]] = dp[mask][u][deeps[u]],
stidx[u][deeps[u]] = deeps[u];
for (long long dd = deeps[u] - 1; dd >= 0; dd--) {
if (store[u][dd + 1] > dp[mask][u][dd]) {
store[u][dd] = dp[mask][u][dd], stidx[u][dd] = dd;
} else
store[u][dd] = store[u][dd + 1], stidx[u][dd] = stidx[u][dd + 1];
}
}
}
if (childs[v].size() == 0) {
if (deep == 0)
return ele = k;
else
return ele = LLONG_MAX;
} else {
if (deep == 0) {
ele = k;
for (long long i = 0; i < childs[v].size(); i++) {
long long u = childs[v][i];
ele += std::min(sol(1, u, 1) - k, store[u][0]);
if (sol(1, u, 1) - k < store[u][0])
ve.push_back({1, u, 1});
else
ve.push_back({0, u, stidx[u][0]});
}
return ele;
} else {
if (deep > deeps[v]) return ele = LLONG_MAX;
ele = LLONG_MAX;
for (long long i = 0; i < childs[v].size(); i++) {
long long u = childs[v][i];
if (deeps[u] >= deep - 1) {
vector<node> tmp;
long long t1 = sol(0, u, deep - 1);
tmp.push_back({0, u, deep - 1});
if (t1 != LLONG_MAX) {
for (long long j = 0; j < childs[v].size(); j++) {
long long t = childs[v][j];
if (t != u) {
if (deep - 1 > deeps[t])
t1 += sol(1, t, deep + 1) - k,
tmp.push_back({1, t, deep + 1});
else {
if (sol(1, t, deep + 1) - k < store[t][deep - 1])
t1 += sol(1, t, deep + 1) - k,
tmp.push_back({1, t, deep + 1});
else
t1 += store[t][deep - 1],
tmp.push_back({0, t, stidx[t][deep - 1]});
}
}
}
if (t1 + d[deep] < ele) {
ele = t1 + d[deep];
ve = move(tmp);
}
}
}
}
return ele;
}
}
} else {
if (childs[v].size() == 0) {
if (deep > deeps2[v])
return ele = LLONG_MAX;
else
return ele = d[deep] + k;
} else {
if (deep > deeps2[v]) return ele = LLONG_MAX;
ele = d[deep] + k;
for (int i = 0; i < childs[v].size(); i++) {
long long u = childs[v][i];
long long t1 = sol(mask, u, deep + 1) - k;
long long t2 = LLONG_MAX, idx;
for (long long dd = 0; dd <= deeps[u]; dd++) {
if (sol(0, u, dd) < t2) {
t2 = sol(0, u, dd), idx = dd;
}
}
if (t1 < t2) {
ele += t1, ve.push_back({mask, u, deep + 1});
} else
ele += t2, ve.push_back({0, u, idx});
}
return ele;
}
}
}
bool power[MAX];
long long ans[MAX];
void assignP(long long mask, long long v, long long deep) {
auto &ve = ss[mask][v][deep];
if (mask == 0 && deep == 0) power[v] = 1;
for (int i = 0; i < ve.size(); i++) {
node &nn = ve[i];
assignP(nn.mask, nn.v, nn.deep);
}
}
void bfs() {
for (int i = 1; i <= n; i++) {
memset(vist, 0, sizeof(vist));
queue<int> q;
q.push(i), vist[i] = 1;
if (power[i] == 1)
ans[i] = i;
else {
bool find = 0;
while (!q.empty() && !find) {
int v = q.front();
q.pop();
for (int j = head[v]; ~j; j = nxt[j]) {
int u = to[j];
if (vist[u] == 0) {
if (power[u] == 1) {
ans[i] = u, find = 1;
break;
} else {
vist[u] = 1, q.push(u);
}
}
}
}
}
}
}
int main() {
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= n - 1; i++) scanf("%lld", &d[i]);
memset(head, -1, sizeof(head));
ent = 0;
for (long long i = 1; i <= n - 1; i++) {
long long a, b;
scanf("%lld%lld", &a, &b);
add(a, b);
}
gdeep = LLONG_MIN;
for (long long i = 1; i <= n; i++) deeps[i] = LLONG_MIN;
memset(vist, 0, sizeof(vist));
parent[1] = -1, dfs1(1, -1);
for (long long i = 1; i <= n; i++) {
deeps2[i] = 0;
long long tt = i, zz = 1;
if (i == 2)
debug = 1;
else
debug = 0;
while (tt != -1) {
long long pa = parent[tt];
if (pa != -1) {
deeps2[i] = std::max(deeps2[i], zz);
for (long long j = head[pa]; ~j; j = nxt[j]) {
long long u = to[j];
if (u != tt && u != parent[pa]) {
deeps2[i] = std::max(deeps2[i], deeps[u] + zz + 1);
}
}
}
++zz, tt = pa;
}
}
memset(vist, 0, sizeof(vist));
dfs2(1, -1);
for (long long i = 1; i <= n; i++) {
for (long long dd = 0; dd <= deeps[i]; dd++) dp[0][i][dd] = -1;
for (long long dd = 0; dd <= deeps2[i]; dd++) dp[1][i][dd] = -1;
}
memset(vist, 0, sizeof(vist));
long long opt = LLONG_MAX, t1;
node optn;
for (long long dd = 0; dd <= deeps[1]; dd++) {
t1 = sol(0, 1, dd);
if (t1 < opt) opt = t1, optn = {0, 1, dd};
}
for (long long dd = 1; dd <= deeps2[1]; dd++) {
t1 = sol(1, 1, dd);
if (t1 < opt) opt = t1, optn = {1, 1, dd};
}
printf("%lld\n", opt);
memset(power, 0, sizeof(power));
assignP(optn.mask, optn.v, optn.deep);
bfs();
for (int i = 1; i <= n; i++) printf("%lld ", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[180][180], dist[180][180], d[180], a[180];
vector<int> ge[180];
bool v[180];
void dfs(int i, int n, int k) {
for (int j = 0; j < n; j++) f[i][j] = d[dist[i][j]];
v[i] = true;
for (int j = 0; j < ge[i].size(); j++) {
int son = ge[i][j];
if (v[son]) continue;
dfs(son, n, k);
for (int t = 0; t < n; t++) {
int minv = f[son][t];
for (int x = 0; x < n; x++) minv = min(minv, f[son][x] + k);
f[i][t] += minv;
}
}
}
void getAnswer(int i, int t, int n, int k) {
a[i] = t;
v[i] = true;
for (int j = 0; j < ge[i].size(); j++) {
int son = ge[i][j];
if (v[son]) continue;
int minv = f[son][t], c = t;
for (int x = 0; x < n; x++)
if (f[son][x] + k < minv) {
minv = f[son][x] + k;
c = x;
}
getAnswer(son, c, n, k);
}
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
d[0] = 0;
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
ge[a].push_back(b);
ge[b].push_back(a);
}
for (int i = 0; i < n; i++) {
memset(v, false, sizeof(v));
queue<int> q;
q.push(i);
v[i] = true;
dist[i][i] = 0;
while (!q.empty()) {
int now = q.front();
q.pop();
for (int j = 0; j < ge[now].size(); j++) {
int t = ge[now][j];
if (v[t]) continue;
v[t] = true;
dist[i][t] = dist[i][now] + 1;
q.push(t);
}
}
}
memset(v, false, sizeof(v));
dfs(0, n, k);
int ans = f[0][0];
int t = 0;
for (int i = 1; i < n; i++)
if (f[0][i] < ans) {
ans = f[0][i];
t = i;
}
printf("%d\n", ans + k);
memset(v, false, sizeof(v));
getAnswer(0, t, n, k);
for (int i = 0; i < n; i++)
if (i < n - 1) {
printf("%d ", a[i] + 1);
} else {
printf("%d\n", a[i] + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
bool debug = false;
int d[205], ans[205], mp[205][205], f[205][205], path[205];
void dfs(int x, int p) {
for (int i = 1; i <= n; i++) {
f[x][i] = d[mp[x][i]] + k;
}
for (int i = 1; i <= n; i++)
if (mp[x][i] == 1 && i != p) {
dfs(i, x);
for (int j = 1; j <= n; j++) {
f[x][j] += min(f[i][ans[i]], f[i][j] - k);
}
}
ans[x] = 1;
for (int i = 2; i <= n; i++) {
if (f[x][i] < f[x][ans[x]]) ans[x] = i;
}
}
void pt(int x, int p, int r) {
path[x] = r;
for (int i = 1; i <= n; i++)
if (mp[x][i] == 1 && i != p) {
pt(i, x, f[i][r] - k < f[i][ans[i]] ? r : ans[i]);
}
}
int main() {
scanf("%d%d", &n, &k);
int a, b;
for (int i = 1; i < n; i++) scanf("%d", d + i);
for (int i = 0; i < 205; i++)
for (int j = 0; j < 205; j++) mp[i][j] = 1000;
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
mp[a][b] = mp[b][a] = 1;
mp[i][i] = 0;
}
mp[n][n] = 0;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
mp[i][j] = min(mp[i][j], mp[i][k] + mp[k][j]);
}
dfs(1, -1);
printf("%d\n", f[1][ans[1]]);
pt(1, -1, ans[1]);
for (int i = 1; i <= n; i++) printf("%d ", path[i]);
return 0;
}
|
#include <bits/stdc++.h>
using std::bitset;
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
using std::make_pair;
using std::map;
using std::pair;
using std::priority_queue;
using std::queue;
using std::set;
using std::string;
using std::stringstream;
using std::vector;
class MyTimer {
public:
void reset() {}
void report() {}
} myTimer;
template <typename T1, typename T2>
inline bool chmin(T1 &a, const T2 &b) {
return a > b ? a = b, true : false;
}
template <typename T1, typename T2>
inline bool chmax(T1 &a, const T2 &b) {
return a < b ? a = b, true : false;
}
inline int readint() {
int a = 0;
char c = getchar(), p = 0;
while (isspace(c)) c = getchar();
if (c == '-') p = 1, c = getchar();
while (isdigit(c)) a = a * 10 + c - '0', c = getchar();
return p ? -a : a;
}
inline long long readLL() {
long long a = 0;
char c = getchar(), p = 0;
while (isspace(c)) c = getchar();
if (c == '-') p = 1, c = getchar();
while (isdigit(c)) a = a * 10 + c - '0', c = getchar();
return p ? -a : a;
}
const int maxN = 180 + 5;
const int INF = 0x3f3f3f3f;
int n, w[maxN];
int p[maxN][maxN], d[maxN][maxN];
vector<int> G[maxN];
void init(int u, int root, int fa) {
for (int v : G[u])
if (v != fa) {
p[v][root] = u;
d[v][root] = d[u][root] + 1;
init(v, root, u);
}
}
int f[maxN][maxN], g[maxN];
void DFS(int u, int fa) {
memset(f[u], INF, sizeof(f[u]));
for (int v : G[u])
if (v != fa) DFS(v, u);
g[u] = INF;
for (int t = 1; t <= n; ++t) {
f[u][t] = w[d[u][t]];
if (p[u][t] != fa) {
f[u][t] = w[d[u][t]];
for (int v : G[u])
if (v != fa)
if (v == p[u][t])
f[u][t] += f[v][t];
else
f[u][t] += std::min(f[v][t], g[v]);
else {
}
chmin(g[u], f[u][t]);
} else {
for (int v : G[u])
if (v != fa) f[u][t] += std::min(f[v][t], g[v]);
}
}
}
int master[maxN];
void printG(int u, int fa);
void printF(int u, int t, int fa) {
master[u] = t;
if (p[u][t] != fa) {
for (int v : G[u])
if (v != fa)
if (v == p[u][t])
printF(v, t, u);
else
f[v][t] < g[v] ? printF(v, t, u) : printG(v, u);
else {
}
} else {
for (int v : G[u])
if (v != fa) f[v][t] < g[v] ? printF(v, t, u) : printG(v, u);
}
}
void printG(int u, int fa) {
for (int t = 1; t <= n; ++t)
if (p[u][t] != fa)
if (g[u] == f[u][t]) {
printF(u, t, fa);
return;
}
}
int main() {
std::ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) cin >> w[i];
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
for (int root = 1; root <= n; ++root) {
p[root][root] = root;
d[root][root] = 0;
init(root, root, -1);
}
DFS(1, -1);
printf("%d\n", g[1]);
printG(1, -1);
for (int u = 1; u <= n; ++u) printf("%d%c", master[u], " \n"[u == n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 185, INF = 1e7 + 7;
int floyd[maxn][maxn], road[maxn][maxn], d[maxn], path[maxn], f[maxn][maxn],
ans[maxn], N, K;
inline int read() {
int w = 0, f = 1;
char ch = getchar();
while (ch < '0' or ch > '9') {
if (ch == '-') f = -f;
ch = getchar();
}
while (ch >= '0' and ch <= '9') w = w * 10 + ch - '0', ch = getchar();
return w * f;
}
void dfs(int x, int fa) {
for (int i = 1; i <= N; i++) f[i][x] = K + d[floyd[i][x]];
for (int y = 1; y <= N; y++) {
if (y == x or y == fa or !road[x][y]) continue;
dfs(y, x);
for (int i = 1; i <= N; i++) f[i][x] += min(f[path[y]][y], f[i][y] - K);
}
path[x] = 1;
for (int i = 1; i <= N; i++)
if (f[path[x]][x] > f[i][x]) path[x] = i;
}
void print(int x, int fa, int p) {
ans[x] = p;
for (int y = 1; y <= N; y++) {
if (y == fa or !road[x][y] or y == x) continue;
if (f[path[y]][y] < f[p][y] - K)
print(y, x, path[y]);
else
print(y, x, p);
}
}
int main() {
N = read(), K = read();
for (int i = 1; i < N; i++) d[i] = read();
for (int i = 1; i < N; i++) {
int x = read(), y = read();
road[x][y] = 1, road[y][x] = 1;
}
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) floyd[i][j] = INF;
for (int i = 1; i <= N; i++) floyd[i][i] = 0;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
if (road[i][j]) floyd[i][j] = 1;
for (int k = 1; k <= N; k++)
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
if (floyd[i][k] != INF and floyd[k][j] != INF)
floyd[i][j] = min(floyd[i][j], floyd[i][k] + floyd[k][j]);
dfs(1, 0);
printf("%d\n", f[path[1]][1]);
print(1, 0, path[1]);
for (int i = 1; i <= N; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void cmax(int &a, int b) { a = max(a, b); }
inline void cmin(int &a, int b) { a = min(a, b); }
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
struct edge {
int to, cap, rev;
edge(int x, int y, int z) { to = x, cap = y, rev = z; }
};
struct Max_flow {
int Siz;
int src, snk;
vector<vector<edge> > G;
vector<int> dist, seen;
Max_flow() {
Siz = 0;
src = -1;
snk = -1;
G.clear();
dist.clear();
seen.clear();
}
void Set(int x, int y) { src = x, snk = y; }
void resize(int s) {
Siz = s;
G.resize(s + 1);
dist.resize(s + 1);
seen.resize(s + 1);
}
void add_edge(int u, int v, int c) {
edge t1(v, c, G[v].size()), t2(u, 0, G[u].size());
G[u].push_back(t1);
G[v].push_back(t2);
}
void bfs(int s) {
for (int i = 0; i < dist.size(); i++) dist[i] = -1;
queue<int> Q;
dist[s] = 0;
Q.push(s);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (int i = 0; i < G[x].size(); i++) {
int v = G[x][i].to;
if (G[x][i].cap && dist[v] == -1) {
dist[v] = dist[x] + 1;
Q.push(v);
}
}
}
}
int dfs(int x, int dest, int flow) {
if (x == dest) return flow;
for (int &i = seen[x]; i < G[x].size(); i++) {
edge &e = G[x][i];
if (e.cap && dist[e.to] == dist[x] + 1) {
int ff = dfs(e.to, dest, min(flow, e.cap));
if (ff) {
e.cap -= ff;
G[e.to][e.rev].cap += ff;
return ff;
}
}
}
return 0;
}
int dinic(int u, int v) {
int ans = 0;
while (1) {
for (int i = 0; i < seen.size(); i++) seen[i] = 0;
bfs(u);
if (dist[v] == -1) break;
int f;
while (f = dfs(u, v, 1e9)) {
ans += f;
}
}
return ans;
}
int Maxflow() { return dinic(src, snk); }
};
const int Maxn = 188;
int D[Maxn];
int dp[Maxn][Maxn][2];
int pre[Maxn][Maxn];
int ppre[Maxn][Maxn];
int g[Maxn];
int id[Maxn];
int par[Maxn];
vector<int> G[Maxn], son[Maxn];
bool vis[Maxn];
int n, k;
void dfs(int x) {
vis[x] = true;
for (int i = 0; i < G[x].size(); i++) {
int v = G[x][i];
if (!vis[v]) {
dfs(v);
son[x].push_back(v);
}
}
dp[x][0][0] = k;
dp[x][0][1] = k;
for (int i = 0; i < son[x].size(); i++) {
int v = son[x][i];
dp[x][0][0] += min(g[v], dp[v][1][1]);
dp[x][0][1] += min(g[v], dp[v][1][1]);
if (g[v] < dp[v][1][1]) {
ppre[v][1] = -1;
}
}
for (int d = 1; d <= n; d++) {
int tot = 0;
for (int i = 0; i < son[x].size(); i++) {
int v = son[x][i];
tot += min(g[v], dp[v][d + 1][1]);
if (g[v] < dp[v][d + 1][1]) {
ppre[v][d + 1] = -1;
}
}
dp[x][d][0] = 1e9;
for (int i = 0; i < son[x].size(); i++) {
int v = son[x][i];
int curcost = dp[v][d - 1][0] + tot - min(g[v], dp[v][d + 1][1]) + D[d];
if (curcost < dp[x][d][0]) {
dp[x][d][0] = curcost;
pre[x][d] = v;
}
}
dp[x][d][1] = D[d];
for (int i = 0; i < son[x].size(); i++) {
int v = son[x][i];
dp[x][d][1] += min(dp[v][d + 1][1], g[v]);
}
}
g[x] = 1e9;
for (int i = 0; i <= n; i++) {
if (dp[x][i][0] < g[x]) {
g[x] = dp[x][i][0];
id[x] = i;
}
}
}
void _init() {
for (int i = 0; i < Maxn; i++) {
for (int j = 0; j < Maxn; j++) {
dp[i][j][0] = dp[i][j][1] = 1e9;
}
}
}
int curpa;
void go(int x, int d, int tp, int pp) {
if (tp == 0) {
if (d == 0) {
for (int i = 0; i < son[x].size(); i++) {
int v = son[x][i];
if (ppre[v][1] != -1) {
go(v, 1, 1, x);
} else {
int tt = id[v];
go(v, tt, 0, -1);
}
}
par[x] = x;
curpa = x;
return;
}
int idd = pre[x][d];
go(idd, d - 1, 0, pp);
pp = curpa;
par[x] = pp;
for (int i = 0; i < son[x].size(); i++) {
int v = son[x][i];
if (v == idd) continue;
if (ppre[v][d + 1] != -1) {
go(v, d + 1, 1, pp);
} else {
int tt = id[v];
go(v, tt, 0, -1);
}
}
curpa = pp;
} else {
par[x] = pp;
for (int i = 0; i < son[x].size(); i++) {
int v = son[x][i];
if (ppre[v][d + 1] != -1) {
go(v, d + 1, 1, pp);
} else {
int tt = id[v];
go(v, tt, 0, -1);
}
}
}
}
int main() {
_init();
scanf("%d %d", &n, &k);
for (int i = 1; i <= n - 1; i++) {
scanf("%d", &D[i]);
}
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1);
printf("%d\n", g[1]);
go(1, id[1], 0, -1);
for (int i = 1; i <= n; i++) {
printf("%d ", par[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9 + 29;
const int N = 2e2 + 22;
int dist[N][N], d[N], dp[N];
int ans[N], mem[N][N][2];
set<int> vert[N];
vector<int> g[N];
void setdfs(int v, int p) {
for (int u : g[v]) {
if (u != p) setdfs(u, v);
}
vert[v].insert(v);
for (int x : vert[v]) {
vert[p].insert(x);
}
}
int dfs2(int v, int p, int x, int flg) {
if (!mem[v][x][flg]) return mem[v][x][flg];
int sum = d[dist[v][x]];
for (int u : g[v]) {
if (u != p) {
if (flg && vert[u].count(x))
sum += dfs2(u, v, x, 1);
else
sum += dfs2(u, v, x, 0);
}
}
if (!flg) sum = min(sum, dp[v]);
return mem[v][x][flg] = sum;
}
void dfs(int v, int p) {
for (int u : g[v]) {
if (u != p) dfs(u, v);
}
int ret = inf;
for (int x : vert[v]) {
ret = min(ret, dfs2(v, p, x, 1));
}
dp[v] = ret;
return;
}
void backTrack(int v, int p, int x, int flg) {
if (!flg) {
if (dfs2(v, p, x, 1) <= dp[v]) {
ans[v] = x;
for (int u : g[v]) {
if (u != p) backTrack(u, v, x, 0);
}
return;
}
for (int y : vert[v]) {
if (dfs2(v, p, y, 1) == dp[v]) {
return backTrack(v, p, y, 1);
}
}
}
ans[v] = x;
for (int u : g[v]) {
if (u != p) {
if (vert[u].count(x))
backTrack(u, v, x, 1);
else
backTrack(u, v, x, 0);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(32);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> d[i];
}
memset(dist, 0x3f, sizeof(dist));
dist[1][1] = 0;
for (int i = 2; i <= n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
dist[i][i] = 0;
dist[u][v] = dist[v][u] = 1;
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
memset(mem, -1, sizeof(mem));
setdfs(1, 0);
dfs(1, 0);
backTrack(1, 0, 1, 0);
cout << dp[1] << endl;
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Stanje {
int x, u, d;
Stanje() {}
Stanje(int X, int U, int D) : x(X), u(U), d(D) {}
};
vector<int> node[184];
vector<int> v;
int dp[184][184][184];
int dp2[184][184][184];
Stanje parent[184][184][184];
int parent2[184][184][184];
int dfsparent[184];
int cost[184];
int height[184];
int center[184];
bool bio[184];
int N;
vector<int> c;
bool bfsbio[184];
void DFS(int x, int parent = -1) {
bio[x] = true;
for (vector<int>::iterator it = node[x].begin(); it != node[x].end(); ++it) {
if (bio[*it]) continue;
DFS(*it, x);
if (height[*it] + 1 > height[x]) height[x] = height[*it] + 1;
}
if (x > 1) {
dfsparent[x] = parent;
node[x].erase(find(node[x].begin(), node[x].end(), parent));
}
v.push_back(x);
}
vector<int> stek;
void reconstruct(int x, int u, int d) {
if (d == 0) c.push_back(x);
if (height[x] == 0) return;
stek.push_back(x);
for (int i = 0; i < node[x].size(); ++i) {
int y = node[x][i];
Stanje S;
if (parent[x][u][d].x == y) {
S = parent[x][u][d];
} else if (d > 0)
S = Stanje(node[x][i], min(u, d) + 1, parent2[y][min(u, d) + 1][N]);
else {
S = Stanje(node[x][i], 1, parent2[y][1][parent[x][u][d].d]);
}
reconstruct(S.x, S.u, S.d);
}
stek.pop_back();
}
void BFS(void) {
queue<int> q;
memset(bfsbio, 0, sizeof(bfsbio));
for (int i = 2; i <= N; ++i) node[i].push_back(dfsparent[i]);
for (int i = 0; i < c.size(); ++i) {
q.push(c[i]);
center[c[i]] = c[i];
bfsbio[c[i]] = true;
}
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = 0; i < node[x].size(); ++i) {
int y = node[x][i];
if (bfsbio[y]) continue;
bfsbio[y] = true;
center[y] = center[x];
q.push(y);
}
}
}
int main(void) {
int A, B;
memset(cost, 0x3f, sizeof(cost));
scanf("%d%d", &N, &cost[0]);
for (int i = 1; i < N; ++i) scanf("%d", cost + i);
for (int i = 1; i < N; ++i) {
scanf("%d%d", &A, &B);
node[A].push_back(B);
node[B].push_back(A);
}
memset(dp, 0x3f, sizeof(dp));
memset(dp2, 0x3f, sizeof(dp2));
DFS(1);
for (int I = 0; I < N; ++I) {
int x = v[I];
for (int u = 1; u <= N; ++u)
for (int d = 0; d <= N; ++d) {
if (d > height[x] && d < N) continue;
int best = node[x].empty() ? 0 : 1000000000;
Stanje best_parent;
if (d > 0) {
int sum = 0;
for (int i = 0; i < node[x].size(); ++i)
sum += dp2[node[x][i]][min(u, d) + 1][N];
for (int i = 0; i < node[x].size(); ++i) {
int y = node[x][i];
int tmp = dp[y][min(u + 1, N)][d == N ? N : d - 1] + sum -
dp2[y][min(u, d) + 1][N];
if (tmp < best) {
best = tmp;
best_parent = Stanje(y, min(u + 1, N), d == N ? N : d - 1);
}
}
} else {
for (int h = 0; h <= N; ++h) {
int sum = 0;
for (int i = 0; i < node[x].size(); ++i)
sum += dp2[node[x][i]][1][h];
for (int i = 0; i < node[x].size(); ++i) {
int y = node[x][i];
int tmp = dp[y][1][h] + sum - dp2[y][1][h];
if (tmp < best) {
best = tmp;
best_parent = Stanje(y, 1, h);
}
}
}
}
best += cost[min(u, d)];
if (best > 1000000000) best = 1000000000;
for (int i = d; i <= N; ++i)
if (best < dp2[x][u][i]) {
dp2[x][u][i] = best;
parent2[x][u][i] = d;
}
dp[x][u][d] = best;
parent[x][u][d] = best_parent;
}
}
int best = 1000000000;
Stanje S;
for (int i = 0; i < N; ++i) {
int tmp = dp[1][N][i];
if (tmp < best) {
best = tmp;
S = Stanje(1, N, i);
}
}
printf("%d\n", best);
reconstruct(S.x, S.u, S.d);
BFS();
for (int i = 1; i <= N; ++i) printf("%d ", center[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[185][185], best[185], dis[185][185], cost[185], n, k, d[185][185],
ans[185];
void floyd() {
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
void dp(int x, int fa) {
for (int y = 1; y <= n; y++)
if (d[x][y])
if (y != fa) dp(y, x);
for (int i = 1, minn = 1 << 30; i <= n; i++) {
f[x][i] = cost[dis[x][i]] + k;
for (int y = 1; y <= n; y++)
if (d[x][y])
if (y != fa) f[x][i] += min(f[y][i] - k, f[y][best[y]]);
if (f[x][i] < minn) {
minn = f[x][i];
best[x] = i;
}
}
}
void make(int x, int fa) {
for (int y = 1; y <= n; y++)
if (d[x][y])
if (y != fa) {
if (f[y][best[y]] < f[y][ans[x]] - k)
ans[y] = best[y];
else
ans[y] = ans[x];
make(y, x);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", &cost[i]);
memset(dis, 63, sizeof(dis));
for (int i = 1, a, b; i < n; i++) {
scanf("%d%d", &a, &b);
d[a][b] = d[b][a] = true;
dis[a][b] = dis[b][a] = 1;
}
floyd();
dp(1, 0);
ans[1] = best[1];
make(1, 0);
printf("%d\n", f[1][best[1]]);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int d[N][N], f[N][N], g[N][N], Min[N], w[N], ans[N], i, j, k, x, y, n;
void floyed() {
int i, j, z;
for (z = 1; z <= n; z++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (z != i && i != j && j != z)
if (d[i][z] + d[z][j] < d[i][j]) d[i][j] = d[i][z] + d[z][j];
for (i = 1; i <= n; i++) d[i][i] = 0;
}
void dfs(int u, int fa) {
int i, j;
for (i = 1; i <= n; i++) f[u][i] = w[d[u][i]] + k;
for (i = 1; i <= n; i++)
if (i != fa && g[u][i] == 1) {
dfs(i, u);
for (j = 1; j <= n; j++) f[u][j] += min(f[i][j] - k, f[i][Min[i]]);
}
Min[u] = 1;
for (i = 2; i <= n; i++)
if (f[u][i] < f[u][Min[u]]) Min[u] = i;
}
void write(int u, int fa, int now) {
ans[u] = now;
int i;
for (i = 1; i <= n; i++)
if (i != fa && g[u][i] == 1) {
if (f[i][now] - k < f[i][Min[i]])
write(i, u, now);
else
write(i, u, Min[i]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (i = 1; i <= n - 1; i++) scanf("%d", &w[i]);
for (i = 1; i <= N; i++)
for (j = 1; j <= N; j++) d[i][j] = 1e9;
for (i = 1; i <= n - 1; i++) {
scanf("%d%d", &x, &y);
g[x][y] = g[y][x] = d[x][y] = d[y][x] = 1;
}
floyed();
dfs(1, 0);
printf("%d\n", f[1][Min[1]]);
write(1, 0, Min[1]);
for (i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200;
struct Edge {
int nxt, to;
Edge(int nxt = 0, int to = 0) : nxt(nxt), to(to) {}
} e[N << 1];
int first[N], cur;
void connect(int x, int y) {
e[++cur] = Edge(first[x], y);
first[x] = cur;
}
int n, k;
int d[N];
int dis[N][N];
int f[N][N], p[N];
void dfs(int x, int fa, int y) {
if (fa != x) dis[y][x] = dis[y][fa] + 1;
for (int i = first[x]; i; i = e[i].nxt)
if (e[i].to != fa) dfs(e[i].to, x, y);
}
void get(int x, int fa) {
for (int i = 1; i <= n; i++) f[x][i] = d[dis[x][i]] + k;
for (int i = first[x]; i; i = e[i].nxt)
if (e[i].to != fa) {
get(e[i].to, x);
for (int j = 1; j <= n; j++)
f[x][j] += min(f[e[i].to][p[e[i].to]], f[e[i].to][j] - k);
}
p[x] = 1;
for (int i = 1; i <= n; i++)
if (f[x][i] < f[x][p[x]]) p[x] = i;
}
int ans[N];
void get_ans(int x, int fa, int pos) {
ans[x] = pos;
for (int i = first[x]; i; i = e[i].nxt)
if (e[i].to != fa)
get_ans(e[i].to, x,
f[e[i].to][p[e[i].to]] < f[e[i].to][pos] - k ? p[e[i].to] : pos);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i < n; i++) cin >> d[i];
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
connect(u, v), connect(v, u);
}
for (int i = 1; i <= n; i++) dis[i][i] = 0, dfs(i, i, i);
get(1, 0), get_ans(1, 0, p[1]);
cout << f[1][p[1]] << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
const int INF = 1e9;
int n;
int m;
int res[200][200][2];
int NEXT[200][200][2];
int y[200], ly[200], ry[200], d[200], use[200];
int g[200][200];
vector<int> v[200];
int go(int x, int p) {
vector<int> w;
for (int i = 0; i < ((int)(v[x]).size()); i++)
if (v[x][i] != p) {
go(v[x][i], x);
w.push_back(v[x][i]);
}
int k = ((int)(w).size());
res[x][n][0] = res[x][n][1] = INF;
for (int i = 0; i < n; i++) {
res[x][i][0] = 0;
for (int j = 0; j < k; j++) {
int cur = res[w[j]][i + 1][0];
for (int k = -1; k < 1; k++)
if (i + k >= 0 && cur > res[w[j]][i + k][1]) cur = res[w[j]][i + k][1];
y[j] = cur;
res[x][i][0] = min(res[x][i][0] + cur, INF);
}
for (int j = 0; j < k; j++) {
ly[j] = y[j];
if (j > 0) ly[j] = min(ly[j - 1] + y[j], INF);
}
for (int j = k - 1; j >= 0; j--) {
ry[j] = y[j];
if (j + 1 < k) ry[j] = min(ry[j + 1] + y[j], INF);
}
NEXT[x][i][0] = -1;
res[x][i][1] = INF;
if (i == 0) res[x][i][1] = res[x][i][0];
if (i > 0)
for (int j = 0; j < k; j++) {
int cur = res[w[j]][i - 1][1];
if (j - 1 >= 0) cur = min(cur + ly[j - 1], INF);
if (j + 1 < k) cur = min(cur + ry[j + 1], INF);
if (res[x][i][1] > cur) {
res[x][i][1] = cur;
NEXT[x][i][1] = w[j];
}
}
res[x][i][0] += d[i];
res[x][i][1] += d[i];
}
return 0;
}
int out(int x, int ai, int aj, int p) {
if (ai == 0) use[x] = 1;
vector<int> w;
for (int i = 0; i < ((int)(v[x]).size()); i++)
if (v[x][i] != p) w.push_back(v[x][i]);
int k = ((int)(w).size());
for (int j = 0; j < k; j++) {
int cur = res[w[j]][ai + 1][0], ak = ai + 1;
int ok = 0;
if (w[j] == NEXT[x][ai][aj]) {
cur = INF;
ok = 1;
}
for (int k = -1; k < 1 - ok; k++)
if (ai + k >= 0 && cur > res[w[j]][ai + k][1]) {
ak = ai + k;
cur = res[w[j]][ai + k][1];
}
out(w[j], ak, int(ak <= ai), x);
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
d[0] = m;
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) g[i][j] = n + 1;
for (int i = 0; i < n; i++) g[i][i] = 0;
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
g[a][b] = g[b][a] = 1;
}
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
go(0, -1);
int ans = INF, ai = 0;
for (int i = 0; i < n; i++)
if (res[0][i][1] < ans) {
ans = res[0][i][1];
ai = i;
}
printf("%d\n", ans);
out(0, ai, 1, -1);
for (int i = 0; i < n; i++) {
int k = -1;
for (int j = 0; j < n; j++)
if (use[j] && (k == -1 || g[i][k] > g[i][j])) k = j;
printf("%d ", k + 1);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d[205], dis[205][205], dp[205][205];
int p[205];
int ans[205];
vector<int> v[205];
void aux() {
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int r = 1; r <= n; r++)
dis[i][r] = min(dis[i][r], dis[i][k] + dis[k][r]);
}
void solve(int x, int fa) {
for (int i = 1; i <= n; i++) dp[i][x] = d[dis[i][x]] + k;
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i];
if (to == fa) continue;
solve(to, x);
for (int r = 1; r <= n; r++) dp[r][x] += min(dp[p[to]][to], dp[r][to] - k);
}
p[x] = 1;
for (int i = 2; i <= n; i++)
if (dp[p[x]][x] > dp[i][x]) p[x] = i;
}
void getans(int x, int fa) {
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i];
if (to == fa) continue;
ans[to] = (dp[p[to]][to] < dp[ans[x]][to] - k) ? p[to] : ans[x];
getans(to, x);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", d + i);
memset(dis, 0X3f, sizeof dis);
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
dis[a][b] = dis[b][a] = 1;
v[a].push_back(b);
v[b].push_back(a);
}
aux();
solve(1, 0);
printf("%d\n", dp[p[1]][1]);
ans[1] = p[1];
getans(1, 0);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
void read(Tp &x) {
x = 0;
int op = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') op = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= op;
}
template <typename Tp>
void CMax(Tp &x, Tp y) {
if (y > x) x = y;
}
template <typename Tp>
void CMin(Tp &x, Tp y) {
if (y < x) x = y;
}
const int N = 205;
const int INF = 0x3f3f3f3f;
int n, k;
int d[N];
vector<int> T[N];
void Adde(int x, int y) {
T[x].push_back(y);
T[y].push_back(x);
}
int dis[N][N];
void GetDis(int x, int fa, int rt) {
for (auto y : T[x])
if (y != fa) {
dis[rt][y] = dis[rt][x] + 1;
GetDis(y, x, rt);
}
}
int f[N][N], best[N];
void DP(int x, int fa) {
for (auto y : T[x])
if (y != fa) DP(y, x);
int mn = INF;
for (int i = (1); i <= (n); ++i) {
f[x][i] = d[dis[x][i]] + k;
for (auto y : T[x])
if (y != fa) {
f[x][i] += min(f[y][i] - k, f[y][best[y]]);
}
if (f[x][i] < mn) {
mn = f[x][i];
best[x] = i;
}
}
}
int pos[N];
void GetPos(int x, int fa, int p) {
pos[x] = p;
for (auto y : T[x])
if (y != fa) {
if (f[y][p] - k < f[y][best[y]])
GetPos(y, x, p);
else
GetPos(y, x, best[y]);
}
}
int main() {
read(n);
read(k);
for (int i = (1); i <= (n - 1); ++i) read(d[i]);
int x, y;
for (int i = (2); i <= (n); ++i) read(x), read(y), Adde(x, y);
for (int i = (1); i <= (n); ++i) GetDis(i, 0, i);
DP(1, 0);
printf("%d\n", f[1][best[1]]);
GetPos(1, 0, best[1]);
for (int i = (1); i <= (n); ++i) printf("%d ", pos[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 222;
const int inf = 1e9;
int n, m, c[N], a[N][N], f[N][N], g[N];
int ff[N][N], gg[N];
vector<int> v[N];
int tt, tin[N], tout[N];
bool isin(int x, int y) { return tin[x] <= tin[y] && tout[y] <= tout[x]; }
void dfs(int u, int fa = -1) {
int i, j, sz, x, y;
tin[u] = ++tt;
sz = v[u].size();
for (j = 0; j < sz; j = j + 1) {
x = v[u][j];
if (x != fa) dfs(x, u);
}
tout[u] = tt;
g[u] = inf;
for (i = 1; i <= n; i = i + 1) {
f[u][i] = c[a[u][i]];
for (j = 0; j < sz; j = j + 1) {
x = v[u][j];
if (x != fa) {
y = f[x][i];
if (!isin(x, i)) y = min(y, g[x]);
f[u][i] += y;
}
}
if (isin(u, i) && g[u] > f[u][i]) {
g[u] = f[u][i];
gg[u] = i;
}
}
}
int ans[N];
void getans(int u, int fa = -1, int isg = 1) {
int i, j, sz, x;
if (isg) ans[u] = gg[u];
i = ans[u];
sz = v[u].size();
for (j = 0; j < sz; j = j + 1) {
x = v[u][j];
if (x != fa) {
if (f[x][i] >= g[x] && !isin(x, i))
getans(x, u, 1);
else {
ans[x] = i;
getans(x, u, 0);
}
}
}
}
int main() {
int i, j, k, x, y;
cin >> n >> c[0];
for (i = 1; i < n; i = i + 1) cin >> c[i];
for (i = 1; i <= n; i = i + 1)
for (j = 1; j <= n; j = j + 1)
if (i != j) a[i][j] = inf;
for (i = 1; i < n; i = i + 1) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
a[x][y] = 1;
a[y][x] = 1;
}
for (k = 1; k <= n; k = k + 1)
for (i = 1; i <= n; i = i + 1)
for (j = 1; j <= n; j = j + 1) a[i][j] = min(a[i][j], a[i][k] + a[k][j]);
for (i = 1; i <= n; i = i + 1) tin[i] = 0, tout[i] = n;
dfs(1);
cout << g[1] << endl;
getans(1);
for (i = 1; i <= n; i = i + 1) cout << ans[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 185;
struct Tedge {
int v;
Tedge *p;
};
Tedge *head[maxn], buf[maxn * 2], *ptr = buf;
int f[maxn][maxn], dis[maxn][maxn];
int d[maxn], loc[maxn], ans[maxn];
int n, k;
void getdis(int u, int r, int fa) {
for (Tedge *p = head[u]; p; p = p->p)
if (p->v != fa) {
dis[r][p->v] = dis[r][u] + 1;
getdis(p->v, r, u);
}
}
void dp(int u, int fa) {
int i;
Tedge *p;
for (i = 1; i <= n; ++i) f[u][i] = d[dis[u][i]] + k;
for (p = head[u]; p; p = p->p)
if (p->v != fa) {
dp(p->v, u);
for (i = 1; i <= n; ++i)
f[u][i] += min(f[p->v][i] - k, f[p->v][loc[p->v]]);
}
for (i = 1, loc[u] = u; i <= n; ++i)
if (f[u][i] < f[u][loc[u]]) loc[u] = i;
}
void getans(int u, int r, int fa) {
Tedge *p;
ans[u] = r;
for (p = head[u]; p; p = p->p)
if (p->v != fa)
if (f[p->v][r] - k < f[p->v][loc[p->v]])
getans(p->v, r, u);
else
getans(p->v, loc[p->v], u);
}
int main() {
int i, u, v;
scanf("%d%d", &n, &k);
for (i = 1; i < n; ++i) scanf("%d", d + i);
for (i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
*ptr = (Tedge){v, head[u]};
head[u] = ptr++;
*ptr = (Tedge){u, head[v]};
head[v] = ptr++;
}
for (i = 1; i <= n; ++i) getdis(i, i, 0);
dp(1, 0);
printf("%d\n", f[1][loc[1]]);
getans(1, loc[1], 0);
for (i = 1; i <= n; ++i) printf("%d%c", ans[i], i == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, e, f, g, h, i, j, k;
int F[205][205];
int G[205];
int num[205];
int father[205];
int L[205];
int D[205][205];
vector<int> GG[205];
int an;
int belong[205];
void soso(int x) {
int ii, jj, kk;
for (ii = 0; ii < GG[x].size(); ii++) {
jj = GG[x][ii];
if (jj == father[x]) continue;
father[jj] = x;
soso(jj);
}
for (ii = 1; ii <= a; ii++) {
F[x][ii] = b + L[D[x][ii]];
for (jj = 0; jj < GG[x].size(); jj++) {
kk = GG[x][jj];
if (kk == father[x]) continue;
F[x][ii] += min(F[kk][ii] - b, G[kk]);
}
}
G[x] = 1 << 30;
for (ii = 1; ii <= a; ii++) {
if (F[x][ii] < G[x]) {
G[x] = F[x][ii];
num[x] = ii;
}
}
}
void Get_Belong(int x, int y) {
int ii, jj, kk;
belong[x] = y;
for (ii = 0; ii < GG[x].size(); ii++) {
jj = GG[x][ii];
if (jj == father[x]) continue;
if (F[jj][y] - b < G[jj])
Get_Belong(jj, y);
else
Get_Belong(jj, num[jj]);
}
}
int main() {
cin >> a >> b;
for (i = 1; i < a; i++) cin >> L[i];
for (i = 1; i <= a; i++)
for (j = 1; j <= a; j++)
if (i != j) D[i][j] = 1 << 29;
for (i = 1; i < a; i++) {
cin >> c >> d;
GG[c].push_back(d);
GG[d].push_back(c);
D[c][d] = D[d][c] = 1;
}
for (k = 1; k <= a; k++)
for (i = 1; i <= a; i++)
for (j = 1; j <= a; j++) D[i][j] = min(D[i][j], D[i][k] + D[k][j]);
soso(1);
cout << G[1] << endl;
Get_Belong(1, num[1]);
for (i = 1; i <= a; i++) cout << belong[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
struct Edge {
int u, v;
} e[361];
int head[181], ecnt;
inline void adde(int u, int v) {
e[++ecnt].v = v;
e[ecnt].u = head[u];
head[u] = ecnt;
}
inline void add(int u, int v) {
adde(u, v);
adde(v, u);
}
int dis[181][181], RT, f[181][181], p[181], n, k, d[181], A, B, cho[181],
ans[181];
inline void Dfs(int x, int fa) {
for (int yny = head[x], v; yny && (v = e[yny].v); yny = e[yny].u)
if (v != fa) {
dis[RT][v] = dis[RT][x] + 1;
Dfs(v, x);
}
}
inline void dfs1(int x, int fa) {
for (int i = (1); i <= (n); i++) f[x][i] = d[dis[x][i]] + k;
for (int yny = head[x], v; yny && (v = e[yny].v); yny = e[yny].u)
if (v != fa) {
dfs1(v, x);
for (int i = (1); i <= (n); i++) f[x][i] += min(f[v][i] - k, f[v][p[v]]);
}
f[x][0] = inf;
for (int i = (1); i <= (n); i++)
if (f[x][i] < f[x][p[x]]) p[x] = i;
}
inline void dfs2(int x, int fa, int as) {
ans[x] = as;
for (int yny = head[x], v; yny && (v = e[yny].v); yny = e[yny].u)
if (v != fa) {
if (f[v][p[v]] < (f[v][as] - k))
dfs2(v, x, p[v]);
else
dfs2(v, x, as);
}
}
inline void solve() {
scanf("%d %d", &n, &k);
for (int i = (1); i <= (n - 1); i++) scanf("%d", &d[i]);
for (int i = (1); i <= (n - 1); i++) scanf("%d %d", &A, &B), add(A, B);
for (int i = (1); i <= (n); i++) dis[i][i] = 0, RT = i, Dfs(i, 0);
dfs1(1, 0);
printf("%d\n", f[1][p[1]]);
dfs2(1, 0, p[1]);
for (int i = (1); i <= (n); i++) printf("%d ", ans[i]);
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
int N, K, A, B;
int D[191];
vector<int> G[181];
int d[180][180];
int par[180];
int best[180];
bitset<180> bb[180];
bitset<180> cb[180];
bitset<180> df[180][180];
bitset<180> cf[180][180];
int dp[180][180];
void solve(int v, int c, int p) {
dp[v][c] = d[v][c];
cf[v][c].set(c);
for (int(i) = 0; (i) < (G[v].size()); (i)++)
if (G[v][i] != p) {
int u = G[v][i];
if (dp[u][c] > best[u]) {
dp[v][c] += best[u];
df[v][c] = df[v][c] | bb[u];
cf[v][c] = cf[v][c] | cb[u];
} else {
dp[v][c] += dp[u][c];
df[v][c] = df[v][c] | df[u][c];
df[v][c].set(u);
cf[v][c] = cf[v][c] | cf[u][c];
}
}
}
void dfs(int v, int p) {
par[v] = p;
for (int(i) = 0; (i) < (G[v].size()); (i)++)
if (G[v][i] != p) dfs(G[v][i], v);
for (int(i) = 0; (i) < (N); (i)++) solve(v, i, p);
int pos = 0;
for (int(i) = (1); (i) < (N); (i)++)
if (dp[v][i] < dp[v][pos]) pos = i;
best[v] = dp[v][pos] + K;
bb[v] = df[v][pos];
cb[v] = cf[v][pos];
}
struct UnionFind {
int par[180], ans[180];
UnionFind() {
for (int(i) = 0; (i) < (180); (i)++) par[i] = i;
}
int find(int x) { return par[x] == x ? x : par[x] = find(par[x]); }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
par[b] = a;
}
} uf;
int main() {
scanf("%d%d", &N, &K);
for (int(i) = 0; (i) < (N - 1); (i)++) scanf("%d", &D[i + 1]);
for (int(i) = 0; (i) < (N); (i)++)
for (int(j) = 0; (j) < (N); (j)++) d[i][j] = (1 << 29) * (i != j);
for (int(i) = 0; (i) < (N - 1); (i)++) {
scanf("%d%d", &A, &B);
A--, B--;
G[A].push_back(B);
G[B].push_back(A);
d[A][B] = d[B][A] = 1;
}
for (int(k) = 0; (k) < (N); (k)++)
for (int(i) = 0; (i) < (N); (i)++)
for (int(j) = 0; (j) < (N); (j)++)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
for (int(i) = 0; (i) < (N); (i)++)
for (int(j) = 0; (j) < (N); (j)++) d[i][j] = D[d[i][j]];
dfs(0, -1);
printf("%d\n", best[0]);
for (int(i) = (1); (i) < (N); (i)++)
if (bb[0].test(i)) uf.unite(i, par[i]);
for (int(i) = 0; (i) < (N); (i)++)
if (cb[0].test(i)) uf.ans[uf.find(i)] = i + 1;
for (int(i) = 0; (i) < (N); (i)++)
printf("%d%c", uf.ans[uf.find(i)], i + 1 == N ? '\n' : ' ');
}
|
#include <bits/stdc++.h>
using namespace std;
const long long NR = 2e2 + 10;
long long n, k;
long long d[NR], g[NR][NR];
long long f[NR][NR], minx[NR], ans[NR];
long long h[NR];
struct edge {
long long v, next;
} e[2 * NR];
long long tot = 0;
void add(long long u, long long v) {
tot++;
e[tot].v = v;
e[tot].next = h[u];
h[u] = tot;
}
void dfs(long long u, long long fa) {
for (long long i = 1; i <= n; i++) {
if (g[u][i] == 0x3f3f3f3f) continue;
f[u][i] = d[g[u][i]] + k;
}
for (long long i = h[u]; i != 0; i = e[i].next) {
long long v = e[i].v;
if (v == fa) continue;
dfs(v, u);
for (long long j = 1; j <= n; j++) {
f[u][j] += min(f[v][minx[v]], f[v][j] - k);
}
}
minx[u] = 1;
for (long long i = 2; i <= n; i++) {
if (f[u][minx[u]] > f[u][i]) {
minx[u] = i;
}
}
}
void dfsPri(long long u, long long fa, long long x) {
ans[u] = x;
for (long long i = h[u]; i != 0; i = e[i].next) {
long long v = e[i].v;
if (v == fa) continue;
if (f[v][minx[v]] < f[v][x] - k)
dfsPri(v, u, minx[v]);
else
dfsPri(v, u, x);
}
}
int main() {
scanf("%lld%lld", &n, &k);
memset(g, 0x3f, sizeof g);
for (long long i = 1; i < n; i++) {
scanf("%lld", d + i);
}
for (long long i = 1; i <= n; i++) {
g[i][i] = 0;
}
for (long long i = 1; i < n; i++) {
long long u, v;
scanf("%lld%lld", &u, &v);
g[u][v] = 1;
g[v][u] = 1;
add(u, v);
add(v, u);
}
for (long long k = 1; k <= n; k++) {
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
g[i][j] = g[j][i] = min(g[i][j], g[i][k] + g[k][j]);
}
}
}
dfs(1, 0);
dfsPri(1, 0, minx[1]);
printf("%lld\n", f[1][minx[1]]);
for (int i = 1; i <= n; i++) {
printf("%lld ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 210;
const int M = 410;
const int INF = 1e8;
using namespace std;
int n;
int las[N], ans[N];
int edge[M], lst[N], nxt[M], t = 0;
long long dis[N][N], f[N][N], mn[N], d[N], K;
void ADD(int x, int y) {
edge[++t] = y;
nxt[t] = lst[x];
lst[x] = t;
}
void READ() {
int u, v;
scanf("%d%lld", &n, &K);
for (int i = 1; i <= n - 1; i++) scanf("%lld", &d[i]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) dis[i][j] = INF;
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &u, &v);
ADD(u, v);
ADD(v, u);
dis[u][v] = dis[v][u] = 1;
}
}
void INIT() {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
for (int i = 1; i <= n; i++) mn[i] = 1e16, las[i] = -1;
}
void SEARCH(int x, int fa) {
for (int r = lst[x]; r; r = nxt[r]) {
if (edge[r] == fa) continue;
SEARCH(edge[r], x);
}
for (int pos = 1; pos <= n; pos++) {
f[x][pos] = d[dis[x][pos]] + K;
for (int r = lst[x]; r; r = nxt[r]) {
if (edge[r] == fa) continue;
f[x][pos] += min(f[edge[r]][las[edge[r]]], f[edge[r]][pos] - K);
}
if (f[x][pos] < mn[x]) las[x] = pos, mn[x] = f[x][pos];
}
}
void SOLVE(int x, int fa) {
for (int r = lst[x]; r; r = nxt[r]) {
if (edge[r] == fa) continue;
if (f[edge[r]][las[edge[r]]] < f[edge[r]][ans[x]] - K)
ans[edge[r]] = las[edge[r]];
else
ans[edge[r]] = ans[x];
SOLVE(edge[r], x);
}
}
int main() {
READ();
INIT();
SEARCH(1, 0);
printf("%lld\n", mn[1]);
ans[1] = las[1];
SOLVE(1, 0);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 180, Inf = 1000000000;
int si[N + 10], sk;
class Tree {
int n, m;
struct Point {
int first, ua[N + 10], da[N + 10], best, bi, di[N + 10], ans;
} po[N + 10];
struct Line {
int next, l;
} li[N * 2 + 10];
void Dfs(int fa, int k) {
int i, j, t, tmp, tmp2, tmp3;
for (i = po[k].first; i; i = li[i].next) {
if ((j = li[i].l) == fa) continue;
Dfs(k, j);
}
po[k].best = Inf;
po[k].ua[n] = Inf;
for (t = 0; t < n; t++) {
tmp = 0;
po[k].ua[t] = po[k].da[t] = si[t];
for (i = po[k].first; i; i = li[i].next) {
if ((j = li[i].l) == fa) continue;
tmp += min(po[j].best, po[j].ua[t + 1]);
}
po[k].ua[t] += tmp;
if (t == 0)
po[k].ua[t] += sk, po[k].da[t] = po[k].ua[t], po[k].di[0] = k;
else {
tmp2 = Inf;
for (i = po[k].first; i; i = li[i].next) {
if ((j = li[i].l) == fa) continue;
if (tmp2 >
(tmp3 = tmp - min(po[j].best, po[j].ua[t + 1]) + po[j].da[t - 1]))
tmp2 = tmp3, po[k].di[t] = po[j].di[t - 1];
}
po[k].da[t] += tmp2;
}
if (po[k].da[t] < po[k].best) po[k].best = po[k].da[t], po[k].bi = t;
}
}
void Get(int fa, int k, int l, int d) {
int i, j;
po[k].ans = d;
if (l >= 0) {
for (i = po[k].first; i; i = li[i].next) {
if ((j = li[i].l) == fa) continue;
if (po[j].best > po[j].ua[l + 1])
Get(k, j, l + 1, d);
else
Get(k, j, -po[j].bi, po[j].di[po[j].bi]);
}
return;
}
l = -l;
for (i = po[k].first; i; i = li[i].next) {
if ((j = li[i].l) == fa) continue;
if (d == po[j].di[l - 1])
Get(k, j, -l + 1, d);
else {
if (po[j].best > po[j].ua[l + 1])
Get(k, j, l + 1, d);
else
Get(k, j, -po[j].bi, po[j].di[po[j].bi]);
}
}
}
public:
void Add(int a, int b) {
li[++m].next = po[a].first;
li[m].l = b, po[a].first = m;
li[++m].next = po[b].first;
li[m].l = a, po[b].first = m;
}
void Work(int _n) {
n = _n;
Dfs(0, 1);
Get(0, 1, -po[1].bi, po[1].di[po[1].bi]);
printf("%d\n", po[1].best);
for (int i = 1; i <= n; i++) printf("%d ", po[i].ans);
printf("\n");
}
} tr;
int main() {
int i, j, n, ans, a, b;
scanf("%d%d", &n, &sk);
for (i = 1; i < n; i++) scanf("%d", &si[i]);
for (i = 1; i < n; i++) scanf("%d%d", &a, &b), tr.Add(a, b);
tr.Work(n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, f[190][190], a[190], d[190][190], ans[190], pre[190];
vector<long long> edge[190];
inline void floyd() {
for (long long k = 1; k <= n; k++) {
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
d[i][j] = d[j][i] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
}
void dfs(long long m, long long before) {
for (long long i = 1; i <= n; i++) f[m][i] = a[d[m][i]] + k;
for (long long i = 0; i < edge[m].size(); i++) {
long long Next = edge[m][i];
if (Next != before) {
dfs(Next, m);
for (long long j = 1; j <= n; j++)
f[m][j] += min(f[Next][ans[Next]], f[Next][j] - k);
}
}
ans[m] = 1;
for (long long i = 2; i <= n; i++) {
if (f[m][i] < f[m][ans[m]]) ans[m] = i;
}
}
void print(long long m, long long before, long long x) {
pre[m] = x;
for (long long i = 0; i < edge[m].size(); i++) {
long long Next = edge[m][i];
if (Next != before) {
if (f[Next][ans[Next]] < f[Next][x] - k)
print(Next, m, ans[Next]);
else
print(Next, m, x);
}
}
}
int main() {
cin >> n >> k;
for (long long i = 1; i < n; i++) scanf("%lld", &a[i]);
memset(d, 0x3f, sizeof(d));
for (long long i = 1; i <= n; i++) d[i][i] = 0;
for (long long i = 1; i < n; i++) {
long long x, y;
scanf("%lld %lld", &x, &y);
d[x][y] = d[y][x] = 1;
edge[x].push_back(y);
edge[y].push_back(x);
}
floyd();
dfs(1, 0);
printf("%lld\n", f[1][ans[1]]);
print(1, 0, ans[1]);
for (long long i = 1; i <= n; i++) printf("%lld ", pre[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int w[205], d[205][205], f[205][205], b[205], c[205], n, v, x, y;
void dfs(int x, int y) {
for (int j = 1; j <= n; j++) f[x][j] = w[d[x][j]] + v;
for (int i = 1; i <= n; i++)
if (d[x][i] == 1 && y - i) {
dfs(i, x);
for (int j = 1; j <= n; j++) f[x][j] += min(f[i][j] - v, f[i][b[i]]);
}
b[x] = 1;
for (int j = 1; j <= n; j++)
if (f[x][j] < f[x][b[x]]) b[x] = j;
}
void prt(int x, int y, int z) {
c[x] = z;
for (int i = 1; i <= n; i++)
if (d[x][i] == 1 && y - i) prt(i, x, f[i][z] - v < f[i][b[i]] ? z : b[i]);
}
int main() {
scanf("%d%d", &n, &v);
for (int i = 1; i <= n - 1; i++) scanf("%d", w + i);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = (i != j) << 22;
for (int i = 1; i <= n - 1; i++) scanf("%d%d", &x, &y), d[x][y] = d[y][x] = 1;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
dfs(1, 0), printf("%d\n", f[1][b[1]]), prt(1, 0, b[1]);
for (int i = 1; i <= n; i++) printf("%d%s", c[i], i < n ? " " : "\n");
return 0;
}
|
#include <bits/stdc++.h>
int fr[182], ne[362], v[362], bs = 0;
void addb(int a, int b) {
v[bs] = b;
ne[bs] = fr[a];
fr[a] = bs++;
}
int dp[182][182], wz[182], sz[182], cd[182][182], n, k;
int fa[182], sd[182], ans[182], zy[362][182];
void dfs0(int u, int f) {
fa[u] = f;
sd[u] = sd[f] + 1;
for (int i = fr[u]; i != -1; i = ne[i]) {
if (v[i] != f) dfs0(v[i], u);
}
}
int dfscd(int a, int b) {
if (a == b) return 0;
if (cd[a][b]) return cd[a][b];
if (sd[a] > sd[b])
cd[a][b] = dfscd(fa[a], b) + 1;
else
cd[a][b] = dfscd(a, fa[b]) + 1;
return cd[a][b];
}
void dfs(int u, int f) {
for (int i = fr[u]; i != -1; i = ne[i]) {
if (v[i] != f) dfs(v[i], u);
}
for (int a = 1; a <= n; a++) {
dp[u][a] = sz[cd[u][a]] + k;
for (int i = fr[u]; i != -1; i = ne[i]) {
if (v[i] == f) continue;
int t = dp[v[i]][wz[v[i]]];
if (dp[v[i]][a] - k < t) {
t = dp[v[i]][a] - k;
zy[i][a] = a;
} else
zy[i][a] = wz[v[i]];
dp[u][a] += t;
}
if (a == 1 || dp[u][a] < dp[u][wz[u]]) wz[u] = a;
}
}
void dfs1(int u, int f, int a) {
ans[u] = a;
for (int i = fr[u]; i != -1; i = ne[i]) {
if (v[i] != f) dfs1(v[i], u, zy[i][a]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) fr[i] = -1;
for (int i = 1; i < n; i++) scanf("%d", &sz[i]);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
addb(a, b);
addb(b, a);
}
dfs0(1, 0);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i != j && cd[i][j] == 0) dfscd(i, j);
}
}
dfs(1, 0);
int z = 1;
for (int i = 2; i <= n; i++) {
if (dp[1][i] < dp[1][z]) z = i;
}
printf("%d\n", dp[1][z]);
dfs1(1, 0, z);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mn = 210, inf = 1 << 29;
int d[mn], c[mn], ans[mn], f[mn][mn], g[mn][mn];
int n, co;
void dp(int r, int fa) {
int i, j;
for (i = 1; i <= n; ++i) f[r][i] = d[g[r][i]] + co;
for (i = 1; i <= n; ++i) {
if (g[r][i] != 1 || i == fa) continue;
dp(i, r);
for (j = 1; j <= n; ++j) f[r][j] += min(f[i][j] - co, f[i][c[i]]);
}
c[r] = r;
for (i = 1; i <= n; ++i)
if (f[r][i] < f[r][c[r]]) c[r] = i;
}
void repair(int r, int fa, int k) {
int i;
ans[r] = k;
for (i = 1; i <= n; ++i) {
if (g[r][i] != 1 || i == fa) continue;
if (f[i][k] - co < f[i][c[i]])
repair(i, r, k);
else
repair(i, r, c[i]);
}
}
int main() {
int i, j, k;
scanf("%d%d", &n, &co);
for (i = 1; i <= n - 1; ++i) scanf("%d", d + i);
fill(g[1], g[n + 1], inf);
for (i = 1; i <= n - 1; ++i) {
scanf("%d%d", &j, &k);
g[j][k] = g[k][j] = 1;
}
for (i = 1; i <= n; ++i) g[i][i] = 0;
for (k = 1; k <= n; ++k)
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j) g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
dp(1, 0);
printf("%d\n", f[1][c[1]]);
repair(1, 0, c[1]);
printf("%d", ans[1]);
for (i = 2; i <= n; ++i) printf(" %d", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, l, n, m, s, an, sum, tot, K;
int dis[500][500], v[500], e[1000], nxt[1000], go[1000];
int dp[500][500], best[500][500], ans[500];
void add(int x, int y) {
tot++;
e[tot] = y;
nxt[tot] = go[x];
go[x] = tot;
}
void dfs(int x, int pre, int now) {
for (int p = go[x]; p; p = nxt[p]) {
if (e[p] != pre) {
int y = e[p];
dis[now][y] = dis[now][x] + 1;
dfs(y, x, now);
}
}
}
void work(int x, int pre) {
for (int p = go[x]; p; p = nxt[p])
if (e[p] != pre) work(e[p], x);
for (int i = 1; i <= n; i++) {
dp[x][i] = v[dis[x][i]];
for (int p = go[x]; p; p = nxt[p]) {
if (e[p] != pre) {
int y = e[p];
dp[x][i] += min(dp[y][i], dp[y][best[y][i]] + K);
}
}
}
int k = 1;
for (int i = 2; i <= n; i++)
if (dp[x][i] < dp[x][k]) k = i;
for (int i = 1; i <= n; i++) best[x][i] = k;
}
void find(int x, int pre, int now) {
ans[x] = now;
for (int p = go[x]; p; p = nxt[p]) {
if (e[p] != pre) {
int y = e[p];
if (dp[y][now] < dp[y][best[y][now]] + K)
find(y, x, now);
else
find(y, x, best[y][now]);
}
}
}
int main() {
scanf("%d %d", &n, &K);
for (int i = 1; i < n; i++) scanf("%d", &v[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
add(x, y);
add(y, x);
}
for (int i = 1; i <= n; i++) dfs(i, -1, i);
work(1, -1);
int k = 1;
for (int i = 2; i <= n; i++)
if (dp[1][i] < dp[1][k]) k = i;
find(1, -1, k);
printf("%d\n", dp[1][k] + K);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int DIM = 189;
vector<int> edg[DIM];
int dst[DIM][DIM], cst[DIM];
int dp[DIM][DIM], opt[DIM], ans[DIM];
void dpdfs(int x, int f, int n, int k) {
for (int y = 1; y <= n; ++y) dp[x][y] = cst[dst[x][y]] + k;
for (int y : edg[x])
if (y != f) {
dpdfs(y, x, n, k);
for (int z = 1; z <= n; ++z) dp[x][z] += min(dp[y][z] - k, dp[y][opt[y]]);
}
opt[x] = 1;
for (int y = 1; y <= n; ++y)
if (dp[x][y] < dp[x][opt[x]]) opt[x] = y;
}
void soldfs(int x, int f, int n, int k, int v) {
ans[x] = v;
for (int y : edg[x])
if (y != f) soldfs(y, x, n, k, (dp[y][v] - k < dp[y][opt[y]] ? v : opt[y]));
}
int main(void) {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (i != j) dst[i][j] = numeric_limits<int>::max() / 2;
for (int i = 1; i <= n - 1; ++i) scanf("%d", &cst[i]);
for (int i = 1; i <= n - 1; ++i) {
int x, y;
scanf("%d %d", &x, &y);
edg[x].push_back(y);
dst[x][y] = 1;
edg[y].push_back(x);
dst[y][x] = 1;
}
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (dst[i][j] > dst[i][k] + dst[k][j])
dst[i][j] = dst[i][k] + dst[k][j];
dpdfs(1, 0, n, k);
soldfs(1, 0, n, k, opt[1]);
printf("%d\n", dp[1][opt[1]]);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
int min(int a, int b) { return a < b ? a : b; }
int *ej[180], eo[180];
void append(int i, int j) {
int o = eo[i]++;
if (o >= 2 && (o & o - 1) == 0)
ej[i] = (int *)realloc(ej[i], o * 2 * sizeof *ej[i]);
ej[i][o] = j;
}
int cc[180], dp[180][180][2], jj[180][180], diff[180][180], n;
void dfs(int p, int i) {
int o, d;
memset(jj[i], -1, n * sizeof *jj[i]),
memset(diff[i], 0x3f, n * sizeof *diff[i]), diff[i][0] = 0;
for (o = eo[i]; o--;) {
int j = ej[i][o];
if (j != p) {
dfs(i, j);
for (d = 0; d < n; d++) {
int x = min(min(dp[j][d][0], d == 0 ? 0x3f3f3f3f : dp[j][d - 1][0]),
d + 1 == n ? 0x3f3f3f3f : dp[j][d + 1][1]);
dp[i][d][1] = min(dp[i][d][1] + x, 0x3f3f3f3f);
if (d > 0 && dp[j][d - 1][0] != 0x3f3f3f3f &&
diff[i][d] > dp[j][d - 1][0] - x)
diff[i][d] = dp[j][d - 1][0] - x, jj[i][d] = j;
}
}
}
for (d = 0; d < n; d++) {
dp[i][d][1] = min(dp[i][d][1] + cc[d], 0x3f3f3f3f);
dp[i][d][0] = min(dp[i][d][1] + diff[i][d], 0x3f3f3f3f);
}
}
int pp[180];
void trace(int p, int i, int d, int up) {
int o;
if (d == 0)
pp[i] = i;
else if (up)
pp[i] = pp[p];
else
trace(i, jj[i][d], d - 1, 0), pp[i] = pp[jj[i][d]];
for (o = eo[i]; o--;) {
int j = ej[i][o];
if (j != p && (up || j != jj[i][d])) {
int x = min(min(dp[j][d][0], d == 0 ? 0x3f3f3f3f : dp[j][d - 1][0]),
d + 1 == n ? 0x3f3f3f3f : dp[j][d + 1][1]);
if (dp[j][d][0] == x)
trace(i, j, d, 0);
else if (d > 0 && dp[j][d - 1][0] == x)
trace(i, j, d - 1, 0);
else
trace(i, j, d + 1, 1);
}
}
}
int main() {
int h, i, j, d, d_, ans;
scanf("%d", &n);
for (d = 0; d < n; d++) scanf("%d", &cc[d]);
for (i = 0; i < n; i++) ej[i] = (int *)malloc(2 * sizeof *ej[i]);
for (h = 0; h < n - 1; h++) {
scanf("%d%d", &i, &j), i--, j--;
append(i, j), append(j, i);
}
dfs(-1, 0);
ans = 0x3f3f3f3f, d_ = -1;
for (d = 0; d < n; d++) {
int x = dp[0][d][0];
if (ans > x) ans = x, d_ = d;
}
printf("%d\n", ans);
trace(-1, 0, d_, 0);
for (i = 0; i < n; i++) printf("%d ", pp[i] + 1);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int cost[200];
vector<int> con[200];
vector<int> ch[200];
int d0[200][200];
int f0[200][200];
int q0[200][200];
int d1[200][200];
int f1[200][200];
void build_tree(int cur, int p = -1) {
for (int i = 0; i < con[cur].size(); i++)
if (con[cur][i] != p) {
ch[cur].push_back(con[cur][i]);
build_tree(ch[cur].back(), cur);
}
}
void print_tree() {
for (int i = 0; i < n; i++) {
cout << i << " ->";
for (int j = 0; j < ch[i].size(); j++) cout << " " << ch[i][j];
cout << endl;
}
}
int calc_d1(int, int);
int calc_d0(int i, int l) {
if (d0[i][l] == -1) {
int& res = d0[i][l];
int& f = f0[i][l];
res = cost[0];
for (int j = 0; j < ch[i].size(); j++) res += calc_d0(ch[i][j], 1);
f = -1;
if (l < n) {
int cnt = cost[l];
for (int j = 0; j < ch[i].size(); j++) cnt += calc_d0(ch[i][j], l + 1);
if (cnt < res) {
res = cnt;
f = -2;
}
}
for (int r = 1; r < l; r++) {
for (int q = 0; q < ch[i].size(); q++) {
int cnt = calc_d1(ch[i][q], r - 1) + cost[r];
for (int j = 0; j < ch[i].size(); j++)
if (j != q) cnt += calc_d0(ch[i][j], r + 1);
if (cnt < res) {
res = cnt;
f = r;
q0[i][l] = q;
}
}
}
}
return d0[i][l];
}
int calc_d1(int i, int r) {
if (d1[i][r] == -1) {
int& res = d1[i][r];
int& f = f1[i][r];
if (r == 0) {
res = cost[0];
for (int j = 0; j < ch[i].size(); j++) res += calc_d0(ch[i][j], 1);
} else {
res = 2000000000;
for (int q = 0; q < ch[i].size(); q++) {
int cnt = calc_d1(ch[i][q], r - 1) + cost[r];
for (int j = 0; j < ch[i].size(); j++)
if (j != q) cnt += calc_d0(ch[i][j], r + 1);
if (cnt < res) {
res = cnt;
f = q;
}
}
}
}
return d1[i][r];
}
int cities[200];
int restore_d1(int, int);
void restore_d0(int i, int l, int top_city) {
int f = f0[i][l];
int q = q0[i][l];
if (f == -1) {
cities[i] = i;
for (int j = 0; j < ch[i].size(); j++) restore_d0(ch[i][j], 1, i);
} else if (f == -2) {
cities[i] = top_city;
for (int j = 0; j < ch[i].size(); j++)
restore_d0(ch[i][j], l + 1, top_city);
} else {
cities[i] = restore_d1(ch[i][q], f - 1);
for (int j = 0; j < ch[i].size(); j++)
if (j != q) restore_d0(ch[i][j], f + 1, cities[i]);
}
}
int restore_d1(int i, int r) {
int q = -1;
if (r == 0) {
cities[i] = i;
} else {
q = f1[i][r];
cities[i] = restore_d1(ch[i][q], r - 1);
}
for (int j = 0; j < ch[i].size(); j++)
if (j != q) restore_d0(ch[i][j], r + 1, cities[i]);
return cities[i];
}
int main() {
cin >> n >> cost[0];
for (int i = 1; i <= n - 1; i++) cin >> cost[i];
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
con[a].push_back(b);
con[b].push_back(a);
}
build_tree(0);
memset(d0, -1, sizeof(d0));
memset(d1, -1, sizeof(d1));
cout << calc_d0(0, n) << endl;
restore_d0(0, n, -1);
for (int i = 0; i < n; i++) cout << cities[i] + 1 << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long double EPS = 1e-6;
const int N = 220;
int w[N];
int n, k;
vector<int> g[N];
int d[N][N];
int dp[N][N];
int best[N];
void DP(int u, int f) {
for (int i = 1; i <= (int)n; i++) dp[i][u] = w[d[i][u]] + k;
for (auto v : g[u])
if (v != f) {
DP(v, u);
for (int i = 1; i <= (int)n; i++)
dp[i][u] += min(dp[best[v]][v], dp[i][v] - k);
}
best[u] = 1;
for (int i = 1; i <= (int)n; i++)
if (dp[i][u] <= dp[best[u]][u]) best[u] = i;
}
int ans[N];
void print(int u, int f, int i) {
for (auto v : g[u])
if (v != f) {
if (dp[best[v]][v] > dp[i][v] - k)
ans[v] = i;
else
ans[v] = best[v];
print(v, u, ans[v]);
}
}
void solve() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= (int)n - 1; i++) cin >> w[i];
memset(d, INF, sizeof(d));
for (int i = 1; i <= (int)n; i++) d[i][i] = 0;
for (int i = 1; i <= (int)n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
d[u][v] = d[v][u] = 1;
}
for (int k = 1; k <= (int)n; k++)
for (int i = 1; i <= (int)n; i++)
for (int j = 1; j <= (int)n; j++)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
DP(1, 0);
cout << dp[best[1]][1] << endl;
ans[1] = best[1];
print(1, 0, ans[1]);
for (int i = 1; i <= (int)n; i++) cout << ans[i] << ' ';
cout << endl;
}
signed main() {
int T = 1;
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, maxn = 185;
int n, K, d[maxn], dis[maxn][maxn], m[maxn][maxn], dp[maxn][maxn], ans[maxn],
path[maxn];
void dfs(int u, int fa) {
for (int i = 1; i <= n; i++) dp[u][i] = d[dis[u][i]] + K;
for (int v = 1; v <= n; v++)
if (m[u][v] && v != fa) {
dfs(v, u);
for (int i = 1; i <= n; i++) dp[u][i] += min(dp[v][ans[v]], dp[v][i] - K);
}
ans[u] = 1;
for (int i = 2; i <= n; i++)
if (dp[u][i] < dp[u][ans[u]]) ans[u] = i;
}
void output(int u, int fa, int i) {
path[u] = i;
for (int v = 1; v <= n; v++)
if (m[u][v] && v != fa) {
if (dp[v][ans[v]] < dp[v][i] - K)
output(v, u, ans[v]);
else
output(v, u, i);
}
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j)
dis[i][j] = INF;
else
dis[i][j] = 0;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
m[u][v] = m[v][u] = 1;
dis[u][v] = dis[v][u] = 1;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(1, 0);
printf("%d\n", dp[1][ans[1]]);
output(1, 0, ans[1]);
for (int i = 1; i <= n; i++) printf("%d%c", path[i], i == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int f[220][220], ans[220], d[220];
int dis[220][220], q[220];
int num, first[220], nxt[220 * 2], to[220 * 2];
void add(int a, int b) {
nxt[++num] = first[a];
to[num] = b;
first[a] = num;
dis[a][b] = 1;
}
void Floyd() {
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
void dfs(int u, int fa) {
for (int i = 1; i <= n; i++) f[i][u] = d[dis[i][u]] + k;
for (int i = first[u], v; i; i = nxt[i]) {
v = to[i];
if (v == fa) continue;
dfs(v, u);
for (int j = 1; j <= n; j++) f[j][u] += min(f[q[v]][v], f[j][v] - k);
}
q[u] = 1;
for (int i = 2; i <= n; i++)
if (f[i][u] < f[q[u]][u]) q[u] = i;
}
void find_ans(int u, int fa, int last) {
for (int i = first[u], v; i; i = nxt[i]) {
v = to[i];
if (v == fa) continue;
ans[v] = (f[q[v]][v] > f[last][v] - k ? last : q[v]);
find_ans(v, u, ans[v]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
int a, b;
memset(dis, 63, sizeof(dis));
memset(f, 63, sizeof(f));
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
add(a, b);
add(b, a);
}
Floyd();
dfs(1, 0);
ans[1] = q[1];
printf("%d\n", f[q[1]][1]);
find_ans(1, 0, ans[1]);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 200;
int opt[N], dp[N][N];
int dis[N][N];
std::vector<int> edge[N];
int k, n, cost[N], control[N];
void dfs(int u, int f) {
std::vector<int> chd;
for (int i = 0; i < (int)edge[u].size(); i++) {
int v = edge[u][i];
if (v == f) continue;
dfs(v, u);
chd.push_back(v);
}
for (int w = 0; w < n; w++) {
dp[u][w] = cost[dis[u][w]];
for (int i = 0; i < (int)chd.size(); i++) {
int v = chd[i];
dp[u][w] += std::min(dp[v][w], opt[v]);
}
}
opt[u] = 1000000000;
for (int w = 0; w < n; w++) {
if (dp[u][w] + k < opt[u]) {
opt[u] = dp[u][w] + k;
control[u] = w;
}
}
}
int ans[N];
void print(int u, int f, int w) {
int nw = -1;
if (dp[u][w] < opt[u]) {
nw = w;
} else {
nw = control[u];
}
ans[u] = nw;
for (int i = 0; i < (int)edge[u].size(); i++) {
if (edge[u][i] != f) {
print(edge[u][i], u, nw);
}
}
}
int main() {
int a, b;
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", &cost[i]);
for (int i = 0; i < n; i++) {
dis[i][i] = 0;
for (int j = i + 1; j < n; j++) {
dis[i][j] = dis[j][i] = 10000000;
}
}
for (int i = 1, a, b; i < n; i++) {
scanf("%d%d", &a, &b);
a--;
b--;
edge[a].push_back(b);
edge[b].push_back(a);
dis[a][b] = dis[b][a] = 1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
dis[j][k] = std::min(dis[j][k], dis[j][i] + dis[i][k]);
}
}
}
dfs(0, -1);
printf("%d\n", opt[0]);
int w;
for (w = 0; w < n; w++)
if (dp[0][w] + k == opt[0]) break;
print(0, -1, w);
for (int i = 0; i < n; i++) printf("%d ", ans[i] + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, tmp, nw, id[185], w[185], in[185][185], pin[185][185], ax[185][185],
f[185][185][2], head[185];
struct edge {
int v, nxt, p[185][2];
} e[185 * 2];
void dfs(int, int);
void find(int, int, int, int);
void adde(int, int);
int main() {
int i, u, v, ans = 1000000000, ps;
scanf("%d %d", &n, &nw);
for (i = 1; i < n; ++i) scanf("%d", &w[i]);
for (i = 1; i < n; ++i) {
scanf("%d %d", &u, &v);
adde(u, v);
adde(v, u);
}
memset(in, 0x3f, sizeof(in));
dfs(1, 0);
for (i = 0; i < n; ++i)
if (ans > f[1][i][0]) {
ans = f[1][i][0];
ps = i;
}
find(1, 0, ps, 0);
printf("%d\n", ans);
for (i = 1; i <= n; ++i) printf("%d ", id[i]);
return 0;
}
void dfs(int u, int fa) {
int i, d, v, ww;
for (i = head[u]; i; i = e[i].nxt)
if ((v = e[i].v) != fa) {
dfs(v, u);
f[u][0][0] += (ww = min(f[v][1][1], f[v][0][0]));
if (f[v][1][1] == ww)
e[i].p[0][0] = 3;
else if (f[v][0][0] == ww)
e[i].p[0][0] = 0;
for (d = 1; d < n; ++d) {
ww = min(f[v][d + 1][1], min(f[v][d][0], f[v][d - 1][0]));
f[u][d][0] += ww;
f[u][d][1] += ww;
if (ww == f[v][d + 1][1])
e[i].p[d][0] = e[i].p[d][1] = (d + 1) * 2 + 1;
else if (ww == f[v][d][0])
e[i].p[d][0] = e[i].p[d][1] = d * 2;
else
e[i].p[d][0] = e[i].p[d][1] = (d - 1) * 2;
if (in[u][d] > f[v][d - 1][0] - ww) {
in[u][d] = f[v][d - 1][0] - ww;
pin[u][d] = i;
}
}
}
f[u][0][0] += nw;
for (d = 1; d < n; ++d) {
f[u][d][0] += in[u][d] + w[d];
f[u][d][1] += w[d];
e[pin[u][d]].p[d][0] = 2 * (d - 1);
}
}
void find(int u, int fa, int d, int fl) {
int i, v;
if (!fl && !d)
id[u] = u;
else if (fl)
id[u] = id[fa];
for (i = head[u]; i; i = e[i].nxt)
if ((v = e[i].v) != fa)
if (!(e[i].p[d][fl] & 1)) {
find(v, u, e[i].p[d][fl] / 2, e[i].p[d][fl] % 2);
if (!fl && d == e[i].p[d][fl] / 2 + 1) id[u] = id[v];
}
for (i = head[u]; i; i = e[i].nxt)
if ((v = e[i].v) != fa)
if (e[i].p[d][fl] & 1) find(v, u, e[i].p[d][fl] / 2, e[i].p[d][fl] % 2);
}
void adde(int u, int v) {
e[++tmp].v = v;
e[tmp].nxt = head[u];
head[u] = tmp;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
pair<int, int> Time[1003];
vector<int> edge[1003];
int d[207][207];
int f[207][207], where[207], belong[207][207];
int W[1003], N, K, totalTime;
void surf(int u, int Fa) {
Time[u].first = totalTime++;
for (typeof(edge[u].begin()) it = edge[u].begin(); it != edge[u].end(); it++)
if (*it != Fa) surf(*it, u);
Time[u].second = totalTime;
}
queue<int> q;
void dist(int u, int d[]) {
while (!q.empty()) q.pop();
q.push(u);
for (int i = 0; i < N; i++) d[i] = 0x7f7f7f7f;
d[u] = 0;
while (!q.empty()) {
int now = q.front();
q.pop();
for (typeof(edge[now].begin()) it = edge[now].begin();
it != edge[now].end(); it++)
if (d[*it] > d[now] + 1) {
d[*it] = d[now] + 1;
q.push(*it);
}
}
}
void calc(int u, int Fa) {
if (edge[u].size() == 1 && Fa != -1) {
for (int i = 0; i < N; i++) f[u][i] = W[d[u][i]];
return;
}
for (typeof(edge[u].begin()) it = edge[u].begin(); it != edge[u].end(); it++)
if (*it != Fa) calc(*it, u);
for (int i = 0; i < N; i++) {
int partsum = W[d[u][i]];
if (i != u && Time[i].first >= Time[u].first &&
Time[i].second <= Time[u].second) {
for (typeof(edge[u].begin()) it = edge[u].begin(); it != edge[u].end();
it++) {
if (*it == Fa) continue;
int best = f[*it][i];
if (!(Time[*it].first <= Time[i].first &&
Time[*it].second >= Time[i].second))
for (int j = 0; j < N; j++)
if (Time[*it].first <= Time[j].first &&
Time[*it].second >= Time[j].second)
best = min(best, f[*it][j]);
partsum += best;
}
} else {
for (typeof(edge[u].begin()) it = edge[u].begin(); it != edge[u].end();
it++) {
if (*it == Fa) continue;
int best = f[*it][i];
for (int j = 0; j < N; j++)
if (Time[*it].first <= Time[j].first &&
Time[*it].second >= Time[j].second)
best = min(best, f[*it][j]);
partsum += best;
}
}
f[u][i] = partsum;
}
}
void output(int u, int pick, int Fa) {
where[u] = pick;
if (edge[u].size() == 1 && Fa != -1) return;
int i = pick;
{
int partsum = W[d[u][i]];
if (i != u && Time[i].first >= Time[u].first &&
Time[i].second <= Time[u].second) {
for (typeof(edge[u].begin()) it = edge[u].begin(); it != edge[u].end();
it++) {
if (*it == Fa) continue;
int best = f[*it][i];
int wherebest = i;
if (!(Time[*it].first <= Time[i].first &&
Time[*it].second >= Time[i].second))
for (int j = 0; j < N; j++)
if (Time[*it].first <= Time[j].first &&
Time[*it].second >= Time[j].second) {
if (f[*it][j] < best) wherebest = j;
best = min(best, f[*it][j]);
}
partsum += best;
output(*it, wherebest, u);
}
} else {
for (typeof(edge[u].begin()) it = edge[u].begin(); it != edge[u].end();
it++) {
if (*it == Fa) continue;
int best = f[*it][i];
int wherebest = i;
for (int j = 0; j < N; j++)
if (Time[*it].first <= Time[j].first &&
Time[*it].second >= Time[j].second) {
if (f[*it][j] < best) wherebest = j;
best = min(best, f[*it][j]);
}
partsum += best;
output(*it, wherebest, u);
}
}
}
}
int main() {
cin >> N >> K;
W[0] = K;
for (int i = 0; i < N - 1; i++) cin >> W[i + 1];
for (int i = 0; i < N - 1; i++) {
int a, b;
cin >> a >> b;
--a, --b;
edge[a].push_back(b);
edge[b].push_back(a);
}
for (int i = 0; i < N; i++) dist(i, d[i]);
totalTime = 0;
surf(0, -1);
calc(0, -1);
int ans = 0x7f7f7f7f;
int whereisit = 0;
for (int i = 0; i < N; i++) {
if (f[0][i] < ans) whereisit = i;
ans = min(ans, f[0][i]);
}
cout << ans << endl;
output(0, whereisit, -1);
for (int i = 0; i < N; i++) {
if (i) cout << " ";
cout << where[i] + 1;
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int k, dis[185][185];
int n, a[185];
int dp[185][185];
int mini[185], lst[185], co[185][185], fa[185];
bool vis[185];
vector<int> v[185];
void dfs(int p, int start) {
for (auto u : v[p])
if (!vis[u]) {
vis[u] = 1;
dis[start][u] = dis[start][p] + 1;
dfs(u, start);
}
}
void get(int x) {
for (auto u : v[x])
if (u != fa[x]) {
fa[u] = x;
get(u);
}
mini[x] = 1e9;
for (int to = 1; to <= n; to++) {
dp[x][to] = a[dis[to][x]] + k;
for (auto u : v[x])
if (u != fa[x]) {
if (mini[u] < dp[u][to] - k) {
co[to][u] = lst[u];
dp[x][to] += mini[u];
} else {
co[to][u] = to;
dp[x][to] += dp[u][to] - k;
}
}
if (mini[x] > dp[x][to]) {
mini[x] = dp[x][to];
lst[x] = to;
}
}
}
int pr[185];
void getpr(int x, int now) {
pr[x] = now;
for (auto u : v[x])
if (u != fa[x]) {
getpr(u, co[now][u]);
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i < n; i++) cin >> a[i];
int x, y;
for (int i = 1; i < n; i++) {
cin >> x >> y;
v[x].emplace_back(y);
v[y].emplace_back(x);
}
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof(vis));
vis[i] = 1;
dfs(i, i);
}
get(1);
int ans = 1;
for (int i = 2; i <= n; i++) {
if (dp[1][i] < dp[1][ans]) ans = i;
}
cout << dp[1][ans] << '\n';
getpr(1, ans);
for (int i = 1; i <= n; i++) cout << pr[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const int Max = 256;
const int MaxE = Max * 2;
struct edge {
int to;
edge *s;
};
edge E[MaxE], *hd[Max], *cp;
int n, k, D[Max];
int mp[Max][Max];
int F[Max][Max];
int A[Max], R[Max];
void addEdge(int x, int y) { cp->to = y, cp->s = hd[x], hd[x] = cp++; }
inline void update(int &r, int d) {
if (d < r) r = d;
}
void dfs(int x, int f) {
for (edge *p = hd[x]; p; p = p->s)
if (p->to != f) dfs(p->to, x);
for (int i = 1; i <= n; i++) {
int &cr = F[x][i] = 0;
int dx = mp[x][i];
for (edge *p = hd[x]; p; p = p->s)
if (p->to != f) {
int y = p->to;
cr += dx < mp[y][i] ? min(R[y], F[y][i]) : F[y][i];
}
cr += D[dx];
if (x == i) cr += k;
if (dx < mp[f][i]) update(R[x], cr);
}
}
void aDfs(int x, int f, int g) {
if (g == 0) {
for (int i = 1; i <= n; i++)
if (mp[x][i] < mp[f][i] && F[x][i] == R[x]) {
aDfs(x, f, i);
return;
}
}
A[x] = g;
for (edge *p = hd[x]; p; p = p->s)
if (p->to != f) {
int y = p->to;
aDfs(y, x, mp[x][g] < mp[y][g] && R[y] < F[y][g] ? 0 : g);
}
}
int main() {
while (scanf("%d%d", &n, &k) != EOF && n) {
for (int i = 1; i < n; i++) scanf("%d", &D[i]);
D[n] = oo;
memset(hd, 0, sizeof(hd));
memset(mp, 0x3f, sizeof(mp));
cp = E;
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
mp[x][y] = mp[y][x] = 1;
addEdge(x, y);
addEdge(y, x);
}
for (int z = 1; z <= n; z++)
for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++) update(mp[x][y], mp[x][z] + mp[z][y]);
for (int x = 1; x <= n; x++) mp[x][x] = 0;
memset(R, 0x3f, sizeof(R));
dfs(1, 0);
printf("%d\n", R[1]);
aDfs(1, 0, 0);
for (int i = 1; i <= n; i++) printf("%d%c", A[i], i == n ? '\n' : ' ');
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INFLL = 0x3f3f3f3f3f3f3f3fLL;
const int MAXN = 180;
struct et {
int t;
et* n;
et() {}
et(int _t, et* _n) : t(_t), n(_n) {}
} * e[MAXN + 10], store[MAXN * 2 + 10], *loc = store;
int n, k;
int fa[MAXN + 10];
int d[MAXN + 10];
void build(int x) {
for (et* i = e[x]; i; i = i->n)
if (i->t != fa[x]) {
fa[i->t] = x;
build(i->t);
}
}
long long f[MAXN + 10][MAXN + 10];
int choose[MAXN + 10];
void fun(int x) {
for (et* i = e[x]; i; i = i->n)
if (i->t != fa[x]) fun(i->t);
f[x][0] = INFLL;
for (int i = 1; i <= n; i++) {
int p = i;
while (p && p != x) p = fa[p];
if (!p) continue;
int dist = 0, prev = -1;
long long tmp = 0;
for (p = i; p != fa[x]; p = fa[p]) {
tmp += !dist ? k : d[dist];
for (et* j = e[p]; j; j = j->n)
if (j->t != fa[p] && j->t != prev) tmp += f[j->t][min(dist + 1, n - 1)];
prev = p;
dist++;
}
if (tmp < f[x][0]) {
choose[x] = i;
f[x][0] = tmp;
}
}
for (int i = 1; i < n; i++) {
long long tmp = d[i];
for (et* j = e[x]; j; j = j->n)
if (j->t != fa[x]) tmp += f[j->t][i + 1];
f[x][i] = min(f[x][0], tmp);
}
}
int ans[MAXN + 10];
void findAns(int x, int dist, int center) {
if (f[x][dist] == f[x][0]) {
int dst = 0, prev = -1;
for (int i = choose[x]; i != fa[x]; i = fa[i]) {
ans[i] = choose[x];
for (et* j = e[i]; j; j = j->n)
if (j->t != fa[i] && j->t != prev)
findAns(j->t, min(dst + 1, n - 1), choose[x]);
prev = i;
dst++;
}
} else {
ans[x] = center;
for (et* i = e[x]; i; i = i->n)
if (i->t != fa[x]) findAns(i->t, dist + 1, center);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
e[x] = new (loc++) et(y, e[x]);
e[y] = new (loc++) et(x, e[y]);
}
build(1);
fun(1);
cout << f[1][0] << endl;
findAns(1, 0, -1);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[200][200];
int d[200];
int dis[200][200], c[200];
int n, k;
void input() {
int x, y;
memset(dis, 255, sizeof(dis));
for (int i = 1; i < n; i++) scanf("%d", d + i);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
x--;
y--;
if (x == y) continue;
dis[x][y] = dis[y][x] = 1;
}
}
void floyd() {
for (int i = 0; i < n; i++) dis[i][i] = 0;
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
if (i != k && dis[i][k] != -1)
for (int j = 0; j < n; j++)
if (j != i && j != k && dis[k][j] != -1) {
if (dis[i][k] + dis[k][j] < dis[i][j] || dis[i][j] == -1)
dis[i][j] = dis[i][k] + dis[k][j];
}
}
void dfs(int x, int fa) {
vector<int> cand;
for (int i = 0; i < n; i++)
if (dis[x][i] == 1 && i != fa) {
cand.push_back(i);
dfs(i, x);
}
c[x] = 0;
for (int i = 0; i < n; i++) {
dp[x][i] = d[dis[x][i]];
for (int j = 0; j < cand.size(); j++) {
int v = cand[j];
dp[x][i] += min(dp[v][i], dp[v][c[v]] + k);
}
if (dp[x][i] < dp[x][c[x]]) c[x] = i;
}
}
void dfs2(int x, int fa) {
for (int i = 0; i < n; i++)
if (dis[x][i] == 1 && i != fa) {
if (dp[i][c[x]] < dp[i][c[i]] + k) c[i] = c[x];
dfs2(i, x);
}
}
void output() {
printf("%d\n", dp[0][c[0]] + k);
for (int i = 0; i < n; i++) printf("%d%c", c[i] + 1, i == n - 1 ? '\n' : ' ');
}
int main() {
while (scanf("%d%d", &n, &k) != EOF) {
input();
floyd();
dfs(0, -1);
dfs2(0, -1);
output();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int sz = 1 << 15;
char inbuf[sz], outbuf[sz];
char *pinbuf = inbuf + sz;
char *poutbuf = outbuf;
inline char _getchar() {
if (pinbuf == inbuf + sz) fread(inbuf, 1, sz, stdin), pinbuf = inbuf;
return *(pinbuf++);
}
inline void _putchar(char x) {
if (poutbuf == outbuf + sz) fwrite(outbuf, 1, sz, stdout), poutbuf = outbuf;
*(poutbuf++) = x;
}
inline void flush() {
if (poutbuf != outbuf)
fwrite(outbuf, 1, poutbuf - outbuf, stdout), poutbuf = outbuf;
}
} // namespace IO
inline int read() {
int x = 0, p = 1;
char c = IO::_getchar();
while (c < '0' || c > '9') {
if (c == '-') p = -1;
c = IO::_getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = IO::_getchar();
return x * p;
}
namespace Mymath {
long long qp(long long x, long long p, long long mod) {
long long ans = 1;
while (p) {
if (p & 1) ans = ans * x % mod;
x = x * x % mod;
p >>= 1;
}
return ans;
}
long long inv(long long x, long long mod) { return qp(x, mod - 2, mod); }
long long C(long long N, long long K, long long fact[], long long mod) {
return fact[N] * inv(fact[K], mod) % mod * inv(fact[N - K], mod) % mod;
}
template <typename Tp>
Tp gcd(Tp A, Tp B) {
if (B == 0) return A;
return gcd(B, A % B);
}
template <typename Tp>
Tp lcm(Tp A, Tp B) {
return A * B / gcd(A, B);
}
}; // namespace Mymath
namespace fwt {
using namespace Mymath;
void FWT(int a[], int n, long long mod) {
for (int d = 1; d < n; d <<= 1)
for (int m = d << 1, i = 0; i < n; i += m)
for (int j = 0; j < d; j++) {
int x = a[i + j], y = a[i + j + d];
a[i + j] = (x + y) % mod, a[i + j + d] = (x - y + mod) % mod;
}
}
void UFWT(int a[], int n, long long mod) {
long long rev = inv(2, mod);
for (int d = 1; d < n; d <<= 1)
for (int m = d << 1, i = 0; i < n; i += m)
for (int j = 0; j < d; j++) {
int x = a[i + j], y = a[i + j + d];
a[i + j] = 1LL * (x + y) * rev % mod,
a[i + j + d] = (1LL * (x - y) * rev % mod + mod) % mod;
}
}
void solve(int a[], int b[], int n, long long mod) {
FWT(a, n, mod);
FWT(b, n, mod);
for (int i = 0; i < n; i++) a[i] = 1LL * a[i] * b[i] % mod;
UFWT(a, n, mod);
}
}; // namespace fwt
namespace Maxflow {
const int Maxn = 1005;
struct edge {
int to, rev, cap;
edge(int _to, int _rev, int _cap) { to = _to, rev = _rev, cap = _cap; }
};
int src = 1002, snk = 1003;
vector<edge> G[Maxn];
int dist[Maxn], seen[Maxn];
int n;
void Clear() {
for (int i = 0; i < Maxn; i++) G[i].clear();
}
void bfs(int s) {
for (int i = 0; i < Maxn; i++) dist[i] = -1;
dist[s] = 0;
queue<int> Q;
Q.push(s);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (int i = 0; i < G[x].size(); i++) {
edge &e = G[x][i];
if (e.cap && dist[e.to] == -1) {
dist[e.to] = dist[x] + 1;
Q.push(e.to);
}
}
}
}
int dfs(int now, int dest, int fl) {
if (now == dest) return fl;
for (int &i = seen[now]; i < G[now].size(); i++) {
edge &ed = G[now][i];
if (ed.cap && dist[ed.to] == dist[now] + 1) {
int f = dfs(ed.to, dest, min(fl, ed.cap));
if (f) {
ed.cap -= f;
G[ed.to][ed.rev].cap += f;
return f;
}
}
}
return 0;
}
int dinic(int s = src, int t = snk) {
int ret = 0;
while (1) {
memset(seen, 0, sizeof(seen));
bfs(s);
if (dist[t] == -1) return ret;
int f = dfs(s, t, 2147483647);
while (f) {
ret += f;
f = dfs(s, t, 2147483647);
}
}
}
}; // namespace Maxflow
namespace Geometry {
struct iP {
long long x, y;
iP(long long _x, long long _y) { x = _x, y = _y; }
iP() { x = y = 0; }
iP operator+(iP p) { return iP(x + p.x, y + p.y); }
iP operator-(iP p) { return iP(x - p.x, y - p.y); }
iP operator*(long long k) { return iP(x * k, y * k); }
long long det(iP p) { return x * p.y - y * p.x; }
long long dot(iP p) { return x * p.x + y * p.y; }
long long dist() { return x * x + y * y; }
bool operator<(const iP &p) const {
if (x != p.x) return x < p.x;
return y < p.y;
}
};
struct dP {
double x, y;
dP(double _x, double _y) { x = _x, y = _y; }
dP() { x = y = 0.0; }
dP operator+(dP p) { return dP(x + p.x, y + p.y); }
dP operator-(dP p) { return dP(x - p.x, y - p.y); }
dP operator*(double k) { return dP(x * k, y * k); }
double det(dP p) { return x * p.y - y * p.x; }
double dot(dP p) { return x * p.x + y * p.y; }
double dist() { return x * x + y * y; }
bool operator<(const dP &p) const {
if (x != p.x) return x < p.x;
return y < p.y;
}
};
vector<iP> convex_hull(iP X[], int l) {
vector<iP> ret;
sort(X + 1, X + 1 + l);
ret.push_back(X[1]);
for (int i = 2; i <= l; i++) {
while (ret.size() >= 2 &&
(ret[ret.size() - 2] - X[i]).det(ret[ret.size() - 1] - X[i]) >= 0) {
ret.pop_back();
}
ret.push_back(X[i]);
}
int rs = ret.size() + 1;
for (int i = l - 1; i >= 1; i--) {
while (ret.size() >= rs &&
(ret[ret.size() - 2] - X[i]).det(ret[ret.size() - 1] - X[i]) >= 0) {
ret.pop_back();
}
ret.push_back(X[i]);
}
return ret;
}
}; // namespace Geometry
const int Maxn = 188;
int n, k;
int d[Maxn];
int par[Maxn];
vector<int> G[Maxn], son[Maxn], str[Maxn];
int dp[Maxn][Maxn];
int ans[Maxn];
int pre[Maxn][Maxn];
void pre_dfs(int x, int p) {
par[x] = p;
str[x].push_back(x);
for (int i = 0; i < G[x].size(); i++) {
int u = G[x][i];
if (u != p) {
son[x].push_back(u);
pre_dfs(u, x);
for (auto v : str[u]) {
str[x].push_back(v);
}
}
}
}
void dfs(int x) {
for (int i = 0; i < son[x].size(); i++) {
int v = son[x][i];
dfs(v);
}
dp[x][0] = 1e9;
for (auto v : str[x]) {
int cost = 0, di = 0;
int u = v, prev = -1;
for (; u != par[x]; prev = u, u = par[u]) {
if (di == 0)
cost += k, di++;
else
cost += d[di++];
for (auto w : son[u]) {
if (w != prev) cost += dp[w][min(di, n - 1)];
}
}
if (cost < dp[x][0]) {
dp[x][0] = cost;
pre[x][0] = v;
}
}
for (int i = 1; i < n; i++) {
dp[x][i] = dp[x][0];
pre[x][i] = 0;
int tmp = d[i];
for (auto v : son[x]) {
tmp += dp[v][min(i + 1, n - 1)];
}
if (tmp < dp[x][i]) {
dp[x][i] = tmp;
pre[x][i] = 1;
}
}
}
void traverse(int x, int d, int c) {
if (d != 0 && pre[x][d] == 0) {
traverse(x, 0, -1);
return;
}
if (d != 0) {
ans[x] = c;
for (auto v : son[x]) {
traverse(v, d + 1, c);
}
return;
}
ans[x] = pre[x][0];
int v = pre[x][0], prev = -1, di = 0;
for (; v != par[x]; prev = v, v = par[v]) {
for (auto w : son[v]) {
if (w != prev) {
traverse(w, di + 1, pre[x][0]);
}
}
ans[v] = pre[x][0];
di++;
}
}
int main() {
n = read();
k = read();
for (int i = 1; i <= n - 1; i++) d[i] = read();
for (int i = 0; i < n - 1; i++) {
int u = read(), v = read();
G[u].push_back(v);
G[v].push_back(u);
}
pre_dfs(1, -1);
dfs(1);
printf("%d\n", dp[1][0]);
traverse(1, 0, -1);
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 205;
const int inf = 0x3f3f3f3f;
int n, k, d[maxn], dis[maxn][maxn], dp[maxn][maxn], mn[maxn],
col[maxn * 2][maxn], ans[maxn];
int head[maxn], ecnt;
struct edge {
int to, next;
} e[maxn << 1];
void adde(int u, int v) {
e[++ecnt].to = v;
e[ecnt].next = head[u];
head[u] = ecnt;
}
int read() {
int res = 0, f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (!isdigit(ch));
do {
res = res * 10 + ch - '0';
ch = getchar();
} while (isdigit(ch));
return res * f;
}
void dfs(int u, int fa) {
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == fa) continue;
dfs(v, u);
}
for (int j = (1); j <= (n); ++j) {
dp[u][j] = d[dis[u][j]] + k;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == fa) continue;
int x = dp[v][mn[v]];
if (x > dp[v][j] - k) {
x = dp[v][j] - k;
col[i][j] = j;
} else
col[i][j] = mn[v];
dp[u][j] += x;
}
if (!mn[u] || dp[u][mn[u]] > dp[u][j]) mn[u] = j;
}
}
void dfs1(int u, int fa, int co) {
ans[u] = co;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == fa) continue;
dfs1(v, u, col[i][co]);
}
}
signed main() {
n = read();
k = read();
memset(dis, 0x3f3f3f3f, sizeof(dis));
for (int i = (1); i <= (n - 1); ++i) d[i] = read();
for (int i = (1); i <= (n - 1); ++i) {
int u = read(), v = read();
adde(u, v);
adde(v, u);
dis[u][v] = dis[v][u] = 1;
}
for (int i = (1); i <= (n); ++i) dis[i][i] = 0, ans[i] = i;
for (int k = (1); k <= (n); ++k)
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(1, 0);
dfs1(1, 0, mn[1]);
printf("%d\n", dp[1][mn[1]]);
for (int i = (1); i <= (n); ++i) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int d[200][200];
int a[200];
int dp[200][200];
int best[200];
int from[200];
vector<int> adia[200];
int n, k;
void calc_from(int nod, int tata, int centru) {
from[nod] = centru;
for (auto i : adia[nod]) {
if (i == tata) continue;
if (dp[i][best[i]] < dp[i][centru] - k)
calc_from(i, nod, best[i]);
else
calc_from(i, nod, centru);
}
}
void calc_dp(int nod, int tata) {
for (int i(1); i <= n; i++) dp[nod][i] = k + a[d[nod][i]];
for (auto i : adia[nod]) {
if (i != tata) {
calc_dp(i, nod);
for (int j(1); j <= n; j++)
dp[nod][j] += min(dp[i][best[i]], dp[i][j] - k);
}
}
best[nod] = nod;
for (int i(1); i <= n; i++)
if (dp[nod][i] < dp[nod][best[nod]]) best[nod] = i;
}
int main() {
cin >> n >> k;
for (int i(1); i < n; i++) cin >> a[i];
for (int i(1); i <= n; i++)
for (int j(1); j <= n; j++) d[i][j] = (i != j ? 1e9 : 0);
int a, b;
for (int i(1); i < n; i++) {
cin >> a >> b;
adia[a].push_back(b);
adia[b].push_back(a);
d[a][b] = d[b][a] = 1;
}
for (int k(1); k <= n; k++)
for (int i(1); i <= n; i++)
for (int j(1); j <= n; j++)
if (d[i][k] + d[k][j] < d[i][j]) d[i][j] = d[i][k] + d[k][j];
calc_dp(1, 0);
calc_from(1, 0, best[1]);
cout << dp[1][best[1]] << '\n';
for (int i(1); i <= n; i++) cout << from[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d[180], K, dep[181], f[181][180], g[181][180], minf[181], ans[181],
gsiz[181];
vector<int> mp[181];
void calcdep(int k, int p, int curd) {
dep[k] = curd;
for (auto c : mp[k])
if (c != p) {
calcdep(c, k, curd + 1);
dep[k] = max(dep[k], dep[c]);
}
}
void dfs(int k, int p, int curd) {
int mxd = gsiz[k];
for (auto c : mp[k])
if (c != p) {
gsiz[c] = max(gsiz[c], mxd);
mxd = max(mxd, dep[c] - curd);
}
mxd = gsiz[k];
for (int i = mp[k].size() - 1; i >= 0; --i)
if (mp[k][i] != p) {
gsiz[mp[k][i]] = max(gsiz[mp[k][i]], mxd);
mxd = max(mxd, dep[mp[k][i]] - curd);
}
f[k][0] = K;
for (auto c : mp[k])
if (c != p) {
++gsiz[c];
dfs(c, k, curd + 1);
f[k][0] += min(g[c][1], minf[c]);
}
for (int i = 1; i <= dep[k] - curd; ++i) {
int tot = 0;
for (auto c : mp[k])
if (c != p) tot += min(minf[c], g[c][i + 1]);
f[k][i] = 1000000000;
for (auto c : mp[k])
if (c != p && dep[c] - curd >= i)
f[k][i] = min(f[k][i], tot - min(minf[c], g[c][i + 1]) + f[c][i - 1]);
f[k][i] += d[i];
}
for (int i = 1; i <= gsiz[k]; ++i) {
g[k][i] = d[i];
for (auto c : mp[k])
if (c != p) g[k][i] += min(g[c][i + 1], minf[c]);
}
minf[k] = 1000000000;
for (int i = 0; i <= dep[k] - curd; ++i) minf[k] = min(minf[k], f[k][i]);
}
void fprint(int k, int p, int curd, int fidx);
void gprint(int k, int p, int curd, int gidx) {
ans[k] = ans[p];
for (auto c : mp[k])
if (c != p)
g[c][gidx + 1] < minf[c] ? gprint(c, k, curd + 1, gidx + 1)
: fprint(c, k, curd + 1, -1);
}
void fprint(int k, int p, int curd, int fidx) {
if (!fidx || (fidx == -1 && minf[k] == f[k][0])) {
ans[k] = k;
for (auto c : mp[k])
if (c != p)
g[c][1] < minf[c] ? gprint(c, k, curd + 1, 1)
: fprint(c, k, curd + 1, -1);
} else {
if (fidx == -1) {
fidx = 1;
while (f[k][fidx] != minf[k]) ++fidx;
}
int tot = d[fidx];
for (auto c : mp[k])
if (c != p) tot += min(minf[c], g[c][fidx + 1]);
int mxv;
for (auto c : mp[k])
if (c != p && dep[c] - curd >= fidx &&
tot - min(minf[c], g[c][fidx + 1]) + f[c][fidx - 1] == f[k][fidx]) {
mxv = c;
break;
}
fprint(mxv, k, curd + 1, fidx - 1);
ans[k] = ans[mxv];
for (auto c : mp[k])
if (c != p && c != mxv)
g[c][fidx + 1] < minf[c] ? gprint(c, k, curd + 1, fidx + 1)
: fprint(c, k, curd + 1, -1);
}
}
int main() {
int n;
scanf("%d%d", &n, &K);
for (int i = 1; i < n; ++i) scanf("%d", d + i);
for (int i = 1; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
mp[a].push_back(b);
mp[b].push_back(a);
}
calcdep(1, 0, 0);
dfs(1, 0, 0);
printf("%d\n", minf[1]);
fprint(1, 0, 0, -1);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
bool vst[1000];
int n, center[1000], cost, head[1000], next[1000], to[1000], f[1000][1000],
d[1000], dist[1000][1000];
void work(int u) {
int i, v;
vst[u] = true;
for (v = 1; v <= n; v++) f[u][v] = d[dist[u][v]];
for (i = head[u]; i; i = next[i]) {
v = to[i];
if (vst[v]) continue;
work(v);
for (int g = 1; g <= n; g++) {
int min = f[v][g];
for (int q = 1; q <= n; q++) min = std::min(min, f[v][q] + cost);
f[u][g] += min;
}
}
}
void find(int u) {
int c, i, v, g;
vst[u] = true;
for (i = head[u]; i; i = next[i]) {
int v = to[i];
if (vst[v]) continue;
int min = f[v][center[u]];
center[v] = center[u];
for (int g = 1; g <= n; g++)
if (f[v][g] + cost < min) {
min = f[v][g] + cost;
center[v] = g;
}
find(v);
}
}
int main() {
scanf("%d%d", &n, &cost);
int i, u, v;
for (i = 1; i < n; i++) scanf("%d", &d[i]);
for (int u = 1; u <= n; u++)
for (int v = 1; v <= n; v++) dist[u][v] = (u == v) ? 0 : 999999999;
for (i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
dist[u][v] = dist[v][u] = 1;
next[i] = head[u];
to[i] = v;
head[u] = i;
next[i + n] = head[v];
to[i + n] = u;
head[v] = i + n;
}
for (int i = 1; i <= n; i++)
for (u = 1; u <= n; u++)
for (v = 1; v <= n; v++)
dist[u][v] = std::min(dist[u][v], dist[u][i] + dist[i][v]);
work(1);
memset(vst, false, sizeof(vst));
for (center[1] = 1, u = 1; u <= n; u++)
if (f[1][u] < f[1][center[1]]) center[1] = u;
find(1);
printf("%d\n", f[1][center[1]] + cost);
for (u = 1; u <= n; u++) printf("%d ", center[u]);
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[185];
int n, nw, ne, w[185], q[185], d[185][185], p[185], id[185], f[185][185],
head[185];
struct edge {
int u, v, nxt;
} e[185 * 2];
void dfs(int, int);
void bfs(int, int*);
void adde(int, int);
void find(int, int, int);
int main() {
int i, u, v;
scanf("%d %d", &n, &nw);
for (i = 1; i < n; ++i) scanf("%d", &w[i]);
for (i = 1; i < n; ++i) {
scanf("%d %d", &u, &v);
adde(u, v);
adde(v, u);
}
for (i = 1; i <= n; ++i) bfs(i, d[i]);
dfs(1, 0);
find(1, p[1], 0);
printf("%d\n", f[1][p[1]]);
for (i = 1; i <= n; ++i) printf("%d ", id[i]);
return 0;
}
void dfs(int u, int fa) {
int i, j, v;
for (i = 1; i <= n; ++i) f[u][i] = nw + w[d[u][i]];
for (i = head[u]; i; i = e[i].nxt)
if ((v = e[i].v) != fa) {
dfs(v, u);
for (j = 1; j <= n; ++j) f[u][j] += min(f[v][p[v]], f[v][j] - nw);
}
p[u] = 1;
for (i = 2; i <= n; ++i)
if (f[u][p[u]] > f[u][i]) p[u] = i;
}
void find(int u, int j, int fa) {
int i, v;
id[u] = j;
for (i = head[u]; i; i = e[i].nxt)
if ((v = e[i].v) != fa) find(v, f[v][p[v]] < f[v][j] - nw ? p[v] : j, u);
}
void bfs(int v0, int* d) {
int i, u, v, hd, tl;
memset(vis, 0, sizeof(vis));
vis[q[hd = tl = 1] = v0] = 1;
while (hd <= tl)
for (i = head[u = q[hd++]]; i; i = e[i].nxt)
if (!vis[v = e[i].v]) d[v] = d[u] + (vis[q[++tl] = v] = 1);
}
void adde(int u, int v) {
e[++ne].v = v;
e[ne].nxt = head[u];
head[u] = ne;
}
|
#include <bits/stdc++.h>
int c[200];
int co[200][200];
int ma[200][200], mp[200];
int u[200];
int pr[200];
int di[200][200];
int dp[200][200];
int K, n;
void dfs(int x) {
int i;
for (i = 0; i < mp[x]; i++) {
if (!u[ma[x][i]]) {
u[ma[x][i]] = 1;
pr[ma[x][i]] = x;
dfs(ma[x][i]);
}
}
}
int calc(int x, int y) {
if (dp[x][y] != -1) return dp[x][y];
int i, j, z, d, md;
dp[x][y] = c[co[x][y]] + K;
for (i = 0; i < mp[x]; i++) {
if ((z = ma[x][i]) == pr[x]) continue;
md = 100000000;
for (j = 0; j < n; j++) {
d = calc(z, j);
if (j == y) d -= K;
if (d < md) md = d;
}
dp[x][y] += md;
}
return dp[x][y];
}
void fill(int x, int y) {
int i, j, z, md, d, mj;
u[x] = y;
for (i = 0; i < mp[x]; i++) {
if ((z = ma[x][i]) == pr[x]) continue;
md = 100000000;
for (j = 0; j < n; j++) {
d = calc(z, j);
if (j == y) d -= K;
if (d < md) {
md = d;
mj = j;
}
}
fill(z, mj);
}
}
int main() {
int i, j, k, x, y, z, md, mi;
scanf("%d %d", &n, &K);
for (i = 1; i < n; i++) {
scanf("%d", &c[i]);
}
c[0] = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
co[i][j] = 100000000;
}
co[i][i] = 0;
}
for (i = 1; i < n; i++) {
scanf("%d %d", &x, &y);
x--;
y--;
ma[x][mp[x]++] = y;
ma[y][mp[y]++] = x;
co[x][y] = co[y][x] = 1;
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < n; k++) {
if (co[j][i] + co[i][k] < co[j][k]) {
co[j][k] = co[j][i] + co[i][k];
}
}
}
}
u[0] = 1;
dfs(0);
pr[0] = -1;
md = 100000000;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
dp[i][j] = -1;
}
}
for (i = 0; i < n; i++) {
z = calc(0, i);
if (z < md) {
md = z;
mi = i;
}
}
fill(0, mi);
printf("%d\n", md);
for (i = 0; i < n; i++) {
printf("%d%c", u[i] + 1, i == n - 1 ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int d[181];
vector<int> adj[181];
int cost[181][181][181];
int sum_min_branch[181][181][181];
int single_min[181][181][181], get_min[181][181][181],
closest_branch[181][181][181];
int par[181] = {};
int deg[181] = {};
int depth[181] = {};
queue<int> q;
vector<int> center;
void init() {
int u, v;
scanf("%d %d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
d[0] = k;
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
deg[u]++;
deg[v]++;
}
deg[1]++;
for (int i = 1; i <= n; i++) {
if (deg[i] == 1) {
q.push(i);
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int ii = 0; ii <= n; ii++) {
sum_min_branch[i][j][ii] = 0;
single_min[i][j][ii] = 1 << 30;
closest_branch[i][j][ii] = -1;
}
}
}
}
void dfs(int v) {
for (int i = 0; i < adj[v].size(); i++) {
if (adj[v][i] == par[v]) continue;
par[adj[v][i]] = v;
dfs(adj[v][i]);
}
}
void depth_search() {
queue<int> q2;
int deg2[181], fr, ma;
for (int i = 1; i <= n; i++) {
deg2[i] = deg[i];
if (deg[i] == 1) q2.push(i);
}
while (!q2.empty()) {
fr = q2.front();
q2.pop();
deg2[par[fr]]--;
if (deg2[par[fr]] == 1) q2.push(par[fr]);
ma = -1;
for (int i = 0; i < adj[fr].size(); i++) {
if (par[fr] == adj[fr][i]) continue;
ma = max(ma, depth[adj[fr][i]]);
}
depth[fr] = ma + 1;
}
}
int single_update(int ver, int out, int in) {
int ans = 0, temp, mi = 1 << 30;
if ((in < n && in > depth[ver]) || (out < n && out > n - 1 - depth[ver]) ||
(in >= n && out >= n) || (!out && in))
return cost[ver][out][in] = 1 << 30;
if (in >= n) {
ans = d[out];
for (int i = 0; i < adj[ver].size(); i++) {
if (adj[ver][i] == par[ver]) continue;
ans += cost[adj[ver][i]][out + 1][in];
}
return cost[ver][out][in] = ans;
}
if (!in) {
return cost[ver][out][in] = k + sum_min_branch[ver][1][0];
}
if (out >= n) {
ans = d[in];
for (int i = 0; i < adj[ver].size(); i++) {
if (adj[ver][i] == par[ver]) continue;
if (depth[adj[ver][i]] < in - 1) continue;
temp = cost[adj[ver][i]][out][in - 1] -
single_min[adj[ver][i]][in + 1][in - 1] +
sum_min_branch[ver][in + 1][in - 1];
if (temp < mi) {
mi = temp;
closest_branch[ver][out][in] = adj[ver][i];
}
}
return cost[ver][out][in] = ans + mi;
}
ans = d[min(out, in)];
for (int i = 0; i < adj[ver].size(); i++) {
if (adj[ver][i] == par[ver]) continue;
if (depth[adj[ver][i]] < in - 1) continue;
temp = cost[adj[ver][i]][out + 1][in - 1] -
single_min[adj[ver][i]][min(out, in) + 1][in - 1] +
sum_min_branch[ver][min(out, in) + 1][in - 1];
if (temp < mi) {
mi = temp;
closest_branch[ver][out][in] = adj[ver][i];
}
}
return cost[ver][out][in] = ans + mi;
}
void solve(int v) {
for (int i = 0; i < adj[v].size(); i++) {
if (adj[v][i] == par[v]) continue;
for (int ii = 0; ii <= n; ii++) {
for (int j = 0; j <= n; j++) {
sum_min_branch[v][ii][j] += single_min[adj[v][i]][ii][j];
}
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
single_update(v, i, j);
}
}
for (int i = 0; i <= n; i++) {
single_min[v][i][n] = cost[v][i][n];
get_min[v][i][n] = n;
for (int j = n - 1; j >= 0; j--) {
if (cost[v][i][j] < single_min[v][i][j + 1]) {
get_min[v][i][j] = j;
single_min[v][i][j] = cost[v][i][j];
} else {
get_min[v][i][j] = get_min[v][i][j + 1];
single_min[v][i][j] = single_min[v][i][j + 1];
}
}
}
}
void find_center(int v, int out, int in) {
if (!in) center.push_back(v);
if (in == n) return;
if (!in) {
for (int i = 0; i < adj[v].size(); i++) {
if (adj[v][i] == par[v]) continue;
find_center(adj[v][i], 1, get_min[adj[v][i]][1][0]);
}
return;
}
find_center(closest_branch[v][out][in], min(out + 1, n), in - 1);
for (int i = 0; i < adj[v].size(); i++) {
if (adj[v][i] == par[v] || adj[v][i] == closest_branch[v][out][in])
continue;
find_center(adj[v][i], min(out, in) + 1,
get_min[adj[v][i]][min(out, in) + 1][in - 1]);
}
}
int dist[181][181];
int get_dist(int u, int v) {
if (u == v || dist[u][v]) return dist[u][v];
if (depth[u] <= depth[v])
return dist[u][v] = dist[v][u] = 1 + get_dist(par[u], v);
return dist[u][v] = dist[v][u] = 1 + get_dist(u, par[v]);
}
int main() {
int fr;
init();
dfs(1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dist[i][j] = 0;
}
}
depth_search();
while (!q.empty()) {
fr = q.front();
q.pop();
deg[par[fr]]--;
if (deg[par[fr]] == 1) q.push(par[fr]);
solve(fr);
}
int ans = cost[1][0][0];
int out = 0, in = 0;
for (int i = 0; i < n; i++) {
if (cost[1][n][i] < ans) {
ans = cost[1][n][i];
out = n;
in = i;
}
}
printf("%d\n", ans);
find_center(1, out, in);
int di, des;
for (int i = 1; i <= n; i++) {
di = 1 << 30;
des = 0;
for (int j = 0; j < center.size(); j++) {
if (di > get_dist(i, center[j])) {
di = get_dist(i, center[j]);
des = center[j];
}
}
printf("%d ", des);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int cost[188];
int dis[188][188];
int dp[188][188];
int sel[188];
vector<int> nei[188];
int chs[188];
void dfs(int now, int lst) {
for (int i = 1; i <= n; i++) {
dp[now][i] = cost[dis[now][i]] + m;
}
for (int i = 0; i < nei[now].size(); i++) {
int to = nei[now][i];
if (to == lst) {
continue;
}
dfs(to, now);
for (int j = 1; j <= n; j++) {
dp[now][j] += min(dp[to][j] - m, dp[to][sel[to]]);
}
}
sel[now] = 1;
for (int i = 1; i <= n; i++) {
if (dp[now][sel[now]] > dp[now][i]) {
sel[now] = i;
}
}
}
void getans(int now, int lst, int se) {
chs[now] = se;
for (int i = 0; i < nei[now].size(); i++) {
int to = nei[now][i];
if (to == lst) {
continue;
}
getans(to, now, dp[to][se] - m < dp[to][sel[to]] ? se : sel[to]);
}
}
int main() {
scanf("%d%d", &n, &m);
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i < n; i++) {
scanf("%d", cost + i);
dis[i][i] = 0;
}
dis[n][n] = 0;
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
nei[a].push_back(b);
nei[b].push_back(a);
dis[a][b] = dis[b][a] = 1;
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
dfs(1, 0);
printf("%d\n", dp[1][sel[1]]);
getans(1, 0, sel[1]);
for (int i = 1; i <= n; i++) {
printf("%d ", chs[i]);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> E[205];
int n, m, l, r, u, v;
int f[205][205], d[205], w[205][205], c[205], Q[205], fa[205];
void dfs(int u) {
for (int i = 0, v; i < E[u].size(); ++i) dfs(E[u][i]);
for (int i = 1; i <= n; ++i) {
f[u][i] = d[w[u][i]];
for (int j = 0, v; j < E[u].size(); ++j) {
v = E[u][j];
f[u][i] += min(f[v][i], f[v][c[v]] + m);
}
if (!c[u] || f[u][i] < f[u][c[u]]) c[u] = i;
}
}
void getans(int u) {
for (int i = 0, v; i < E[u].size(); ++i) {
v = E[u][i];
if (f[v][c[v]] + m > f[v][c[u]]) c[v] = c[u];
getans(v);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; ++i) scanf("%d", &d[i]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) w[i][j] = 2000000000;
for (int i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
w[u][v] = w[v][u] = 1;
E[u].push_back(v);
E[v].push_back(u);
}
for (int i = 1; i <= n; ++i) w[i][i] = 0;
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
if (w[i][k] < 2000000000)
for (int j = 1; j <= n; ++j)
if (w[k][j] < 2000000000) w[i][j] = min(w[i][j], w[i][k] + w[k][j]);
Q[l = r = 1] = 1;
for (; l <= r; ++l) {
u = Q[l];
for (int i = 0; i < E[u].size(); ++i) {
v = E[u][i];
if (v == fa[u]) continue;
fa[v] = u;
Q[++r] = v;
}
}
for (int i = 1; i <= n; ++i) E[i].clear();
for (int i = 1; i <= n; ++i)
if (fa[i]) E[fa[i]].push_back(i);
dfs(1);
getans(1);
printf("%d\n", f[1][c[1]] + m);
for (int i = 1; i <= n; ++i) printf("%d%c", c[i], i < n ? ' ' : '\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const int Max = 256;
const int MaxE = Max * 2;
struct edge {
int to;
edge *s;
};
edge E[MaxE], *hd[Max], *cp;
int n, k, D[Max];
int F[Max][Max], R[Max];
int mp[Max][Max];
int A[Max], Q[Max], qn;
void addEdge(int x, int y) { cp->to = y, cp->s = hd[x], hd[x] = cp++; }
inline void update(int &r, int d) {
if (d < r) r = d;
}
void dfs(int x, int f) {
for (edge *p = hd[x]; p; p = p->s)
if (p->to != f) dfs(p->to, x);
for (int i = 1; i <= n; i++) {
int &cr = F[x][i] = 0;
int dx = mp[x][i];
for (edge *p = hd[x]; p; p = p->s)
if (p->to != f) {
int y = p->to;
cr += dx < mp[y][i] ? min(R[y], F[y][i]) : F[y][i];
}
cr += D[dx];
if (x == i) cr += k;
if (dx < mp[f][i]) update(R[x], cr);
}
}
void aDfs(int x, int f, int g) {
if (g == 0) {
for (int i = 1; i <= n; i++)
if (mp[x][i] < mp[f][i] && F[x][i] == R[x]) {
aDfs(x, f, i);
return;
}
}
if (x == g) A[Q[qn++] = x] = x;
for (edge *p = hd[x]; p; p = p->s)
if (p->to != f) {
int y = p->to;
aDfs(y, x, mp[x][g] < mp[y][g] && R[y] < F[y][g] ? 0 : g);
}
}
int main() {
while (scanf("%d%d", &n, &k) != EOF && n) {
for (int i = 1; i < n; i++) scanf("%d", &D[i]);
D[n] = oo;
memset(hd, 0, sizeof(hd));
memset(mp, 0x3f, sizeof(mp));
cp = E;
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
mp[x][y] = mp[y][x] = 1;
addEdge(x, y);
addEdge(y, x);
}
for (int z = 1; z <= n; z++)
for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++) update(mp[x][y], mp[x][z] + mp[z][y]);
for (int x = 1; x <= n; x++) mp[x][x] = 0;
memset(R, 0x3f, sizeof(R));
dfs(1, 0);
printf("%d\n", R[1]);
memset(A, -1, sizeof(A));
qn = 0;
aDfs(1, 0, 0);
for (int cq = 0; cq < qn; cq++) {
int x = Q[cq];
for (edge *p = hd[x]; p; p = p->s)
if (A[p->to] == -1) {
A[p->to] = A[x];
Q[qn++] = p->to;
}
}
for (int i = 1; i <= n; i++) printf("%d%c", A[i], i == n ? '\n' : ' ');
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, dp[205][205], ans[205], dis[205][205], d[205], path[205];
vector<int> g[205];
void floyd() {
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
void dfs(int u, int fa) {
for (int i = 1; i <= n; i++) dp[u][i] = d[dis[u][i]] + k;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == fa) continue;
dfs(v, u);
for (int j = 1; j <= n; j++) dp[u][j] += min(dp[v][ans[v]], dp[v][j] - k);
}
ans[u] = 1;
for (int i = 2; i <= n; i++) {
if (dp[u][i] < dp[u][ans[u]]) ans[u] = i;
}
}
void output(int u, int fa, int x) {
path[u] = x;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == fa) continue;
if (dp[v][ans[v]] < dp[v][x] - k)
output(v, u, ans[v]);
else
output(v, u, x);
}
}
int main() {
memset(g, 0, sizeof(g));
scanf("%d%d", &n, &k);
for (int i = 1; i <= n - 1; i++) scanf("%d", &d[i]);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (i != j)
dis[i][j] = 1e9;
else
dis[i][j] = 0;
}
for (int i = 1, u, v; i <= n - 1; i++) {
scanf("%d%d", &u, &v);
g[v].push_back(u);
g[u].push_back(v);
dis[u][v] = dis[v][u] = 1;
}
floyd();
dfs(1, 0);
printf("%d\n", dp[1][ans[1]]);
output(1, 0, ans[1]);
for (int i = 1; i <= n; i++) printf("%d ", path[i]);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 200;
using namespace std;
struct edge {
int v, nxt;
} e[N * 2];
int n, k, a[N], head[N], cnt, dep[N], f[N][20];
int p[N], g[N][N], dp[N][N], ans[N];
void adde(int u, int v) {
e[++cnt].v = v;
e[cnt].nxt = head[u];
head[u] = cnt;
}
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
f[u][0] = fa;
for (int i = 1; i <= 15; ++i) f[u][i] = f[f[u][i - 1]][i - 1];
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
dfs(v, u);
}
}
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 15; i >= 0; --i)
if (dep[f[u][i]] >= dep[v]) u = f[u][i];
if (u == v) return u;
for (int i = 15; i >= 0; --i)
if (f[u][i] != f[v][i]) {
u = f[u][i];
v = f[v][i];
}
return f[u][0];
}
int dis(int u, int v) { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; }
void dfs2(int u, int fa) {
for (int i = 1; i <= n; ++i) dp[u][i] = a[dis(i, u)] + k;
p[u] = 1;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
dfs2(v, u);
for (int j = 1; j <= n; ++j) dp[u][j] += min(dp[v][j] - k, dp[v][p[v]]);
}
for (int i = 1; i <= n; ++i)
if (dp[u][i] < dp[u][p[u]]) p[u] = i;
}
void getans(int u, int fa, int x) {
ans[u] = x;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
getans(v, u, dp[v][x] - k < dp[v][p[v]] ? x : p[v]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; ++i) scanf("%d", &a[i]);
for (int i = 1, u, v; i < n; ++i) {
scanf("%d%d", &u, &v);
adde(u, v);
adde(v, u);
}
dfs(1, 0);
dfs2(1, 0);
printf("%d\n", dp[1][p[1]]);
getans(1, 0, p[1]);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, wv, d[200], dist[200][200], dp[200][200], par[200], best[200],
trace[200][200], ans[200];
vector<vector<long long> > gr(200);
void dfs(long long u) {
for (long long i = 0; i < gr[u].size(); ++i) {
long long v = gr[u][i];
if (v != par[u]) {
par[v] = u;
dfs(v);
}
}
}
void dpp(long long u) {
long long currc = 1e18;
for (long long i = 1; i <= n; ++i) {
for (long long j = 0; j < gr[u].size(); ++j) {
long long v = gr[u][j];
if (v != par[u]) {
if (i == 1) dpp(v);
if (dp[v][i] - wv < dp[v][best[v]]) {
dp[u][i] += dp[v][i] - wv;
trace[v][i] = i;
} else {
dp[u][i] += dp[v][best[v]];
trace[v][i] = best[v];
}
}
}
dp[u][i] += wv + d[dist[u][i]];
if (dp[u][i] < currc) {
currc = dp[u][i];
best[u] = i;
}
}
}
void tracee(long long now1, long long now2) {
for (long long i = 0; i < gr[now1].size(); ++i) {
long long v = gr[now1][i];
if (v != par[now1]) {
ans[v] = trace[v][now2];
tracee(v, ans[v]);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> wv;
for (long long i = 1; i < n; ++i) cin >> d[i];
memset(dist, 1, sizeof dist);
for (long long i = 1; i < n; ++i) {
long long x, y;
cin >> x >> y;
gr[x].push_back(y);
gr[y].push_back(x);
dist[x][y] = dist[y][x] = 1;
}
dfs(1);
for (long long i = 1; i <= n; ++i) dist[i][i] = 0;
for (long long k = 1; k <= n; ++k) {
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) {
dist[i][j] = min(dist[i][k] + dist[k][j], dist[i][j]);
}
}
}
dpp(1);
cout << dp[1][best[1]] << "\n";
ans[1] = best[1];
long long now1 = 1, now2 = best[1];
tracee(now1, now2);
for (long long i = 1; i <= n; ++i) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int w[205], d[205][205], f[205][205], b[205], c[205], n, v, x, y;
void dfs(int x, int y) {
for (int j = 1; j <= n; j++) f[x][j] = w[d[x][j]] + v;
for (int i = 1; i <= n; i++)
if (d[x][i] == 1 && y - i) {
dfs(i, x);
for (int j = 1; j <= n; j++) f[x][j] += min(f[i][j] - v, f[i][b[i]]);
}
b[x] = 1;
for (int j = 1; j <= n; j++)
if (f[x][j] < f[x][b[x]]) b[x] = j;
}
void prt(int x, int y, int z) {
c[x] = z;
for (int i = 1; i <= n; i++)
if (d[x][i] == 1 && y - i) prt(i, x, f[i][z] - v < f[i][b[i]] ? z : b[i]);
}
int main() {
scanf("%d%d", &n, &v);
for (int i = 1; i <= n - 1; i++) scanf("%d", w + i);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = (i != j) << 22;
for (int i = 1; i <= n - 1; i++) scanf("%d%d", &x, &y), d[x][y] = d[y][x] = 1;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
dfs(1, 0), printf("%d\n", f[1][b[1]]), prt(1, 0, b[1]);
for (int i = 1; i <= n; i++) printf("%d%s", c[i], i < n ? " " : "\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 250;
long long dp[2][MAX][MAX];
long long gdeep;
long long deeps[MAX], deeps2[MAX], vist[MAX], store[MAX][MAX], stidx[MAX][MAX],
parent[MAX];
vector<long long> childs[MAX];
long long head[MAX], nxt[MAX << 1], to[MAX << 1], ent, cur;
long long n, k, d[MAX];
struct node {
long long mask, v, deep;
node() {}
node(long long a, long long b, long long c) : mask(a), v(b), deep(c) {}
};
vector<node> ss[2][MAX][MAX];
void add(long long a, long long b) {
nxt[ent] = head[a], to[ent] = b, head[a] = ent++;
nxt[ent] = head[b], to[ent] = a, head[b] = ent++;
}
void dfs1(long long v, long long pa) {
vist[v] = 1;
deeps[v] = 0;
for (long long i = head[v]; ~i; i = nxt[i]) {
long long u = to[i];
if (u != pa && vist[u] == 0) {
parent[u] = v;
dfs1(u, v);
deeps[v] = std::max(deeps[v], deeps[u] + 1);
}
}
}
void dfs2(long long v, long long pa) {
vist[v] = 1;
for (long long i = head[v]; ~i; i = nxt[i]) {
long long u = to[i];
if (u != pa && vist[u] == 0) {
childs[v].push_back(u);
dfs2(u, v);
}
}
}
bool debug = 0;
long long sol(long long mask, long long v, long long deep) {
auto &ele = dp[mask][v][deep];
auto &ve = ss[mask][v][deep];
if (ele != -1) return ele;
if (mask == 0) {
if (vist[v] == 0) {
vist[v] = 1;
for (long long i = 0; i < childs[v].size(); i++) {
long long u = childs[v][i];
for (long long dd = 0; dd <= deeps[u]; dd++) {
sol(mask, u, dd);
}
store[u][deeps[u]] = dp[mask][u][deeps[u]],
stidx[u][deeps[u]] = deeps[u];
for (long long dd = deeps[u] - 1; dd >= 0; dd--) {
if (store[u][dd + 1] > dp[mask][u][dd]) {
store[u][dd] = dp[mask][u][dd], stidx[u][dd] = dd;
} else
store[u][dd] = store[u][dd + 1], stidx[u][dd] = stidx[u][dd + 1];
}
}
}
if (childs[v].size() == 0) {
if (deep == 0)
return ele = k;
else
return ele = LLONG_MAX;
} else {
if (deep == 0) {
ele = k;
for (long long i = 0; i < childs[v].size(); i++) {
long long u = childs[v][i];
ele += std::min(sol(1, u, 1) - k, store[u][0]);
if (sol(1, u, 1) - k < store[u][0])
ve.push_back({1, u, 1});
else
ve.push_back({0, u, stidx[u][0]});
}
return ele;
} else {
if (deep > deeps[v]) return ele = LLONG_MAX;
ele = LLONG_MAX;
for (long long i = 0; i < childs[v].size(); i++) {
long long u = childs[v][i];
if (deeps[u] >= deep - 1) {
vector<node> tmp;
long long t1 = sol(0, u, deep - 1);
tmp.push_back({0, u, deep - 1});
if (t1 != LLONG_MAX) {
for (long long j = 0; j < childs[v].size(); j++) {
long long t = childs[v][j];
if (t != u) {
if (deep - 1 > deeps[t])
t1 += sol(1, t, deep + 1) - k,
tmp.push_back({1, t, deep + 1});
else {
if (sol(1, t, deep + 1) - k < store[t][deep - 1])
t1 += sol(1, t, deep + 1) - k,
tmp.push_back({1, t, deep + 1});
else
t1 += store[t][deep - 1],
tmp.push_back({0, t, stidx[t][deep - 1]});
}
}
}
if (t1 + d[deep] < ele) {
ele = t1 + d[deep];
ve = move(tmp);
}
}
}
}
return ele;
}
}
} else {
if (childs[v].size() == 0) {
if (deep > deeps2[v])
return ele = LLONG_MAX;
else
return ele = d[deep] + k;
} else {
if (deep > deeps2[v]) return ele = LLONG_MAX;
ele = d[deep] + k;
for (int i = 0; i < childs[v].size(); i++) {
long long u = childs[v][i];
long long t1 = sol(mask, u, deep + 1) - k;
long long t2 = LLONG_MAX, idx;
for (long long dd = 0; dd <= deeps[u]; dd++) {
if (sol(0, u, dd) < t2) {
t2 = sol(0, u, dd), idx = dd;
}
}
if (t1 < t2) {
ele += t1, ve.push_back({mask, u, deep + 1});
} else
ele += t2, ve.push_back({0, u, idx});
}
return ele;
}
}
}
void printdp() {
printf("parentinfo\n");
for (int i = 1; i <= n; i++) printf("i = %d, pa = %lld\n", i, parent[i]);
printf("deepinfo\n");
for (int i = 1; i <= n; i++) printf("i = %d, dd = %lld\n", i, deeps[i]);
printf("deep2info\n");
for (int i = 1; i <= n; i++) printf("i = %d, dd = %lld\n", i, deeps2[i]);
for (int i = 1; i <= n; i++) {
printf("*********************i = %d :\n", i);
for (int dd = 0; dd <= deeps[i]; dd++) {
printf("(%d, %d, %d) = %lld\n", 0, i, dd, dp[0][i][dd]);
}
for (int dd = 0; dd <= deeps2[i]; dd++) {
printf("(%d, %d, %d) = %lld\n", 1, i, dd, dp[1][i][dd]);
}
}
}
bool power[MAX];
long long ans[MAX];
void assignP(long long mask, long long v, long long deep) {
auto &ve = ss[mask][v][deep];
if (mask == 0 && deep == 0) power[v] = 1;
for (int i = 0; i < ve.size(); i++) {
node &nn = ve[i];
assignP(nn.mask, nn.v, nn.deep);
}
}
void bfs() {
for (int i = 1; i <= n; i++) {
memset(vist, 0, sizeof(vist));
queue<int> q;
q.push(i), vist[i] = 1;
if (power[i] == 1)
ans[i] = i;
else {
bool find = 0;
while (!q.empty() && !find) {
int v = q.front();
q.pop();
for (int j = head[v]; ~j; j = nxt[j]) {
int u = to[j];
if (vist[u] == 0) {
if (power[u] == 1) {
ans[i] = u, find = 1;
break;
} else {
vist[u] = 1, q.push(u);
}
}
}
}
}
}
}
int main() {
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= n - 1; i++) scanf("%lld", &d[i]);
memset(head, -1, sizeof(head));
ent = 0;
for (long long i = 1; i <= n - 1; i++) {
long long a, b;
scanf("%lld%lld", &a, &b);
add(a, b);
}
gdeep = LLONG_MIN;
for (long long i = 1; i <= n; i++) deeps[i] = LLONG_MIN;
memset(vist, 0, sizeof(vist));
parent[1] = -1, dfs1(1, -1);
for (long long i = 1; i <= n; i++) {
deeps2[i] = 0;
long long tt = i, zz = 1;
if (i == 2)
debug = 1;
else
debug = 0;
while (tt != -1) {
long long pa = parent[tt];
if (pa != -1) {
deeps2[i] = std::max(deeps2[i], zz);
for (long long j = head[pa]; ~j; j = nxt[j]) {
long long u = to[j];
if (u != tt && u != parent[pa]) {
deeps2[i] = std::max(deeps2[i], deeps[u] + zz + 1);
}
}
}
++zz, tt = pa;
}
}
memset(vist, 0, sizeof(vist));
dfs2(1, -1);
for (long long i = 1; i <= n; i++) {
for (long long dd = 0; dd <= deeps[i]; dd++) dp[0][i][dd] = -1;
for (long long dd = 0; dd <= deeps2[i]; dd++) dp[1][i][dd] = -1;
}
memset(vist, 0, sizeof(vist));
long long opt = LLONG_MAX, t1;
node optn;
for (long long dd = 0; dd <= deeps[1]; dd++) {
t1 = sol(0, 1, dd);
if (t1 < opt) opt = t1, optn = {0, 1, dd};
}
for (long long dd = 1; dd <= deeps2[1]; dd++) {
t1 = sol(1, 1, dd);
if (t1 < opt) opt = t1, optn = {1, 1, dd};
}
printf("%lld\n", opt);
memset(power, 0, sizeof(power));
assignP(optn.mask, optn.v, optn.deep);
bfs();
for (int i = 1; i <= n; i++) printf("%lld ", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int d[200];
int dis[200][200];
struct edge {
int to, nxt;
} ed[400];
int edcnt = 0;
int hd[200];
inline void adde(int u, int v) {
ed[++edcnt] = {v, hd[u]};
hd[u] = edcnt;
}
int dp[200][200], cho[200][200], mn[200];
void dfs(int u, int fa) {
for (int i = 1; i <= n; ++i) dp[u][i] = k + d[dis[u][i]];
for (int id = hd[u]; id; id = ed[id].nxt) {
int v = ed[id].to;
if (v == fa) continue;
dfs(v, u);
for (int i = 1; i <= n; ++i) {
dp[u][i] += min(dp[v][i] - k, dp[v][mn[v]]);
}
}
for (int i = 1; i <= n; ++i) {
if (!mn[u] || dp[u][mn[u]] > dp[u][i]) mn[u] = i;
}
}
int ans[200];
void dfs2(int u, int i, int fa) {
for (int id = hd[u]; id; id = ed[id].nxt) {
int v = ed[id].to;
if (v == fa) continue;
if (dp[v][i] - k < dp[v][mn[v]]) {
ans[v] = i;
dfs2(v, i, u);
} else {
ans[v] = mn[v];
dfs2(v, mn[v], u);
}
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; ++i) scanf("%d", &d[i]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) dis[i][j] = (i == j ? 0 : 10000);
for (int i = 1, u, v; i < n; ++i) {
scanf("%d%d", &u, &v);
adde(u, v);
adde(v, u);
dis[u][v] = dis[v][u] = 1;
}
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(1, 1);
cout << dp[1][mn[1]] << endl;
dfs2(1, mn[1], 1);
ans[1] = mn[1];
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200;
struct G {
int h[N], e, nxt[N << 1], v[N << 1];
void clear() {
memset(h, 0, sizeof(h));
e = 1;
}
void add_dir(int _u, int _v) {
++e;
nxt[e] = h[_u];
v[e] = _v;
h[_u] = e;
}
void add_undir(int _u, int _v) {
add_dir(_u, _v);
add_dir(_v, _u);
}
};
G g;
int n, co, d[N], dis[N][N];
int f[N][N], ans[N], bel[N];
void Dfs(int u, int fa) {
for (int c = 1; c <= n; ++c) f[u][c] = co + d[dis[u][c]];
for (int i = g.h[u]; i; i = g.nxt[i]) {
int v = g.v[i];
if (v == fa) continue;
Dfs(v, u);
for (int c = 1; c <= n; ++c) {
f[u][c] += min(f[v][ans[v]], f[v][c] - co);
}
}
ans[u] = 1;
for (int c = 2; c <= n; ++c)
if (f[u][c] < f[u][ans[u]]) ans[u] = c;
}
void Dfs1(int u, int fa, int ctr) {
bel[u] = ctr;
for (int i = g.h[u]; i; i = g.nxt[i]) {
int v = g.v[i];
int vc = ctr;
if (v == fa) continue;
if (f[v][ans[v]] < f[v][vc] - co) vc = ans[v];
Dfs1(v, u, vc);
}
}
int main() {
scanf("%d%d", &n, &co);
for (int i = 1; i < n; ++i) scanf("%d", &d[i]);
d[0] = 0;
g.clear();
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i <= n; ++i) dis[i][i] = 0;
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
g.add_undir(x, y);
dis[x][y] = dis[y][x] = 1;
}
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
Dfs(1, 0);
Dfs1(1, 0, ans[1]);
printf("%d\n", f[1][ans[1]]);
for (int i = 1; i <= n; ++i) printf("%d ", bel[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ck, d[200], dis[200][200];
int dp[200][200], best[200], center[200];
vector<int> edge[200];
void dfs(int u, int father) {
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (v == father) continue;
dfs(v, u);
}
int tmp = 1000000;
for (int i = 1; i <= n; i++) {
dp[u][i] = d[dis[u][i]];
for (int j = 0; j < edge[u].size(); j++) {
int v = edge[u][j];
if (v == father) continue;
dp[u][i] += min(dp[v][i], dp[v][best[v]] + ck);
}
if (dp[u][i] < tmp) {
tmp = dp[u][i];
best[u] = i;
}
}
}
void getcenter(int u, int father, int c) {
center[u] = c;
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (v == father) continue;
if (dp[v][c] < dp[v][best[v]] + ck)
getcenter(v, u, c);
else
getcenter(v, u, best[v]);
}
}
int main(int argc, char** argv) {
cin >> n >> ck;
for (int i = 1; i <= n - 1; i++) cin >> d[i];
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) dis[i][j] = ((i == j) ? 0 : n);
int u, v;
for (int i = 1; i <= n - 1; i++) {
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
dis[u][v] = dis[v][u] = 1;
}
for (int k = (1); k <= (n); k++)
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(1, -1);
cout << dp[1][best[1]] + ck << endl;
getcenter(1, -1, best[1]);
for (int i = 1; i <= n; i++) cout << center[i] << " ";
cout << endl;
return (EXIT_SUCCESS);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 185, INF = 1e9;
int n, K, cost[N], dist[N][N], dp[N][N], opt[N], belong[N];
vector<int> T[N];
inline void Min(int &a, int b) {
if (b < a) a = b;
}
void Floyd() {
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) Min(dist[i][j], dist[i][k] + dist[k][j]);
}
void DP(int cur, int par) {
for (int i = 1; i <= n; ++i) dp[cur][i] = cost[dist[cur][i]];
for (int i = 0; i < (int)T[cur].size(); ++i) {
int son = T[cur][i];
if (son == par) continue;
DP(son, cur);
for (int i = 1; i <= n; ++i)
dp[cur][i] += min(dp[son][i], dp[son][opt[son]] + K);
}
opt[cur] = -1;
for (int i = 1; i <= n; ++i)
if (opt[cur] == -1 || dp[cur][i] < dp[cur][opt[cur]]) opt[cur] = i;
}
void assign(int cur, int par, int tar) {
belong[cur] = tar;
for (int i = 0; i < (int)T[cur].size(); ++i) {
int son = T[cur][i];
if (son == par) continue;
assign(son, cur, dp[son][opt[son]] + K < dp[son][tar] ? opt[son] : tar);
}
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 1; i <= n; ++i) T[i].clear();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) dist[i][j] = (i != j) * INF;
cost[0] = 0;
for (int i = 1; i < n; ++i) scanf("%d", &cost[i]);
for (int i = 1, u, v; i < n; ++i) {
scanf("%d%d", &u, &v);
dist[u][v] = dist[v][u] = 1;
T[u].push_back(v);
T[v].push_back(u);
}
Floyd();
DP(1, 0);
assign(1, 0, opt[1]);
printf("%d\n", dp[1][opt[1]] + K);
for (int i = 1; i <= n; ++i) printf("%d%c", belong[i], i == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 185;
int n, K;
int d[N];
int ans[N];
int f[N][N];
int dis[N][N];
vector<int> g[N];
int dp[N], dp0[N][N][N];
int pre[N], pre0[N][N][N];
int siz[N], dfn[N], on[N], tme;
void dfs(int u, int p) {
on[tme] = u;
dfn[u] = tme++;
siz[u] = 1;
for (int j = 0; j < n; ++j) f[u][j] = d[j];
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (v == p) continue;
dfs(v, u);
for (int j = 0; j < n; ++j) {
f[u][j] += f[v][j + 1];
}
siz[u] += siz[v];
}
}
void dfs0(int u, int p) {
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (v == p) continue;
dfs0(v, u);
}
dp[u] = 0x3f3f3f3f;
for (int x = u; ~x && dfn[x] < dfn[u] + siz[u]; x = on[dfn[x] + 1]) {
for (int v = on[dfn[u] + siz[u] - 1]; v != u; v = on[dfn[v] - 1]) {
if (dfn[v] <= dfn[x] && dfn[x] < dfn[v] + siz[v]) {
dp0[u][x][v] = (~on[dfn[v] + 1] ? dp0[u][x][on[dfn[v] + 1]] : 0);
pre0[u][x][v] = 0;
continue;
}
dp0[u][x][v] =
(~on[dfn[v] + siz[v]] ? dp0[u][x][on[dfn[v] + siz[v]]] : 0) + dp[v] -
f[v][dis[v][x]];
pre0[u][x][v] = 1;
if ((~on[dfn[v] + 1] ? dp0[u][x][on[dfn[v] + 1]] : 0) < dp0[u][x][v]) {
dp0[u][x][v] = (~on[dfn[v] + 1] ? dp0[u][x][on[dfn[v] + 1]] : 0);
pre0[u][x][v] = 0;
}
}
int cur = (~on[dfn[u] + 1] ? dp0[u][x][on[dfn[u] + 1]] : 0) + K;
for (int v = u; ~v && dfn[v] < dfn[u] + siz[u]; v = on[dfn[v] + 1])
cur += d[dis[x][v]];
if (cur < dp[u]) {
dp[u] = cur;
pre[u] = x;
}
}
}
void prt(int u) {
int x = pre[u];
for (int v = u; ~v && dfn[v] < dfn[u] + siz[u]; v = on[dfn[v] + 1])
ans[v] = x;
int v = on[dfn[u] + 1];
while (~v && dfn[v] < dfn[u] + siz[u]) {
if (pre0[u][x][v]) prt(v);
v = pre0[u][x][v] ? on[dfn[v] + siz[v]] : on[dfn[v] + 1];
}
}
int main() {
scanf("%d %d", &n, &K);
for (int i = 1; i < n; ++i) scanf("%d", &d[i]);
memset(dis, 0x3f, sizeof(dis));
for (int i = 0; i < n; ++i) dis[i][i] = 0;
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d %d", &u, &v);
--u, --v;
g[u].push_back(v);
g[v].push_back(u);
dis[u][v] = dis[v][u] = 1;
}
for (int k = 0; k < n; ++k) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
on[n] = -1;
dfs(0, -1);
dfs0(0, -1);
printf("%d\n", dp[0]);
prt(0);
for (int i = 0; i < n; ++i) printf("%d ", ans[i] + 1);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ecnt;
struct Edge {
int to;
Edge *next;
} * mat[205], edges[205 * 2];
void link(int x, int to) {
edges[ecnt].to = to;
edges[ecnt].next = mat[x];
mat[x] = &edges[ecnt++];
}
int n, K, dp[205][205], best[205][205];
int d[205], dis[205][205], ans[205];
void dfs(int x, int father, int dis[]) {
for (Edge *p = mat[x]; p; p = p->next) {
int to = p->to;
if (father == to) continue;
dis[to] = dis[x] + 1;
dfs(to, x, dis);
}
}
void solve(int x, int father) {
for (Edge *p = mat[x]; p; p = p->next) {
int to = p->to;
if (father == to) continue;
solve(to, x);
}
for (int i = 1; i <= n; i++) {
dp[x][i] = d[dis[x][i]];
for (Edge *p = mat[x]; p; p = p->next) {
int to = p->to;
dp[x][i] += min(dp[to][i], dp[to][best[to][i]] + K);
}
}
int g = 1, h = 2;
if (dp[x][g] > dp[x][h]) swap(g, h);
for (int i = 3; i <= n; i++)
if (dp[x][i] < dp[x][g])
h = g, g = i;
else if (dp[x][i] < dp[x][h])
h = i;
for (int i = 1; i <= n; i++) best[x][i] = i == g ? h : g;
}
void get(int x, int father, int root) {
ans[x] = root;
for (Edge *p = mat[x]; p; p = p->next) {
int to = p->to;
if (to == father) continue;
if (dp[to][root] < dp[to][best[to][root]] + K)
get(to, x, root);
else
get(to, x, best[to][root]);
}
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
for (int i = 1, x, y; i < n; i++) {
scanf("%d%d", &x, &y);
link(x, y), link(y, x);
}
for (int i = 1; i <= n; i++) dfs(i, -1, dis[i]);
solve(1, -1);
int g = 1;
for (int i = 1; i <= n; i++)
if (dp[1][i] < dp[1][g]) g = i;
printf("%d\n", dp[1][g] + K);
get(1, -1, g);
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], i == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K;
int d[205];
const int INF = 1000000000;
int mat[205][205];
void floyd() {
for (int k = 0; k < N; k++) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
mat[i][j] = min(mat[i][j], mat[i][k] + mat[k][j]);
}
}
}
}
int opt[205][205], prt[205];
void dfs(int np, int fp) {
for (int i = 0; i < N; i++) {
if (mat[np][i] == 1 && i != fp) {
dfs(i, np);
}
}
prt[np] = 0;
for (int c = 0; c < N; c++) {
opt[np][c] = d[mat[np][c]];
for (int i = 0; i < N; i++) {
if (mat[np][i] == 1 && i != fp) {
opt[np][c] += min(opt[i][c], opt[i][prt[i]] + K);
}
}
if (opt[np][c] < opt[np][prt[np]]) {
prt[np] = c;
}
}
}
void gen(int np, int fp) {
for (int i = 0; i < N; i++) {
if (mat[np][i] == 1 && i != fp) {
if (opt[i][prt[i]] + K > opt[i][prt[np]]) {
prt[i] = prt[np];
}
gen(i, np);
}
}
}
int main() {
scanf("%d%d", &N, &K);
d[0] = 0;
for (int i = 1; i <= N - 1; i++) {
scanf("%d", &d[i]);
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
mat[i][j] = INF;
}
mat[i][i] = 0;
}
for (int i = 1; i < N; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
mat[u][v] = mat[v][u] = 1;
}
floyd();
memset(opt, 0, sizeof(opt));
memset(prt, 0, sizeof(prt));
dfs(0, -1);
printf("%d\n", opt[0][prt[0]] + K);
gen(0, -1);
for (int i = 0; i < N; i++) {
printf("%d%c", prt[i] + 1, (i == N - 1) ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 205, M = 405;
int tot, lnk[N], ter[M], nxt[M];
int n, k, d[N], dis[N][N], e[N][N], f[N][N], p[N], ans[N];
void add(int u, int v) { ter[++tot] = v, nxt[tot] = lnk[u], lnk[u] = tot; }
void Floyd() {
for (int k = 1; k <= n; ++k) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
dis[i][j] = std::min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
}
void dfs(int u, int fa) {
for (int i = 1; i <= n; ++i) f[i][u] = d[dis[i][u]] + k;
for (int i = lnk[u]; i; i = nxt[i]) {
int v = ter[i];
if (v == fa) continue;
dfs(v, u);
for (int i = 1; i <= n; ++i) {
f[i][u] += std::min(f[p[v]][v], f[i][v] - k);
}
}
p[u] = 1;
for (int i = 1; i <= n; ++i)
if (f[i][u] < f[p[u]][u]) p[u] = i;
}
void getPath(int u, int fa, int pos) {
for (int i = lnk[u]; i; i = nxt[i]) {
int v = ter[i];
if (v == fa) continue;
if (f[p[v]][v] > f[pos][v] - k)
ans[v] = pos;
else
ans[v] = p[v];
getPath(v, u, ans[v]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; ++i) scanf("%d", &d[i]);
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i <= n; ++i) dis[i][i] = 0;
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
dis[u][v] = dis[v][u] = 1, add(u, v), add(v, u);
}
Floyd();
dfs(1, 0);
printf("%d\n", f[p[1]][1]);
ans[1] = p[1];
getPath(1, 0, ans[1]);
for (int i = 1; i <= n; ++i) printf("%d%c", ans[i], " \n"[i == n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, inf, d[200], mfp[200], ans[200];
long long f[200][200], g[200][200], mf[200];
vector<int> gr[200];
void dfs(int x, int p) {
fill(f[x], f[x] + n + 1, inf);
fill(g[x], g[x] + n + 1, inf);
for (int i = 0; i < n; i++) g[x][i] = d[i];
for (int y : gr[x])
if (y != p) {
dfs(y, x);
for (int i = 0; i < n; i++) g[x][i] += min(g[y][i + 1], mf[y]);
}
f[x][0] = g[x][0];
for (int y : gr[x])
if (y != p) {
for (int i = 1; i < n; i++) {
if (g[x][i] - min(g[y][i + 1], mf[y]) + f[y][i - 1] < f[x][i]) {
f[x][i] = g[x][i] - min(g[y][i + 1], mf[y]) + f[y][i - 1];
}
}
}
mf[x] = *min_element(f[x], f[x] + n);
}
void prtg(int x, int p, int av, int cd);
int prtf(int x, int p, int cd) {
int fp = -1;
if (cd == 0) {
ans[x] = x;
} else {
for (int y : gr[x])
if (y != p) {
if (f[x][cd] == g[x][cd] - min(g[y][cd + 1], mf[y]) + f[y][cd - 1]) {
ans[x] = prtf(y, x, cd - 1);
fp = y;
break;
}
}
}
for (int y : gr[x])
if (y != p && y != fp) {
if (g[y][cd + 1] < mf[y])
prtg(y, x, ans[x], cd + 1);
else
prtf(y, x, min_element(f[y], f[y] + n) - f[y]);
}
return ans[x];
}
void prtg(int x, int p, int av, int cd) {
ans[x] = av;
for (int y : gr[x])
if (y != p) {
if (g[y][cd + 1] < mf[y])
prtg(y, x, ans[x], cd + 1);
else
prtf(y, x, min_element(f[y], f[y] + n) - f[y]);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> d[0];
for (int i = 1; i < n; i++) cin >> d[i];
inf = *max_element(d, d + n) * n + 1;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
gr[u].emplace_back(v);
gr[v].emplace_back(u);
}
dfs(1, -1);
cout << mf[1] << '\n';
prtf(1, -1, min_element(f[1], f[1] + n) - f[1]);
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NR = 180 + 10;
int n, m, w[NR];
int d[NR][NR], f[NR][NR], g[NR], ans[NR];
int ecnt = 0, first[NR];
struct Edge {
int to, nxt;
Edge(int to = 0, int nxt = 0) { this->to = to, this->nxt = nxt; }
} e[NR << 1];
void addE(int u, int v) {
e[++ecnt] = Edge(v, first[u]);
first[u] = ecnt;
}
void dfs(int now, int fou) {
for (int i = 1; i <= n; i++) f[i][now] = w[d[i][now]] + m;
for (int i = first[now]; i; i = e[i].nxt) {
int t = e[i].to;
if (t == fou) continue;
dfs(t, now);
for (int j = 1; j <= n; j++) f[j][now] += min(f[g[t]][t], f[j][t] - m);
}
g[now] = 1;
for (int i = 1; i <= n; i++)
if (f[i][now] < f[g[now]][now]) g[now] = i;
}
void getAns(int now, int fou, int cur) {
for (int i = first[now]; i; i = e[i].nxt) {
int t = e[i].to;
if (t == fou) continue;
if (f[cur][t] - m < f[g[t]][t]) {
ans[t] = cur;
getAns(t, now, cur);
} else {
ans[t] = g[t];
getAns(t, now, g[t]);
}
}
}
int main() {
std::ios::sync_with_stdio(0);
memset(d, 999999, sizeof(f));
cin >> n >> m;
for (int i = 1; i <= n; i++) d[i][i] = 0;
for (int i = 1; i < n; i++) cin >> w[i];
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
addE(u, v), addE(v, u);
d[u][v] = d[v][u] = 1;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
dfs(1, 0);
ans[1] = g[1];
getAns(1, 0, g[1]);
cout << f[g[1]][1] << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void in(int &x) {
x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
}
int n, k, dis[200][200], D[200], best[200], dp[200][200], ans[200];
bool edge[200][200];
void dfs(int from, int f) {
for (int to = 1; to <= n; ++to)
if (edge[from][to] && to != f) {
dfs(to, from);
}
for (int i = 1; i <= n; ++i) {
dp[from][i] = D[dis[from][i]] + k;
for (int to = 1; to <= n; ++to)
if (edge[from][to] && to != f) {
dp[from][i] += min(dp[to][i] - k, dp[to][best[to]]);
}
if (!best[from] || dp[from][best[from]] > dp[from][i]) best[from] = i;
}
}
void get_ans(int from, int f) {
if (!f)
ans[from] = best[from];
else {
if (dp[from][ans[f]] - k > dp[from][best[from]])
ans[from] = best[from];
else
ans[from] = ans[f];
}
for (int to = 1; to <= n; ++to)
if (edge[from][to] && to != f) get_ans(to, from);
}
int main() {
in(n);
in(k);
for (int i = 1; i < n; ++i) in(D[i]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (i != j) dis[i][j] = n;
for (int i = 1; i < n; ++i) {
int x, y;
in(x);
in(y);
edge[x][y] = edge[y][x] = dis[x][y] = dis[y][x] = 1;
}
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (dis[i][k] + dis[k][j] < dis[i][j])
dis[i][j] = dis[i][k] + dis[k][j];
dfs(1, 0);
printf("%d\n", dp[1][best[1]]);
get_ans(1, 0);
for (int i = 1; i <= n; ++i) printf("%d%c", ans[i], i == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 180 + 10;
int N, K, dis[MAXN][MAXN], d[MAXN], f[MAXN][MAXN], rec[MAXN][MAXN][MAXN];
vector<int> E[MAXN];
void dfs(int u, int fr) {
for (int RC = (0), RCend = (N); RC < RCend; ++RC) f[u][RC] = d[dis[u][RC]];
for (int v : E[u])
if (v != fr) {
dfs(v, u);
for (int RC = (0), RCend = (N); RC < RCend; ++RC) {
int mn = INT_MAX;
for (int RCv = (0), RCvend = (N); RCv < RCvend; ++RCv) {
if (RCv != RC) {
if (mn > f[v][RCv] + K) mn = f[v][RCv] + K, rec[u][RC][v] = RCv;
} else {
if (mn > f[v][RC]) mn = f[v][RC], rec[u][RC][v] = RC;
}
}
f[u][RC] += mn;
}
}
}
int fans[MAXN];
void recover(int u, int RC, int fr) {
fans[u] = RC;
for (int v : E[u])
if (v != fr) recover(v, rec[u][RC][v], u);
}
int main() {
scanf("%d %d", &N, &K);
for (int i = (1), iend = (N); i < iend; ++i) scanf("%d", &d[i]);
memset(dis, 0x3f, sizeof dis);
for (int i = (0), iend = (N); i < iend; ++i) dis[i][i] = 0;
for (int i = (0), iend = (N - 1); i < iend; ++i) {
int u, v;
scanf("%d %d", &u, &v);
u--, v--;
dis[u][v] = dis[v][u] = 1;
E[u].push_back(v), E[v].push_back(u);
}
for (int k = (0), kend = (N); k < kend; ++k)
for (int i = (0), iend = (N); i < iend; ++i)
for (int j = (0), jend = (N); j < jend; ++j)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(0, -1);
int ans = INT_MAX, RC0;
for (int RC = (0), RCend = (N); RC < RCend; ++RC) {
if (ans > f[0][RC] + K) ans = f[0][RC] + K, RC0 = RC;
}
printf("%d\n", ans);
recover(0, RC0, -1);
for (int i = (0), iend = (N); i < iend; ++i) printf("%d ", fans[i] + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 202;
int nex[N * 2], head[N], to[N * 2], dis[N][N];
int dp[N][N], d[N], f[N], ans[N];
int cnt, now, n, k, from[N][N];
void link(int x, int y) {
nex[++cnt] = head[x];
head[x] = cnt;
to[cnt] = y;
}
void init(int u, int pre) {
for (int i = head[u]; i; i = nex[i]) {
int v = to[i];
if (v == pre) continue;
dis[now][v] = dis[now][u] + 1;
init(v, u);
}
}
void dfs(int u, int pre) {
for (int i = head[u]; i; i = nex[i]) {
int v = to[i];
if (v == pre) continue;
dfs(v, u);
}
for (int j = 1; j <= n; j++) {
dp[u][j] = d[dis[u][j]] + k;
for (int i = head[u]; i; i = nex[i]) {
int v = to[i];
if (v == pre) continue;
int t = dp[v][f[v]];
dp[u][j] += min(t, dp[v][j] - k);
if (t > dp[v][j] - k)
from[v][j] = j;
else
from[v][j] = f[v];
}
if (j == 1 || dp[u][j] < dp[u][f[u]]) f[u] = j;
}
}
void dfs1(int u, int pre, int a) {
ans[u] = a;
for (int i = head[u]; i; i = nex[i])
if (to[i] != pre) dfs1(to[i], u, from[to[i]][a]);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
int x, y;
for (int i = 1; i < n; i++) scanf("%d%d", &x, &y), link(x, y), link(y, x);
for (int i = 1; i <= n; i++) now = i, init(now, 0);
dfs(1, 0);
printf("%d\n", dp[1][f[1]]);
dfs1(1, 0, f[1]);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, en, nw, id[185], w[185], in[185][185], pin[185][185], ax[185][185],
f[185][185][2], head[185];
struct edge {
int v, nxt, p[185][2];
} e[185 * 2];
void dfs(int, int);
void find(int, int, int, int);
void adde(int, int);
int main() {
int i, u, v, ps = 0;
scanf("%d %d", &n, &nw);
for (i = 1; i < n; ++i) scanf("%d", &w[i]);
for (i = 1; i < n; ++i) {
scanf("%d %d", &u, &v);
adde(u, v);
adde(v, u);
}
memset(in, 0x3f, sizeof(in));
dfs(1, 0);
for (i = 0; i < n; ++i)
if (f[1][ps][0] > f[1][i][0]) ps = i;
find(1, 0, ps, 0);
printf("%d\n", f[1][ps][0]);
for (i = 1; i <= n; ++i) printf("%d ", id[i]);
return 0;
}
void dfs(int u, int fa) {
int i, d, v, ww;
for (i = head[u]; i; i = e[i].nxt)
if ((v = e[i].v) != fa) {
dfs(v, u);
f[u][0][0] += (ww = min(f[v][1][1], f[v][0][0]));
if (f[v][1][1] == ww)
e[i].p[0][0] = 3;
else if (f[v][0][0] == ww)
e[i].p[0][0] = 0;
for (d = 1; d < n; ++d) {
ww = min(f[v][d + 1][1], min(f[v][d][0], f[v][d - 1][0]));
f[u][d][0] += ww;
f[u][d][1] += ww;
if (ww == f[v][d + 1][1])
e[i].p[d][0] = e[i].p[d][1] = (d + 1) * 2 + 1;
else if (ww == f[v][d][0])
e[i].p[d][0] = e[i].p[d][1] = d * 2;
else
e[i].p[d][0] = e[i].p[d][1] = (d - 1) * 2;
if (in[u][d] > f[v][d - 1][0] - ww) {
in[u][d] = f[v][d - 1][0] - ww;
pin[u][d] = i;
}
}
}
f[u][0][0] += nw;
for (d = 1; d < n; ++d) {
f[u][d][0] += in[u][d] + w[d];
f[u][d][1] += w[d];
e[pin[u][d]].p[d][0] = 2 * (d - 1);
}
}
void find(int u, int fa, int d, int fl) {
int i, v, ep;
if (!fl && !d)
id[u] = u;
else if (fl)
id[u] = id[fa];
for (i = head[u]; i; i = e[i].nxt)
if ((v = e[i].v) != fa)
if (!((ep = e[i].p[d][fl]) & 1)) {
find(v, u, ep >> 1, ep & 1);
if (!fl && d == (ep >> 1) + 1) id[u] = id[v];
}
for (i = head[u]; i; i = e[i].nxt)
if ((v = e[i].v) != fa)
if ((ep = e[i].p[d][fl]) & 1) find(v, u, ep >> 1, ep & 1);
}
void adde(int u, int v) {
e[++en].v = v;
e[en].nxt = head[u];
head[u] = en;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chmax(T &x, T y) {
x = x > y ? x : y;
}
template <class T>
void chmin(T &x, T y) {
x = x < y ? x : y;
}
const int maxn = 205;
int n, k;
int d[maxn], ans[maxn], choice[maxn];
int dp[maxn][maxn];
int dist[maxn][maxn];
vector<int> v[maxn];
void predfs(int pos, int fa, int *dis) {
for (int i = 0; i < (int)(v[pos]).size(); i++) {
int to = v[pos][i];
if (to == fa) continue;
dis[to] = dis[pos] + 1;
predfs(to, pos, dis);
}
}
void dfs(int pos, int fa) {
for (int i = 1; i <= n; i++) dp[pos][i] = d[dist[pos][i]] + k;
for (int i = 0; i < (int)(v[pos]).size(); i++) {
int to = v[pos][i];
if (to == fa) continue;
dfs(to, pos);
for (int j = 1; j <= n; j++)
dp[pos][j] += min(dp[to][choice[to]], dp[to][j] - k);
}
choice[pos] = min_element(dp[pos] + 1, dp[pos] + n + 1) - dp[pos];
return;
}
void print(int pos, int fa, int j) {
for (int i = 0, _j; i < (int)(v[pos]).size(); i++) {
int to = v[pos][i];
if (to == fa) continue;
if (dp[to][choice[to]] < dp[to][j] - k) {
_j = choice[to];
} else {
_j = j;
}
ans[to] = _j;
print(to, pos, _j);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n - 1; i++) cin >> d[i];
for (int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) predfs(i, 0, dist[i]);
dfs(1, 0);
cout << dp[1][choice[1]] << endl;
print(1, 0, choice[1]);
ans[1] = choice[1];
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int d[200], f[200][200];
int c[200];
int dis[200][200];
long long fa[200];
int ans[200];
void floyed() {
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
void dfs_1(int x) {
for (int i = 1; i <= n; ++i) f[x][i] = d[dis[x][i]] + m;
for (int i = 1; i <= n; ++i) {
if (dis[x][i] == 1 && (fa[x] != i)) {
fa[i] = x;
dfs_1(i);
for (int j = 1; j <= n; ++j) f[x][j] += min(f[i][j] - m, f[i][c[i]]);
}
}
c[x] = 1;
for (int i = 1; i <= n; ++i)
if (f[x][c[x]] > f[x][i]) c[x] = i;
}
void dfs_2(int x, int y) {
ans[x] = y;
for (int i = 1; i <= n; ++i) {
if (dis[i][x] == 1 && (fa[i] == x)) {
if (f[i][y] - m >= f[i][c[i]])
dfs_2(i, c[i]);
else
dfs_2(i, y);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n - 1; ++i) scanf("%d", &d[i]);
memset(dis, 53, sizeof(dis));
for (int i = 1; i <= n - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
dis[x][y] = 1;
dis[y][x] = 1;
}
for (int i = 1; i <= n; ++i) dis[i][i] = 0;
floyed();
dfs_1(1);
cout << f[1][c[1]] << endl;
dfs_2(1, c[1]);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[222];
int n, k, d[222], x, y, dis[222][222], dp[222][222], gg[222], beg[222], en[222],
ct, mn, ans[222];
void dfs(int i, int rt, int fa, int dep) {
dis[rt][i] = d[dep];
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (to == fa) continue;
dfs(to, rt, i, dep + 1);
}
}
void dfss(int i, int fa) {
beg[i] = ++ct;
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (to == fa) continue;
dfss(to, i);
}
en[i] = ct;
mn = 1e9;
for (int j = 1; j <= n; j++) {
dp[i][j] = k + dis[i][j];
for (int h = 0; h < g[i].size(); h++) {
int to = g[i][h];
if (to == fa) continue;
dp[i][j] += min(dp[to][j] - k, dp[to][gg[to]]);
}
if (beg[j] && beg[j] >= beg[i] && beg[j] <= en[i]) {
if (dp[i][j] < mn) {
mn = dp[i][j];
gg[i] = j;
}
}
}
}
void dft(int i, int fa, int bestu) {
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (to == fa) continue;
if (dp[to][gg[to]] > dp[to][bestu] - k) {
ans[to] = bestu;
dft(to, i, bestu);
} else {
ans[to] = gg[to];
dft(to, i, gg[to]);
}
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
dfs(i, i, 0, 0);
}
dfss(1, 0);
printf("%d\n", dp[1][gg[1]]);
dft(1, 0, gg[1]);
ans[1] = gg[1];
for (int j = 1; j <= n; j++) printf("%d ", ans[j]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:200000000")
using namespace std;
const int MAXN = 190;
const long long INF = (long long)1E18;
int n, w, cost[MAXN * 2];
vector<int> g[MAXN], gorig[MAXN];
void dfs(int v, int par = -1) {
if (par != -1) g[v].erase(find(g[v].begin(), g[v].end(), par));
for (size_t i = 0; i < g[v].size(); ++i) dfs(g[v][i], v);
}
long long d[MAXN][MAXN * 2], d2[MAXN][MAXN * 2], d3[MAXN][MAXN * 2];
bool ans[MAXN];
long long get_d(int v, int k);
long long get_d2(int v, int k);
long long get_d3(int v, int p) {
long long& my = d3[v][p];
if (my != -1) return my;
my = INF;
long long sum = cost[p];
for (size_t i = 0; i < g[v].size(); ++i) sum += get_d(g[v][i], p + 1);
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
long long nd = sum - get_d(to, p + 1) + get_d2(to, p - 1);
my = min(my, nd);
}
if (p - 1 >= 1) my = min(my, get_d3(v, p - 1));
return my;
}
long long get_d(int v, int k) {
long long& my = d[v][k];
if (my != -1) return my;
my = INF;
if (k != 0) my = min(my, get_d(v, 0) + w);
long long nd = cost[k];
for (size_t i = 0; i < g[v].size(); ++i) nd += get_d(g[v][i], k + 1);
my = min(my, nd);
if (k - 1 >= 1) my = min(my, get_d3(v, k - 1));
return my;
}
long long get_d2(int v, int k) {
long long& my = d2[v][k];
if (my != -1) return my;
my = INF;
if (k == 0)
my = w + get_d(v, 0);
else {
long long sum = cost[k];
for (size_t i = 0; i < g[v].size(); ++i) sum += get_d(g[v][i], k + 1);
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
long long nd = sum - get_d(to, k + 1) + get_d2(to, k - 1);
my = min(my, nd);
}
}
return my;
}
void restore_d2(int v, int k);
void restore_d(int v, int k) {
long long my = get_d(v, k);
if (k != 0 && my == get_d(v, 0) + w) {
ans[v] = true;
return restore_d(v, 0);
}
long long nd = cost[k];
for (size_t i = 0; i < g[v].size(); ++i) nd += get_d(g[v][i], k + 1);
if (my == nd) {
for (size_t i = 0; i < g[v].size(); ++i) restore_d(g[v][i], k + 1);
return;
}
for (int p = 1; p < k; ++p) {
long long sum = cost[p];
for (size_t i = 0; i < g[v].size(); ++i) sum += get_d(g[v][i], p + 1);
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
long long nd = sum - get_d(to, p + 1) + get_d2(to, p - 1);
if (my == nd) {
for (size_t j = 0; j < g[v].size(); ++j) {
int to = g[v][j];
if (i == j)
restore_d2(to, p - 1);
else
restore_d(to, p + 1);
}
return;
}
}
}
throw;
}
void restore_d2(int v, int k) {
long long my = get_d2(v, k);
if (k == 0) {
ans[v] = true;
return restore_d(v, 0);
} else {
long long sum = cost[k];
for (size_t i = 0; i < g[v].size(); ++i) sum += get_d(g[v][i], k + 1);
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
long long nd = sum - get_d(to, k + 1) + get_d2(to, k - 1);
if (my == nd) {
for (size_t j = 0; j < g[v].size(); ++j) {
int to = g[v][j];
if (i == j)
restore_d2(to, k - 1);
else
restore_d(to, k + 1);
}
return;
}
}
}
throw;
}
int bfs(int v) {
static int q[MAXN], u[MAXN], cu = 0;
int qh = 0, qt = 0;
q[qt++] = v;
u[v] = ++cu;
while (qh != qt) {
int v = q[qh++];
if (ans[v]) return v;
for (size_t i = 0; i < gorig[v].size(); ++i) {
int to = gorig[v][i];
if (u[to] != cu) {
u[to] = cu;
q[qt++] = to;
}
}
}
throw;
}
int main() {
cin >> n >> w;
for (int i = 1; i < n; ++i) cin >> cost[i];
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < n; ++i) gorig[i] = g[i];
dfs(0);
for (int i = n; i < 2 * MAXN; ++i) cost[i] = 1000000000;
memset(d, -1, sizeof d);
memset(d2, -1, sizeof d2);
memset(d3, -1, sizeof d3);
long long res = get_d(0, n);
cout << res << endl;
restore_d(0, n);
for (int i = 0; i < n; ++i) {
int res;
if (ans[i])
res = i;
else
res = bfs(i);
cout << res + 1 << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dis[190][190];
vector<int> G[190];
int dp[190][190];
int d[190];
int opt[190];
int ans[190];
int n, k;
void dfs(int x, int p, int rt) {
for (int i = 0; i < (int)G[x].size(); i++) {
int y = G[x][i];
if (y == p) continue;
dis[rt][y] = dis[rt][x] + 1;
dfs(y, x, rt);
}
}
void solve(int x, int p) {
for (int i = 1; i <= n; i++) dp[x][i] = d[dis[x][i]];
for (int i = 0; i < (int)G[x].size(); i++) {
int y = G[x][i];
if (y == p) continue;
solve(y, x);
for (int j = 1; j <= n; j++) dp[x][j] += min(dp[y][j], dp[y][opt[y]] + k);
}
for (int i = 1; i <= n; i++) {
if (!opt[x] || dp[x][i] < dp[x][opt[x]]) opt[x] = i;
}
}
void getans(int x, int p, int col) {
ans[x] = col;
for (int i = 0; i < (int)G[x].size(); i++) {
int y = G[x][i];
if (y == p) continue;
int ncol = col;
if (dp[y][opt[y]] + k < dp[y][col]) ncol = opt[y];
getans(y, x, ncol);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", d + i);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = 1; i <= n; i++) dfs(i, 0, i);
solve(1, 0);
printf("%d\n", dp[1][opt[1]] + k);
getans(1, 0, opt[1]);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x * f;
}
const int N = 200;
struct edge {
int v, nxt;
} e[N << 1];
int head[N], cnt, n, m, k, x, y, mp[N][N], f[N][N], pos[N], ans[N], d[N];
inline void add(int u, int v) {
e[++cnt].v = v;
e[cnt].nxt = head[u];
head[u] = cnt;
}
inline void Floyd() {
for (int i = 1; i <= n; ++i) mp[i][i] = 0;
for (int k = 1; k <= n; ++k) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (i != j && j != k && k != i) {
mp[i][j] = min(mp[i][j], mp[i][k] + mp[k][j]);
}
}
}
}
}
inline void dfs(int u, int fa) {
for (int i = 1; i <= n; ++i) f[i][u] = d[mp[i][u]] + k;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
dfs(v, u);
for (int j = 1; j <= n; ++j) f[j][u] += min(f[pos[v]][v], f[j][v] - k);
}
pos[u] = 1;
for (int i = 1; i <= n; ++i)
if (f[i][u] < f[pos[u]][u]) pos[u] = i;
}
inline void work(int u, int fa, int p) {
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
work(v, u, ans[v] = (f[pos[v]][v] > f[p][v] - k ? p : pos[v]));
}
}
int main() {
n = read();
k = read();
for (int i = 1; i < n; ++i) d[i] = read();
memset(mp, 31, sizeof(mp));
for (int i = 1; i < n; ++i) {
x = read();
y = read();
add(x, y);
add(y, x);
mp[x][y] = mp[y][x] = 1;
}
Floyd();
dfs(1, 0);
printf("%d\n", f[pos[1]][1]);
ans[1] = pos[1];
work(1, 0, ans[1]);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NR = 180 + 5;
const int MR = 1e5 + 5;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
inline int read() {
int x = 0;
int bei = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') bei = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * bei;
}
int dis[NR][NR];
int d[NR];
int n, m;
struct Edge {
int v, nxt;
} g[NR << 1];
int fte[NR], gsz;
void adde(int u, int v) {
g[++gsz] = (Edge){v, fte[u]};
fte[u] = gsz;
}
int dp[NR][NR];
int opt[NR];
void DP(int x, int fa) {
for (int i = 1; i <= n; ++i) dp[x][i] = d[dis[x][i]];
for (int i = fte[x]; i; i = g[i].nxt) {
int y = g[i].v;
if (y == fa) continue;
DP(y, x);
for (int j = 1; j <= n; ++j) dp[x][j] += min(dp[y][j], dp[y][opt[y]] + m);
}
int minn = INF;
for (int i = 1; i <= n; ++i)
if (dp[x][i] < minn) minn = dp[x][i], opt[x] = i;
}
int ans[NR];
void make_ans(int x, int fa, int wkj) {
ans[x] = wkj;
for (int i = fte[x]; i; i = g[i].nxt) {
int y = g[i].v;
if (y == fa) continue;
make_ans(y, x, dp[y][wkj] < dp[y][opt[y]] + m ? wkj : opt[y]);
}
}
int main() {
memset(dis, 0x3f, sizeof(dis));
n = read(), m = read();
for (int i = 1; i < n; ++i) d[i] = read();
for (int i = 1; i < n; ++i) {
int u = read(), v = read();
dis[u][v] = dis[v][u] = 1;
adde(u, v), adde(v, u);
}
for (int i = 1; i <= n; ++i) dis[i][i] = 0;
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
DP(1, 0);
printf("%d\n", dp[1][opt[1]] + m);
make_ans(1, 0, opt[1]);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, v, f[201][201], dis[201][201], a[201], b[201], c[201];
void dfs(int x, int fa) {
int i, j;
for (i = 1; i <= n; i++) f[x][i] = a[dis[x][i]] + v;
for (i = 1; i <= n; i++)
if (dis[x][i] == 1 && i != fa) {
dfs(i, x);
for (j = 1; j <= n; j++) f[x][j] += min(f[i][j] - v, f[i][b[i]]);
}
f[x][0] = 1e9;
for (i = 1; i <= n; i++)
if (f[x][i] < f[x][b[x]]) b[x] = i;
}
void getans(int x, int fa, int now) {
int i;
c[x] = now;
for (i = 1; i <= n; i++)
if (dis[x][i] == 1 && i != fa)
getans(i, x, f[i][now] - v < f[i][b[i]] ? now : b[i]);
}
int main() {
int i, ii, j, t, k;
scanf("%d%d", &n, &v);
memset(dis, 44, sizeof(dis));
for (i = 1; i <= n; i++) dis[i][i] = 0;
for (i = 1; i < n; i++) scanf("%d", &a[i]);
for (i = 1; i < n; i++) {
scanf("%d%d", &t, &k);
dis[t][k] = dis[k][t] = 1;
}
for (ii = 1; ii <= n; ii++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][ii] + dis[ii][j]);
dfs(1, 0);
printf("%d\n", f[1][b[1]]);
getans(1, 0, b[1]);
for (i = 1; i <= n; i++) printf("%d ", c[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, c[201], d[201][201], dp[201][201], ans[201];
vector<int> w[201], node;
void dfs(int u, int p) {
for (int v : w[u])
if (v != p) dfs(v, u);
int best = 1 << 30;
for (int i = 1; i <= n; i++) {
dp[u][i] = c[d[u][i]];
for (int v : w[u])
if (v != p) dp[u][i] += min(dp[v][i], dp[v][ans[v]] + q);
if (best > dp[u][i]) best = dp[u][i], ans[u] = i;
}
}
void fill(int u, int i, int p) {
for (int v : w[u])
if (v != p)
dp[v][i] > dp[v][ans[v]] + q ? node.push_back(ans[v]),
fill(v, ans[v], u) : fill(v, i, u);
}
int main() {
cin >> n >> q;
for (int i = 1; i < n; i++) cin >> c[i];
memset(d, 0x3f, sizeof d);
for (int i = 1, x, y; i < n; i++)
cin >> x >> y, w[x].push_back(y), w[y].push_back(x), d[x][y] = d[y][x] = 1;
for (int i = 1; i <= n; i++) d[i][i] = 0;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
dfs(1, 0);
cout << dp[1][ans[1]] + q << '\n';
node.push_back(ans[1]);
fill(1, ans[1], 0);
for (int i = 1; i <= n; i++) {
int dist = 1 << 30, pos = -1;
for (int u : node) dist > d[i][u] ? dist = d[i][u], pos = u : 0;
cout << pos << ' ';
}
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int Imx = 2147483647;
const long long Lbig = 2e18;
const int mod = 1e9 + 7;
struct fastio {
char s[100000];
int it, len;
fastio() { it = len = 0; }
inline char get() {
if (it < len) return s[it++];
it = 0;
len = fread(s, 1, 100000, stdin);
if (len == 0)
return EOF;
else
return s[it++];
}
bool notend() {
char c = get();
while (c == ' ' || c == '\n') c = get();
if (it > 0) it--;
return c != EOF;
}
} _buff;
inline long long getnum() {
long long r = 0;
bool ng = 0;
char c;
c = _buff.get();
while (c != '-' && (c < '0' || c > '9')) c = _buff.get();
if (c == '-') ng = 1, c = _buff.get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = _buff.get();
return ng ? -r : r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline char getreal() {
char c = _buff.get();
while (c <= 32) c = _buff.get();
return c;
}
int tot = 0;
int ti[1000000], tj[1000000], tk[1000000];
vector<int> pv[1000000];
struct value {
int v;
int id;
void update(value a) {
if (a.v < v) {
v = a.v;
pv[id].clear();
pv[id].push_back(a.id);
}
}
void update(value a, value b) {
if (a.v + b.v < v) {
v = a.v + b.v;
pv[id].clear();
pv[id].push_back(a.id);
pv[id].push_back(b.id);
}
}
};
value newv(int i = -1, int j = -1, int k = -1) {
value ret;
ret.id = ++tot;
ret.v = 1 << 29;
ti[tot] = i;
tj[tot] = j;
tk[tot] = k;
return ret;
}
int n, m;
int cd[233];
vector<int> con[233];
value dp[233][233][3];
void dfs(int x, int pre = -1) {
for (int i = 0; i <= n + 2; i++) {
dp[x][i][0] = newv(x, i, 0);
dp[x][i][1] = newv(x, i, 1);
}
for (int i = 0; i < con[x].size(); i++) {
int u = con[x][i];
if (u == pre) continue;
dfs(u, x);
}
for (int d = 1; d <= n; d++) {
value wu0 = newv();
value wu1 = newv();
value wd = newv();
wu0.v = cd[d];
wu1.v = 1 << 28;
wd.v = cd[d];
for (int i = 0; i < con[x].size(); i++) {
int u = con[x][i];
if (u == pre) continue;
value nwd = newv();
nwd.update(wd, dp[u][d + 1][1]);
nwd.update(wd, dp[u][d][0]);
value nwu1 = newv();
value tmp = newv();
tmp.update(wu0, dp[u][d - 1][0]);
tmp.update(wu1, dp[u][d - 1][0]);
value tmp2 = newv();
tmp2.update(dp[u][d + 1][1]);
tmp2.update(dp[u][d][0]);
nwu1.update(wu1, tmp2);
nwu1.update(tmp);
value nwu0 = newv();
nwu0.update(wu0, tmp2);
swap(wu0, nwu0);
swap(wu1, nwu1);
swap(wd, nwd);
}
dp[x][d][0].update(wu1);
dp[x][d][1].update(wd);
}
dp[x][0][0].v = cd[0];
for (int i = 0; i < con[x].size(); i++) {
int u = con[x][i];
if (u == pre) continue;
value nv = newv();
nv.update(dp[x][0][0], dp[u][1][1]);
nv.update(dp[x][0][0], dp[u][0][0]);
swap(nv, dp[x][0][0]);
}
for (int i = n; i >= 0; i--) {
dp[x][i][1].update(dp[x][i][0]);
}
}
bool vis[1000000];
bool center[233];
void findans(int x) {
vis[x] = 1;
for (int i = 0; i < pv[x].size(); i++) {
if (!vis[pv[x][i]]) {
findans(pv[x][i]);
}
}
if (tj[x] == 0) {
center[ti[x]] = 1;
}
}
int q[233], qn;
int g[233];
int main() {
n = getnum(), cd[0] = getnum();
for (int i = 1; i < n; i++) cd[i] = getnum();
for (int i = 1; i < n; i++) {
int x, y;
x = getnum(), y = getnum();
con[x].push_back(y);
con[y].push_back(x);
}
dfs(1);
int mn = mod, mnid = 0;
for (int i = 0; i <= n; i++) {
if (dp[1][i][0].v < mn) {
mn = dp[1][i][0].v;
mnid = i;
}
}
cout << mn << endl;
findans(dp[1][mnid][0].id);
for (int i = 1; i <= n; i++) {
vis[i] = 0;
if (center[i]) {
q[qn++] = i;
g[i] = i;
vis[i] = 1;
}
}
for (int i = 0; i < qn; i++) {
int u = q[i];
for (int j = 0; j < con[u].size(); j++) {
int v = con[u][j];
if (!vis[v]) {
vis[v] = 1;
g[v] = g[u];
q[qn++] = v;
}
}
}
for (int i = 1; i <= n; i++) cout << g[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000, maxN = 185;
int n, K, d[maxN], dis[maxN][maxN], m[maxN][maxN], dp[maxN][maxN], ans[maxN],
path[maxN];
void dfs(int u, int fa) {
for (int i = 1; i <= n; i++) dp[u][i] = d[dis[u][i]] + K;
for (int v = 1; v <= n; v++)
if (m[u][v] && v != fa) {
dfs(v, u);
for (int i = 1; i <= n; i++) dp[u][i] += min(dp[v][ans[v]], dp[v][i] - K);
}
ans[u] = 1;
for (int i = 2; i <= n; i++)
if (dp[u][i] < dp[u][ans[u]]) ans[u] = i;
}
void output(int u, int fa, int i) {
path[u] = i;
for (int v = 1; v <= n; v++)
if (m[u][v] && v != fa) {
if (dp[v][ans[v]] < dp[v][i] - K)
output(v, u, ans[v]);
else
output(v, u, i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> K;
for (int i = 1; i < n; i++) cin >> d[i];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j)
dis[i][j] = INF;
else
dis[i][j] = 0;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
m[u][v] = m[v][u] = 1;
dis[u][v] = dis[v][u] = 1;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(1, 0);
printf("%d\n", dp[1][ans[1]]);
output(1, 0, ans[1]);
for (int i = 1; i <= n; i++) printf("%d%c", path[i], i == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct dpval {
long long sum;
int dis, ind;
dpval() {
sum = (1000000000);
dis = -1;
ind = -1;
}
};
int n;
int d[188];
vector<int> g[188], gg[188];
dpval dp[188][188][2];
bool is[188];
void build(int x, int pre) {
for (int i = (0); i < (g[x].size()); ++i) {
int to = g[x][i];
if (to == pre) {
g[x].erase(g[x].begin() + i, g[x].begin() + i + 1);
i--;
continue;
}
build(to, x);
}
}
dpval dfs(int x, int dis, bool dodo) {
if (dis >= n || dis < 0) {
return dpval();
}
dpval &res = dp[x][dis][dodo];
if (res.sum < (1000000000)) return res;
if (dis == 0 && dodo) {
dpval cur;
cur.sum = d[0];
cur.dis = 0;
for (int i = (0); i < (g[x].size()); ++i) {
int to = g[x][i];
cur.sum += dfs(to, 1, 0).sum;
}
if (res.sum > cur.sum) res = cur;
return res;
}
for (int i = (0); i < (dis); ++i) {
dpval cur = dfs(x, i, 1);
if (res.sum > cur.sum) res = cur;
}
if (dodo) {
dpval tmp;
tmp.sum = d[dis];
tmp.dis = dis;
for (int i = (0); i < (g[x].size()); ++i) {
int to = g[x][i];
tmp.sum += dfs(to, dis + 1, 0).sum;
}
int mn = (1000000000), mnp;
for (int i = (0); i < (g[x].size()); ++i) {
int to = g[x][i];
int val = dfs(to, dis - 1, 1).sum - dfs(to, dis + 1, 0).sum;
if (val < mn) {
mn = val;
mnp = to;
}
}
tmp.sum += mn;
tmp.ind = mnp;
if (res.sum > tmp.sum) res = tmp;
} else {
dpval tmp;
tmp.sum = d[dis];
tmp.dis = dis;
for (int i = (0); i < (g[x].size()); ++i) {
int to = g[x][i];
tmp.sum += dfs(to, dis + 1, 0).sum;
}
if (res.sum > tmp.sum) res = tmp;
}
return res;
}
void calc(int x, int dis, bool dodo) {
dpval res = dfs(x, dis, dodo);
if (res.dis == 0) is[x] = 1;
dis = res.dis;
for (int i = (0); i < (g[x].size()); ++i) {
int to = g[x][i];
if (to == res.ind)
calc(to, dis - 1, 1);
else
calc(to, dis + 1, 0);
}
}
int getans(int x) {
queue<int> q;
bool vis[188] = {};
q.push(x);
while (!q.empty()) {
int x = q.front();
vis[x] = 1;
q.pop();
if (is[x]) return x;
for (int i = (0); i < (gg[x].size()); ++i) {
int to = gg[x][i];
if (!vis[to]) q.push(to);
}
}
}
int main() {
cin >> n;
for (int i = (0); i < (n); ++i) cin >> d[i];
for (int i = (1); i < (n); ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = (0); i < (n); ++i) gg[i] = g[i];
build(0, -1);
int ans = (1000000000), dis;
for (int i = (0); i < (n); ++i) {
dpval res = dfs(0, i, 1);
if (res.sum < ans) {
ans = res.sum;
dis = i;
}
}
calc(0, dis, 1);
cout << ans << endl;
for (int i = (0); i < (n); ++i) {
cout << getans(i) + 1 << (i == n - 1 ? "\n" : " ");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, K;
int d[185];
long long f[185][185];
int trace[185][185];
int depth[185], par[185], start[185], finish[185], num = 0;
vector<int> adj[185];
int output[185];
long long INF = 1LL << 55;
void DFS(int u, int pre) {
int preIdx = -1;
start[u] = num++;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == pre)
preIdx = i;
else {
par[v] = u;
depth[v] = 1 + depth[u];
DFS(v, u);
}
}
if (preIdx >= 0) adj[u].erase(adj[u].begin() + preIdx);
finish[u] = num++;
}
bool isParent(int u, int v) {
return (start[u] < start[v] && finish[v] < finish[u]);
}
long long rec(int u, int far) {
if (f[u][far] >= 0) return f[u][far];
f[u][far] = 0;
for (int v = 1; v <= n; v++)
if (u == v || isParent(u, v)) {
int len = far + depth[v] - depth[u];
f[u][far] += (len >= n) ? INF : d[len];
}
long long tmp = K;
for (int i = 0; i < adj[u].size(); i++) tmp += rec(adj[u][i], 1);
if (tmp < f[u][far]) {
f[u][far] = tmp;
trace[u][far] = u;
}
for (int v = 1; v <= n; v++)
if (isParent(u, v)) {
int jump = 0, x = v;
tmp = K;
for (int i = 0; i < adj[v].size(); i++) tmp += rec(adj[v][i], 1);
while (1) {
jump++;
int y = par[x];
tmp += d[min(jump, far + depth[y] - depth[u])];
for (int i = 0; i < adj[y].size(); i++)
if (adj[y][i] != x)
tmp += rec(adj[y][i],
min(jump + 1, depth[adj[y][i]] - depth[u] + far));
x = y;
if (x == u) break;
}
if (tmp < f[u][far]) {
f[u][far] = tmp;
trace[u][far] = v;
}
}
return f[u][far];
}
void track(int u, int far, int origin) {
if (trace[u][far] < 0) {
for (int v = 1; v <= n; v++)
if (v == u || isParent(u, v)) output[v] = origin;
return;
}
int v = trace[u][far];
int jump = 0, x = v;
output[v] = v;
for (int i = 0; i < adj[v].size(); i++) track(adj[v][i], 1, v);
while (x != u) {
jump++;
int y = par[x];
if (jump < far + depth[y] - depth[u])
output[y] = v;
else
output[y] = origin;
for (int i = 0; i < adj[y].size(); i++)
if (adj[y][i] != x) {
if (jump + 1 <= far + depth[adj[y][i]] - depth[u])
track(adj[y][i], jump + 1, v);
else
track(adj[y][i], far + depth[adj[y][i]] - depth[u], origin);
}
x = y;
}
}
int main() {
scanf("%d %d", &n, &K);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
DFS(1, -1);
memset(f, -1, sizeof(f));
memset(trace, -1, sizeof(trace));
cout << rec(1, n) << endl;
track(1, n, -1);
for (int i = 1; i <= n; i++) printf("%d ", output[i]);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, d[200], g[200][200], dp[200][200], ans[200];
int cnt, st[200], ed[200];
bool flag[200];
void dfs1(int u) {
flag[u] = true;
st[u] = ++cnt;
for (int i = 1; i <= n; i++)
if (g[u][i] == 1 && !flag[i]) dfs1(i);
ed[u] = ++cnt;
}
void dfs2(int u) {
flag[u] = true;
for (int i = 1; i <= n; i++)
if (i ^ u) dp[u][i] = d[g[u][i]];
dp[u][u] = m;
for (int i = 1; i <= n; i++)
if (g[u][i] == 1 && !flag[i]) {
dfs2(i);
for (int j = 1; j <= n; j++)
if (st[i] <= st[j] && ed[j] <= ed[i])
dp[u][j] += dp[i][j];
else
dp[u][j] += min(dp[i][j], dp[i][dp[i][0]]);
}
dp[u][0] = u;
for (int i = 1; i <= n; i++)
if (st[u] <= st[i] && ed[i] <= ed[u] && dp[u][i] < dp[u][dp[u][0]])
dp[u][0] = i;
}
void dfs3(int u) {
flag[u] = true;
for (int i = 1; i <= n; i++)
if (g[u][i] == 1 && !flag[i]) {
if (st[i] <= st[ans[u]] && ed[ans[u]] <= ed[i])
ans[i] = ans[u];
else if (dp[i][ans[u]] < dp[i][dp[i][0]])
ans[i] = ans[u];
else
ans[i] = dp[i][0];
dfs3(i);
}
}
void solve() {
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
memset(flag, false, sizeof(flag));
cnt = 0;
dfs1(1);
memset(flag, false, sizeof(flag));
dfs2(1);
ans[1] = dp[1][0];
memset(flag, false, sizeof(flag));
dfs3(1);
printf("%d\n", dp[1][dp[1][0]]);
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], i < n ? ' ' : '\n');
}
int main() {
int u, v;
while (scanf("%d%d", &n, &m) == 2) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) g[i][j] = 1000000000;
for (int i = 1; i < n; i++) scanf("%d", d + i);
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
g[u][v] = g[v][u] = 1;
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
bool vis[200][200];
int dis[200][200], ans[200], d[200], dp[200][200], Ans[200];
void dfs(int u, int fa) {
for (int i = 1; i <= n; i++) dp[u][i] = d[dis[u][i]] + k;
for (int v = 1; v <= n; v++) {
if (v != fa && vis[u][v]) {
dfs(v, u);
for (int j = 1; j <= n; j++) dp[u][j] += min(dp[v][j] - k, dp[v][ans[v]]);
}
}
ans[u] = 1;
for (int i = 2; i <= n; i++)
if (dp[u][i] < dp[u][ans[u]]) ans[u] = i;
}
void dfs2(int u, int fa, int A) {
Ans[u] = A;
for (int i = 1; i <= n; i++) {
if (i == fa || !vis[u][i]) continue;
if (dp[i][ans[i]] < dp[i][A] - k)
dfs2(i, u, ans[i]);
else
dfs2(i, u, A);
}
}
int main() {
int a, b;
memset(dis, 0x3f3f3f3f, sizeof(dis));
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", &d[i]), dis[i][i] = 0;
;
dis[n][n] = 0;
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
dis[a][b] = dis[b][a] = 1;
vis[a][b] = vis[b][a] = 1;
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
if (i == k) continue;
for (int j = 1; j <= n; j++) {
if (i == j || k == j) continue;
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
dfs(1, 0);
printf("%d\n", dp[1][ans[1]]);
dfs2(1, 0, ans[1]);
for (int i = 1; i < n; i++) {
printf("%d ", Ans[i]);
}
printf("%d\n", Ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 203;
int n, k, cost[maxn], dis[maxn][maxn], e[maxn][maxn], pos[maxn], ans[maxn],
f[maxn][maxn];
void dfs(int u, int pre) {
for (int i = 1; i <= n; ++i) f[i][u] = cost[dis[i][u]] + k;
for (int i = 1; i <= n; ++i) {
if (e[u][i] && i != pre) {
dfs(i, u);
for (int j = 1; j <= n; ++j) f[j][u] += min(f[pos[i]][i], f[j][i] - k);
}
}
pos[u] = 1;
for (int i = 1; i <= n; ++i)
if (f[i][u] < f[pos[u]][u]) pos[u] = i;
}
void getans(int u, int pre, int lastpos) {
for (int i = 1; i <= n; ++i) {
if (e[u][i] && i != pre) {
if (f[pos[i]][i] > f[lastpos][i] - k)
ans[i] = lastpos;
else
ans[i] = pos[i];
getans(i, u, ans[i]);
}
}
}
int main() {
memset(dis, 0x3f, sizeof(dis));
scanf("%d%d", &n, &k);
for (int i = 1; i < n; ++i) scanf("%d", &cost[i]);
for (int i = 1; i <= n; ++i) dis[i][i] = 0;
for (int i = 1; i < n; ++i) {
static int u, v;
scanf("%d%d", &u, &v);
e[u][v] = e[v][u] = 1;
dis[u][v] = dis[v][u] = 1;
}
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(1, 0);
printf("%d\n", f[ans[1] = pos[1]][1]);
getans(1, 0, pos[1]);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int d[188 * 2];
int first[188 * 2];
bool vis[188 * 2];
int nxt[188 * 2 * 2];
int last[188 * 2];
int to[188 * 2 * 2];
int cnt = 0;
int dp[188][188];
int op[188 * 2];
int dis[188 * 2][188 * 2];
const int INF = 1e9 + 7;
int depth[188 * 2];
int up[188 * 2][20];
int ans[188 * 2];
void addedge(int a, int b) {
if (!first[a])
first[a] = ++cnt;
else
nxt[last[a]] = ++cnt;
last[a] = cnt;
to[cnt] = b;
}
void dfs_deep(int u, int fa, int deep) {
depth[u] = deep;
up[u][0] = fa;
for (int q = first[u]; q; q = nxt[q])
if (to[q] != fa) dfs_deep(to[q], u, deep + 1);
}
void init() {
for (int j = 1; j <= 10; j++)
for (int i = 1; i <= n; i++) up[i][j] = up[up[i][j - 1]][j - 1];
}
int get_dis(int a, int dis) {
for (int base = 0; dis; dis >>= 1, base++)
if (dis & 1) a = up[a][base];
return a;
}
int lca(int a, int b) {
if (depth[a] < depth[b]) swap(a, b);
int f = depth[a] - depth[b];
a = get_dis(a, f);
if (a != b) {
for (int i = 10; i >= 0; i--)
if (up[a][i] != up[b][i]) a = up[a][i], b = up[b][i];
a = up[a][0];
}
return a;
}
void bfs(int a) {
queue<int> q1;
q1.push(a);
dis[a][a] = 0;
while (!q1.empty()) {
int f = q1.front();
q1.pop();
for (int q = first[f]; q; q = nxt[q]) {
if (!vis[to[q]]) {
dis[a][to[q]] = dis[a][f] + 1;
vis[to[q]] = 1;
q1.push(to[q]);
}
}
}
}
void dfs(int u, int fa) {
for (int q = first[u]; q; q = nxt[q])
if (to[q] != fa) {
dfs(to[q], u);
for (int i = 1; i <= n; i++) {
dp[i][u] += min(dp[op[to[q]]][to[q]], dp[i][to[q]] - k);
}
}
int MIN = INF;
for (int i = 1; i <= n; i++) {
if (dp[i][u] < MIN) {
MIN = dp[i][u];
op[u] = i;
}
}
}
void dfs_ans(int u, int fa, int now) {
if (u == 1)
ans[u] = op[u];
else {
if (dp[op[u]][u] < dp[now][u] - k)
ans[u] = op[u];
else
ans[u] = now;
}
for (int q = first[u]; q; q = nxt[q])
if (to[q] != fa) dfs_ans(to[q], u, ans[u]);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
addedge(a, b);
addedge(b, a);
}
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof(vis));
vis[i] = 1;
bfs(i);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j] = d[dis[i][j]] + k;
}
}
dfs(1, -1);
dfs_ans(1, -1, -1);
cout << dp[op[1]][1] << endl;
for (int i = 1; i <= n; i++) {
cout << ans[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, lst[205], to[405], pre[405], tot, cost[205];
int dp[205][205], dis[205][205], pos[205], ans[205];
inline void add_edge(int u, int v) {
to[tot] = v;
pre[tot] = lst[u];
lst[u] = tot++;
}
void dfs(int u, int fa = -1) {
for (int i = 0; i < n; i++) dp[u][i] = cost[dis[u][i]];
for (int i = lst[u]; ~i; i = pre[i]) {
int v = to[i];
if (v == fa) continue;
dfs(v, u);
for (int j = 0; j < n; j++) dp[u][j] += min(dp[v][j], dp[v][pos[v]] + k);
}
for (int i = 1; i < n; i++) {
if (dp[u][i] < dp[u][pos[u]]) pos[u] = i;
}
}
void upd(int u, int x, int fa = -1) {
ans[u] = x;
for (int i = lst[u]; ~i; i = pre[i]) {
int v = to[i];
if (v == fa) continue;
upd(v, dp[v][pos[v]] + k < dp[v][x] ? pos[v] : x, u);
}
}
int main() {
memset(lst, -1, sizeof(lst));
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", cost + i);
memset(dis, 0x3f, sizeof(dis));
for (int i = 0; i < n; i++) dis[i][i] = 0;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(--u, --v);
add_edge(v, u);
dis[u][v] = dis[v][u] = 1;
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
dis[i][j] = min(dis[i][k] + dis[k][j], dis[i][j]);
}
}
dfs(0);
upd(0, pos[0]);
printf("%d\n", dp[0][pos[0]] + k);
for (int i = 0; i < n; i++) printf("%d%c", ans[i] + 1, " \n"[i + 1 == n]);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 205, M = 405;
int n, k, tot, d[N], e[N][N], lnk[N], ter[M], nxt[M];
int dis[N][N], f[N][N], p[N], ans[N];
void add(int u, int v) { ter[++tot] = v, nxt[tot] = lnk[u], lnk[u] = tot; }
void Floyd() {
for (int k = 1; k <= n; ++k) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dis[i][j] = std::min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
}
void dfs(int u, int fa) {
for (int i = 1; i <= n; i++) {
f[i][u] = d[dis[i][u]] + k;
}
for (int i = lnk[u]; i; i = nxt[i]) {
int v = ter[i];
if (v == fa) continue;
dfs(v, u);
for (int i = 1; i <= n; i++) {
f[i][u] += std::min(f[p[v]][v], f[i][v] - k);
}
}
p[u] = 1;
for (int i = 1; i <= n; i++) {
if (f[i][u] < f[p[u]][u]) p[u] = i;
}
}
void getPath(int u, int fa, int pos) {
for (int i = lnk[u]; i; i = nxt[i]) {
int v = ter[i];
if (v == fa) continue;
ans[v] = (f[p[v]][v] > f[pos][v] - k ? pos : p[v]);
getPath(v, u, ans[v]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) {
scanf("%d", &d[i]);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dis[i][j] = (i == j ? 0 : 0x3f3f3f3f);
}
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
dis[u][v] = dis[v][u] = 1;
add(u, v), add(v, u);
}
Floyd();
dfs(1, 0);
printf("%d\n", f[p[1]][1]);
ans[1] = p[1];
getPath(1, 0, ans[1]);
for (int i = 1; i <= n; i++) {
printf("%d%c", ans[i], " \n"[i == n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
long long DP[200][200][400];
long long m[200][200][400];
long long d[800];
pair<int, int> sol[200][2];
vector<vector<int> > grafo;
long long calcdp(int n, int dup, int ddown, int p);
void calcmn(int n, int dup, int ddown, int p) {
m[n][dup][ddown] = DP[n][dup][ddown];
if (ddown < 2 * N) {
calcdp(n, dup, ddown + 1, p);
m[n][dup][ddown] = min(m[n][dup][ddown], m[n][dup][ddown + 1]);
}
}
long long calcdp(int n, int dup, int ddown, int p) {
if (DP[n][dup][ddown] != -1) return DP[n][dup][ddown];
long long &ans = DP[n][dup][ddown];
ans = d[min(dup, ddown)];
int vs = grafo[n].size();
long long prev0 = 0, prev1 = 1000000000000000LL;
int resto = (p != -1);
if (vs - resto == 0 && (ddown > 0 && ddown < dup)) {
ans = 1000000000000000LL;
calcmn(n, dup, ddown, p);
return 1000000000000000LL;
}
if (vs - resto == 0) {
ans = d[min(ddown, dup)];
calcmn(n, dup, ddown, p);
return ans;
}
if (ddown) {
for (int i = 0; i < (int)(vs); ++i) {
long long act0 = 1000000000000000LL, act1 = 1000000000000000LL;
int v = grafo[n][i];
int ndup = min(N, min(dup + 1, ddown + 1));
int dup1 = ndup;
if (ddown == 1) dup1 = 0;
if (v != p) {
act1 = min(act1, prev0 + calcdp(v, dup1, ddown - 1, n));
act1 = min(act1, prev1 + calcdp(v, dup1, ddown - 1, n));
calcdp(v, ndup, ddown, n);
act0 = min(act0, prev0 + m[v][ndup][ddown]);
act1 = min(act1, prev1 + m[v][ndup][ddown]);
prev1 = act1;
prev0 = act0;
}
}
ans += prev1;
} else {
long long resto = 0;
for (int i = 0; i < (int)(vs); ++i) {
int v = grafo[n][i];
if (v != p) {
long long act = 1000000000000000LL;
for (int j = 0; j < (int)(2 * N + 1); ++j) {
act = min(act, calcdp(v, 1, j, n));
}
resto += act;
}
}
ans += resto;
}
calcmn(n, dup, ddown, p);
return ans;
}
void construct(int n, int dup, int ddown, int p) {
sol[n][0] = make_pair(dup, ddown);
int vs = grafo[n].size();
long long prev0 = 0, prev1 = 1000000000000000LL;
if (ddown) {
int first1 = 0;
for (int i = 0; i < (int)(vs); ++i) {
long long act0 = 1000000000000000LL, act1 = 1000000000000000LL;
int v = grafo[n][i];
int ndup = min(N, min(dup + 1, ddown + 1));
int dup1 = ndup;
if (ddown == 1) dup1 = 0;
if (v != p) {
int best = ddown;
for (int j = ddown; j <= 2 * N; j++)
if (calcdp(v, ndup, j, n) < calcdp(v, ndup, best, n)) best = j;
act0 = min(act0, prev0 + m[v][ndup][ddown]);
act1 = min(act1, prev1 + m[v][ndup][ddown]);
sol[v][0] = make_pair(ndup, best);
sol[v][1] = make_pair(ndup, best);
if (prev1 + calcdp(v, dup1, ddown - 1, n) < act1) {
sol[v][1] = make_pair(dup1, ddown - 1);
act1 = min(act1, prev1 + calcdp(v, dup1, ddown - 1, n));
}
if (prev0 + calcdp(v, dup1, ddown - 1, n) < act1) {
first1 = i;
sol[v][1] = make_pair(dup1, ddown - 1);
act1 = min(act1, prev0 + calcdp(v, dup1, ddown - 1, n));
}
prev1 = act1;
prev0 = act0;
}
}
for (int i = 0; i < (int)(vs); ++i) {
int v = grafo[n][i];
if (v != p) {
if (i < first1) {
construct(v, sol[v][0].first, sol[v][0].second, n);
} else {
construct(v, sol[v][1].first, sol[v][1].second, n);
}
}
}
} else {
for (int i = 0; i < (int)(vs); ++i) {
int v = grafo[n][i];
if (v != p) {
long long act = 1000000000000000LL;
for (int j = 0; j < (int)(2 * N + 1); ++j) {
if (act > calcdp(v, 1, j, n)) {
sol[v][0] = make_pair(1, j);
act = min(act, calcdp(v, 1, j, n));
}
}
construct(v, sol[v][0].first, sol[v][0].second, n);
}
}
}
}
int ans[200];
int main() {
cin >> N >> d[0];
for (int i = 0; i < (int)(N - 1); ++i) cin >> d[i + 1];
grafo.resize(N);
for (int i = 0; i < (int)(N - 1); ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
grafo[a].push_back(b);
grafo[b].push_back(a);
}
long long res = 1000000000000000LL;
memset(DP, -1, sizeof(DP));
for (int k = N; k <= 3 * N; k++) d[k] = 1000000;
int bestj = 0;
for (int j = 0; j < (int)(N + 1); ++j) {
if (calcdp(0, N, j, -1) < res) {
bestj = j;
}
res = min(res, calcdp(0, N, j, -1));
}
cout << res << endl;
construct(0, N, bestj, -1);
memset(ans, -1, sizeof(ans));
queue<int> bfs;
for (int i = 0; i < (int)(N); ++i) {
if (!sol[i][0].second) {
ans[i] = i + 1;
bfs.push(i);
}
}
while (!bfs.empty()) {
int a = bfs.front(), vs = grafo[a].size();
for (int i = 0; i < (int)(vs); ++i) {
int next = grafo[a][i];
if (ans[next] == -1) {
ans[next] = ans[a];
bfs.push(next);
}
}
bfs.pop();
}
for (int i = 0; i < (int)(N); ++i) {
if (i) cout << " ";
cout << ans[i];
}
cout << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.