HDU 6141 最小树形图

• 题目链接： http://acm.split.hdu.edu.cn/showproblem.php?pid=6141

• 题意：

  • N个点M条边求最大树形图，还问权值最大的图中第N个点的父亲编号最小能是多少

• 规模：

  • $N <= 1e3, M <= 1e4$

• 类型：

  • 最小树形图
  • 边权处理

• 分析：

  • 最开始做的时候用最小费用流，但会超时
  • 原来是最小树形图
  • 这里第N个点的边权，按其u的序号处理，就能解决字典序的问题

• 时间复杂度&&优化：

  • O(nm)

• 代码：

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


using namespace std;

/*
* 最小树形图
* int型
* O（N*M）
* 点的编号 0~N-1
*/

const int INF=0x3fff3fff;
const int MAXN=1010;
const int MAXM=40010;
typedef long long ll;

struct Edge{
    int u,v,cost;
};
Edge edge[MAXM];
int L=0;

void addedge(int u,int v,int cost){
    edge[L].u=u;
    edge[L].v=v;
    edge[L++].cost=cost;
}

void init(){
    L=0;
}

int pre[MAXN],id[MAXN],visit[MAXN],in[MAXN];
int zhuliu(int root,int n,int m,Edge edge[])
{
    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].cost < in[edge[i].v])
            {
                pre[edge[i].v] = edge[i].u;
                in[edge[i].v] = edge[i].cost;
            }
        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(int 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++].cost -= in[v];
            else
                swap(edge[i],edge[--m]);
        }
        n = tn;
        root = id[root];
        }
    return res;
}
int n,m;
int a[1100][1100];
int main()
{
    int T;
    cin>>T;
    while(T--){
            cin>>n>>m;
            init();
            memset(a,-1,sizeof(a));
            for(int i=0;i<m;i++){
                int x,y,w;
                cin>>x>>y>>w;
                a[x][y]=max(a[x][y],w*1000);
            }

            for(int i=1;i<=n;i++){
                for(int j=1;j<=n;j++){
                    if(a[i][j]==-1)continue;
                    if(j==n)
                        addedge(i-1,j-1,-a[i][j]-(1000-i));
                    else addedge(i-1,j-1,-a[i][j]);
                }
            }

            int ans=zhuliu(0,n,L,edge);
            ans=-ans;
            cout<<ans/1000<<" "<<1000-ans%1000<<endl;
    }
    return 0;
}