BZOJ 4016 [FJOI2014]最短路径树问题 (贪心+点分治)

题目大意：略 传送门

硬是把两个题拼到了一起= =

$dijkstra$搜出单源最短路，然后$dfs$建树，如果$dis_{v}=dis_{u}+e.val$，说明这条边在最短路图内，然后像$NOIP2018 D2T1$那样的思路，贪心地选出当前节点的所有子节点里，未被访问过的编号最小的节点递归，回溯后重复此过程。可以用$vector$预处理出来，或者用堆= =。

然后就是很经典的点分治问题了

求出树上固定边数的最长链，类似于[IOI2011]Race这道题的思路，只不过是反着搞。每次选择一个重心为根，开个桶统计答案就行了

求固定长度链的个数。但这道题用桶可能会存不下，可以写$map$代替桶(不过数据里好像没有存不下的情况..)。

由于判定条件是二元的，一个是边数一个是长度，排序双指针不知道行不行

还有我把$vector$改成堆就过了是什么鬼

代码巨长巨恶心

#include <map>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define N1 30010
#define M1 1010
#define ll long long
#define inf 233333333
#define it map<node,int>::iterator
using namespace std;

int gint()
{
    int ret=0,fh=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')fh=-1;c=getchar();}
    while(c>='0'&&c<='9'){ret=ret*10+c-'0';c=getchar();}
    return ret*fh;
}
int n,m,K;
struct Edge{
int to[N1<<2],nxt[N1<<2],val[N1<<2],head[N1],cte;
void ae(int u,int v,int w)
{
    cte++;to[cte]=v,val[cte]=w;
    nxt[cte]=head[u],head[u]=cte;
}
}g,e;
namespace Build_Tree{
struct node{
    int id,val;
    friend bool operator < (const node &s1,const node &s2){
        if(s1.val!=s2.val) return s1.val>s2.val;
        return s1.id>s2.id;
    }
};
int cmp(node s1,node s2){return s1.id<s2.id;}
int vis[N1],dis[N1];
void dijkstra()
{
    memset(dis,0x3f,sizeof(dis));
    priority_queue<node>q;
    q.push((node){1,0}); dis[1]=0;
    int j,u,v; node k;
    while(!q.empty())
    {
        k=q.top(); q.pop(); u=k.id; if(vis[u]) continue; vis[u]=1;
        for(j=g.head[u];j;j=g.nxt[j])
        {
            v=g.to[j];
            if(dis[v]>dis[u]+g.val[j])
                dis[v]=dis[u]+g.val[j], q.push((node){v,dis[v]});
        }
    }
    memset(vis,0,sizeof(vis));
}
priority_queue<node>q[N1];
void dfs(int u)
{
    vis[u]=1; node k;
    for(int j=g.head[u];j;j=g.nxt[j])
    {
        if(vis[g.to[j]]||dis[g.to[j]]!=dis[u]+g.val[j]) continue;
        q[u].push((node){g.val[j],g.to[j]});
    }
    while(!q[u].empty())
    {
        k=q[u].top(); q[u].pop(); if(vis[k.val]) continue;
        e.ae(u,k.val,k.id); e.ae(k.val,u,k.id);
        dfs(k.val);
    }
}
void Main()
{
    dijkstra(); 
    dfs(1);
}
};
int sz[N1],ms[N1],use[N1],tsz,G;
void gra(int u,int dad)
{
    sz[u]=1; ms[u]=0;
    for(int j=e.head[u];j;j=e.nxt[j])
    {
        if(use[e.to[j]]||e.to[j]==dad) continue;
        gra(e.to[j],u);
        sz[u]+=sz[e.to[j]]; ms[u]=max(ms[u],sz[e.to[j]]);
    }
    ms[u]=max(ms[u],tsz-sz[u]);
    if(ms[u]<ms[G]) G=u;
}

int ma[N1],q[N1],eq,tq[N1],et,dep[N1],dis[N1];

namespace Find_ma{
int ans;
void dfs(int u,int dad)
{
    if(dep[u]>K) return; tq[++et]=u;
    for(int j=e.head[u];j;j=e.nxt[j])
    {
        if(use[e.to[j]]||e.to[j]==dad) continue;
        dep[e.to[j]]=dep[u]+1; dis[e.to[j]]=dis[u]+e.val[j];
        dfs(e.to[j],u);
    }
}
void calc(int u)
{
    int i,j,x;
    dep[u]=0; ma[0]=0;
    for(j=e.head[u];j;j=e.nxt[j])
    {
        if(use[e.to[j]]) continue;
        dep[e.to[j]]=1; dis[e.to[j]]=e.val[j];
        dfs(e.to[j],u);
        for(i=1;i<=et;i++)
        {
            x=tq[i];
            ans=max(ans,ma[K-dep[x]]+dis[x]);
        }
        while(et)
        {
            x=tq[et--]; q[++eq]=dep[x];
            ma[dep[x]]=max(ma[dep[x]],dis[x]);
        }
    }
    while(eq) ma[q[eq--]]=-inf; 
}
void main_dfs(int u)
{
    int j,v; use[u]=1; calc(u);
    for(j=e.head[u];j;j=e.nxt[j])
    {
        v=e.to[j]; if(use[v]) continue;
        tsz=sz[v]; G=0; gra(v,u);
        main_dfs(G);
    }
}
void solve()
{
    ms[0]=tsz=n; G=0; gra(1,-1); gra(G,-1);
    for(int i=1;i<=n;i++) ma[i]=-inf;
    main_dfs(G);
}
};

namespace Count{

struct node{
    int dis,dep;
    friend bool operator < (const node &s1,const node &s2)
    {
        if(s1.dis!=s2.dis) return s1.dis<s2.dis;
        return s1.dep<s2.dep;
    }
};
int M,ans; map<node,int>mp;
void dfs(int u,int dad)
{
    if(dis[u]>M||dep[u]>K) return;
    mp[(node){dis[u],dep[u]}]++;
    for(int j=e.head[u];j;j=e.nxt[j])
    {
        if(use[e.to[j]]||e.to[j]==dad) continue;
        dep[e.to[j]]=dep[u]+1; dis[e.to[j]]=dis[u]+e.val[j];
        dfs(e.to[j],u);
    }
}
int calc(int u)
{
    int ret=0; node k,t; mp.clear(); dfs(u,-1);
    for(it i=mp.begin();i!=mp.end();i++)
    {
        k=i->first; t=(node){M-k.dis,K-k.dep};
        if(mp.find(t)==mp.end()) continue;
        if(k.dis==t.dis&&k.dep==t.dep) ret+=(i->second)*((i->second)-1);
        else ret+=mp[t]*(i->second);
    }
    return ret/2;
}
void main_dfs(int u)
{
    int j,v; use[u]=1; dis[u]=0; dep[u]=0; ans+=calc(u);
    for(j=e.head[u];j;j=e.nxt[j])
    {
        v=e.to[j]; if(use[v]) continue;
        ans-=calc(v); tsz=sz[v]; G=0; gra(v,u);
        main_dfs(G);
    }
}
void solve()
{
    M=Find_ma::ans;
    memset(use,0,sizeof(use));
    ms[0]=tsz=n; G=0; gra(1,-1); gra(G,-1);
    main_dfs(G);
}
};

int main()
{
    //freopen("t2.in","r",stdin);
    int i,x,y,z;
    scanf("%d%d%d",&n,&m,&K); K--;
    for(i=1;i<=m;i++)
    {
        x=gint(),y=gint(),z=gint();
        g.ae(x,y,z),g.ae(y,x,z);
    }
    Build_Tree::Main();
    Find_ma::solve(); 
    Count::solve();
    printf("%d %d
",Find_ma::ans,Count::ans);
    return 0;
}
/*
6 6 4
1 2 1
2 3 1
3 4 1
2 5 1
3 6 1
5 6 1

3 4

7 6 4
1 2 2
1 3 1
2 4 4
2 5 3
3 6 2
5 7 2

9 1
*/