# luogu P2495 [SDOI2011]消耗战

```/*
luogu P2495 [SDOI2011]消耗战

虚树+树形dp

首先对原图构建出虚树

在建图的时候处理出最小值
转移即可

小技巧
在dp的过程中可以顺便把边表清空
将边结构体封装可方便的建多张图
*/
#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>

#define INF 1e17

{
register char c = getchar ();
for (now = 0; !isdigit (c); c = getchar ());
for (; isdigit (c); now = now * 10 + c - ‘0‘, c = getchar ());
}
#define Max 1000010

struct Edge
{
int to, next, w;
Edge (int _x, int _y, int _z) : to (_x), next (_y), w (_z) {}
Edge () {}
};

int N, M;
long long value[Max];
int dfn[Max], Count;
struct Graph
{
Edge e[Max << 1];
int C;
Graph () { C = 0;}

int list[Max];
inline void Clear ()
{
C = 0;
}
inline void Add_Edge (int from, int to, int dis)
{
if (from == to) return ;
e[++ C].to = to;
e[C].next = list[from];
list[from] = C;
e[C].w = dis;
}
inline void Add_Edge (int from, int to)
{
if (from == to) return ;
e[++ C].to = to;
e[C].next = list[from];
list[from] = C;
}
};

inline void swap (int &x, int &y)
{
int now = x;
x = y;
y = now;
}

inline long long min (int x, long long y)
{
return x < y ? x : y;
}

class Tree_Chain_Get
{
private :
Graph G;
int  size[Max], chain[Max], father[Max], son[Max];

public :

int deep[Max];

void Dfs_1 (int now, int Father)
{
size[now] = 1;
dfn[now] = ++ Count;
for (int i = G.list[now]; i; i = G.e[i].next)
if (G.e[i].to != Father)
{
Dfs_1 (G.e[i].to, now);
father[now] = Father;
size[now] += size[G.e[i].to];
deep[now] = deep[Father] + 1;
value[G.e[i].to] = min (G.e[i].w, value[now]);
if (size[son[now]] < size[G.e[i].to])
son[now] = G.e[i].to;
}
}

void Dfs_2 (int now, int point)
{
chain[now] = point;
if (son[now])
Dfs_2 (son[now], point);
else return ;
for (int i = G.list[now]; i; i = G.e[i].next)
if (G.e[i].to != son[now] && G.e[i].to != father[now])
Dfs_2 (G.e[i].to, G.e[i].to);
}

int Get_Lca (int x, int y)
{
for (; chain[x] != chain[y]; )
{
if (deep[chain[x]] < deep[chain[y]])
swap (x, y);
x = father[chain[x]];
}
return deep[x] < deep[y] ? x : y;
}

inline void Insert_edges (const int L)
{
for (int i = 1, x, y, z; i <= L; ++ i)
{
}
value[1] = INF;
deep[1] = 0;
Dfs_1 (1, 0);
Dfs_2 (1, 1);
}
};
Tree_Chain_Get Lca;

inline bool Comp (const int &x, const int &y)
{
return dfn[x] < dfn[y];
}

class Virtual_Tree
{
private : Graph T; int Stack[Max], top;
long long dp[Max];
int queue[Max];

public :

Virtual_Tree () {top = 0;}

void Build_Tree ()
{
int M;
for (int i = 1; i <= M; ++ i)
std :: sort (queue + 1, queue + 1 + M, Comp);
int cur = 0;
for (int i = 2; i <= M; ++ i)
if (Lca.Get_Lca (queue[i], queue[cur]) != queue[cur])
queue[++ cur] = queue[i];
int top = 0;
Stack[++ top] = 1;
int __lca;
T.Clear ();
for (int i = 1; i <= cur; ++ i)
{
__lca = Lca.Get_Lca (Stack[top], queue[i]);
for (; ; )
{
if (Lca.deep[Stack[top - 1]] <= Lca.deep[__lca])
{
-- top;
if (Stack[top] != __lca)
Stack[++ top] = __lca;
break;
}
-- top;
}
if (Stack[top] != queue[i])
Stack[++ top] = queue[i];
}
top --;
for (; top; -- top)
Dp (1);
printf ("%lld\n", dp[1]);
}

void Dp (int now)
{
long long res = 0; dp[now] = value[now];
for (int i = T.list[now]; i; i = T.e[i].next)
{
Dp (T.e[i].to);
res += dp[T.e[i].to];
}
T.list[now] = 0;
if (!res)
dp[now] = value[now];
else if (res < dp[now])
dp[now] = res;
}

void Doing (const int &K)
{
for (int i = 1; i <= K; ++ i)
Build_Tree ();
}
};

Virtual_Tree V_T;

int main (int argc, char *argv[])
{

Lca.Insert_edges (N - 1);
int K;
V_T.Doing (K);

return 0;
}```

luogu P2495 [SDOI2011]消耗战

(0)
(0)

0条