hdu6141 最大树形图+权值编码

传送门
大佬写的太好了，拿来分享，希望大佬不要生气
题意：给定一个有向图，求以1为根节点的最大树形图是多少并且输出n号节点的父亲节点（父亲节点字典序需要最小）。n是节点数目，m是边的数目。

分析：首先，这里求的是最大树形图，我们可以将所有边的权值乘以-1，然后根据最小树形图算法，求出最小树形图的权值和，再乘回-1就是该有向图的最大树形图权值。但是这样是求不出n号节点的最小字典序父亲节点的，朱刘算法中会将节点序号打乱，也就是我们会丢失节点序号，那这里怎么办呢？这里就用到了权值编码。我们可以思考，既然朱刘算法会将节点序号改变，那么什么是不变的呢？那肯定就是进入n号节点的最小边，如果我们将n号节点的父亲节点信息存到边中，然后再还原回来，不就可以了？这就是权值编码的神奇之处了。这里的操作是，我们将所有的权值都乘以-n，为什么是乘以-n，而不是乘以别的数呢？这里做个记号#1，先不讨论。然后当存在某条边（u，v，w），其中v是n号节点，那么我就将这条边的权值w+=u（这里的w已经进行过乘以-n的操作了。），那么这里问题来了，我这样w+=u，会不会改变节点到达n点权值的相对大小呢？正常情况下是会的，但是这里我们可以提前避开这个问题，这里做个记号#2，先不讨论。然后，当我们根据以上操作处理完所有的权值以及到达n的权值之后，就可以直接跑最小树形图。当我们做完最小树形图之后，会得到一个负数ans1，这个ans1=-n*wi+u，其中wi表示选中边初始的权值和，u表示进入n的父亲节点（神奇吧？），那么此时我们经过乘以ans1*-1，会得到ans2=n*wi-u，这时，我们可以很明显的发现，我们所求的最大树形图权值就是所有wi的和，n的最小字典序父亲节点就是u。到了这一步，我们的工作就是处理ans2。对于最大树形图的权值，我们不能直接（ans2=n*wi-u）/n，这里-u的做操作会使最终结果少1，因此，我们这样操作（ans2+n-1）/n=（n*wi-u+n-1）/n，这里0<-u+n-1

#include <map>
#include <stack>
#include <queue>
#include <math.h>
#include <vector>
#include <string>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <algorithm>

using namespace std;
typedef long long LL;
const int MAXN = 1e4+5;
const double PI = acos(-1);
const double eps = 1e-8;
const int MOD = 1e9+7;
const int INF=0x3f3f3f3f;
struct node
{
    int u,v,next,w;
} edge[MAXN*10];
int head[MAXN],tot;
void init()
{
    tot=0;
    memset(head,-1,sizeof(head));
}
void add(int u,int v,int w)
{
    edge[tot].u=u;
    edge[tot].v=v;
    edge[tot].w=w;
    edge[tot].next=head[u];
    head[u]=tot++;
}
int pre[MAXN],id[MAXN],visit[MAXN],in[MAXN],vis[MAXN];

int zhuliu(int root,int n,int m)
{
    int res=0,u,v;
    while(1)
    {
        for(int i=0; i<n; i++)
            in[i]=INF;
        for(int i=0; i<m; i++)
            if(edge[i].u!=edge[i].v&&edge[i].w<in[edge[i].v])
            {
                pre[edge[i].v]=edge[i].u;
                in[edge[i].v]=edge[i].w;
            }
        for(int i=0; i<n; i++)
            if(i!=root&&in[i]==INF)
                return -1;
        int tn=0;
        memset(id,-1,sizeof(id));
        memset(visit,-1,sizeof(visit));
        in[root]=0;
        for(int i=0; i<n; i++)
        {
            res+=in[i];
            v=i;
            while(visit[v]!=i&&id[v]==-1&&v!=root)
            {
                visit[v]=i;
                v=pre[v];
            }
            if(v!=root&&id[v]==-1)
            {
                for( u=pre[v]; u!=v; u=pre[u])
                    id[u]=tn;
                id[v]=tn++;
            }
        }
        if(tn==0)
            break;
        for(int i=0; i<n; i++)
            if(id[i]==-1)
                id[i]=tn++;
        for(int i=0; i<m;)
        {
            v=edge[i].v;
            edge[i].u=id[edge[i].u];
            edge[i].v=id[edge[i].v];
            if(edge[i].u!=edge[i].v)
                edge[i++].w-=in[v];
            else
                swap(edge[i],edge[--m]);
        }
        n=tn;
        root=id[root];
    }
    return res;
}
/*
double Dir_MST(int root, int V, int E)
{
    double ret = 0;
    while(true)
    {
        //1.找最小入边
        for(int i = 0; i < V; i++) in[i] = INF;
        for(int i = 0; i < E; i++)
        {
            int u = edge[i].u;
            int v = edge[i].v;
            if(edge[i].w < in[v] && u != v) {pre[v] = u; in[v] = edge[i].w;}
        }
        for(int i = 0; i < V; i++)
        {
            if(i == root) continue;
            if(in[i] == INF) return -1;//除了跟以外有点没有入边,则根无法到达它
        }
        //2.找环
        int cnt = 0;
        memset(id, -1, sizeof(id));
        memset(vis, -1, sizeof(vis));
        in[root] = 0;
        for(int i = 0; i < V; i++) //标记每个环
        {
            ret += in[i];
            int v = i;
            while(vis[v] != i && id[v] == -1 && v != root)  //每个点寻找其前序点，要么最终寻找至根部，要么找到一个环
            {
                vis[v] = i;
                v = pre[v];
            }
            if(v != root && id[v] == -1)//缩点
            {
                for(int u = pre[v]; u != v; u = pre[u]) id[u] = cnt;
                id[v] = cnt++;
            }
        }
        if(cnt == 0) break; //无环   则break
        for(int i = 0; i < V; i++)
            if(id[i] == -1) id[i] = cnt++;
              //3.建立新图
        for(int i = 0; i < E; i++)
        {
            int u = edge[i].u;
            int v = edge[i].v;
            edge[i].u = id[u];
            edge[i].v = id[v];
            if(id[u] != id[v]) edge[i].w -= in[v];
        }
        V = cnt;
        root = id[root];
    }
    return ret;
}
*/
int main()
{
    int T;
    scanf("%d",&T);
    int n,m,u,v,w;
    while(T--)
    {
        scanf("%d%d",&n,&m);
        init();
        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            u--;
            v--;
            w=w*(-n);
            if(v==n-1)
                w+=u;
            add(u,v,w);
        }
        int ans=zhuliu(0,n,m);
        printf("%d %d\n",(n-1-ans)/n,(n-ans-1)/n*n+ans+1);///因为u做了减一操作，所以加1 
    }
    return 0;
}