【Typical-Greedy】【JZOJ 5400】 Repulsed

Description

给定n个节点的树，需要在一些节点放置任意数量的半径为k的灭火器（能够覆盖距离不超过k的点），使得任意节点都被至少一个灭火器覆盖到
每个灭火器最多覆盖s个点
最小化放置的灭火器数量
对于100% 的数据满足n <= 10^5, k <= 20, s <= 10^9。

Greedy

从下往上比较好做
有一个正确的思路：对于当前未覆盖的最深节点x，覆盖它的灭火器放置越浅越好，设放置于y，则y为x的k级父亲。确定灭火器后选择覆盖最深的那些点。
这样写可以获得不少分数，因为这道题比较容易水。但是这样做正确性有点问题，因为如果s好大，y会一直覆盖到y上面，你又不知道去覆盖哪些点更优了（类似于后效性）
我们选择将这些多余的次数在y点存起来，以后如果有没被覆盖的点就可以使用这些次数
设f[x][i]表示x往下深度为i的没被覆盖的点数
g[x][i]表示x往下深度为i的剩余次数
则f[x],g[x]都可由f[son(x)]继承
当f[x][k]有值时，我们就需要在x处放置灭火器
同时我们需要将f[x][i]与g[x][j]匹配，类似的贪心可以发现，当且仅当i+j=k 或i+j=k-1时相匹配是不会劣的
实时维护f,g，时间复杂度为O(nk)

Code

#include<ctime>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,b,a) for(int i=b;i>=a;i--)
#define efo(i,v,u) for(int i=last[v],u=to[i];i;i=next[i],u=to[i])
#define max(x,y) ((x)>(y)?(x):(y))
#define min(x,y) ((x)<(y)?(x):(y))
#define mset(a,x) memset(a,x,sizeof(a))
using namespace std;
typedef long long ll;
char ch;
void read(int &n)
{
    n=0;
    for(ch=getchar();ch<'0' || ch>'9';ch=getchar()); 
    for(;'0'<=ch && ch<='9';ch=getchar()) n=n*10+ch-'0';
}
const int N=1e5+5;
int n,s,k,tot,ans,to[N+N],next[N+N],last[N];
ll g[N][22],f[N][22];
void link(int u,int v){to[++tot]=v,next[tot]=last[u],last[u]=tot;}
void rev(ll &x,ll &y)
{
    ll t=min(x,y);
    x-=t,y-=t;
}
void dfs(int v,int fr=0)
{
    f[v][0]=1;
    efo(i,v,u) if(u!=fr)
    {
        dfs(u,v);
        fo(j,1,k) f[v][j]+=f[u][j-1],g[v][j]+=g[u][j-1];
    }
    if(f[v][k])
    {
        int t=f[v][k]/s+(f[v][k]%s>0);
        ans+=t,g[v][0]+=(ll)s*t;
        rev(g[v][0],f[v][k]);
    }
    fo(i,0,k) rev(f[v][i],g[v][k-i]);
    fo(i,0,k-1) rev(f[v][i],g[v][k-1-i]);
}
int main()
{
    freopen("repulsed.in","r",stdin);
    freopen("repulsed.out","w",stdout);
    int u,v;
    read(n),read(s),read(k);
    fo(i,1,n-1) read(u),read(v),link(u,v),link(v,u);
    dfs(1);
    fo(i,0,k)
        fd(j,k-i,0) rev(f[1][i],g[1][j]);
    int t=0;
    fo(i,0,k) t+=f[1][i];
    ans+=t/s+(t%s>0);
    printf("%d",ans);
    return 0;
}