HDU 4966 GGS-DDU(无固定根最小树形图)

题目链接；
HDU 4966 GGS-DDU
题意：
有n门课程需要学习，每门课程的初始等级是0，最高等级是num[i],有m个补习班可以用来提升课程等级，
参加第i个补习班的条件是第a[i]门课程的等级不低于b[i],补习后可以使第c[i]门课程的等级提升到d[i],花费是e[i],
问将这n门课程都学习到最高等级的最小花费是多少？如果不能使每门课都达到最高等级输出-1.
分析：
主要是建图。
每门课看成num[i]+1个点，每门课内部从高等级到低等级可以建一条权值为0的边，然后再根据给出的m条信息建m条边，最后还需要一个根节点。用sum[i]表示在学习第i门课程之前有多少个等级(包括0等级)需要学习，也就是有多少个点，可以令根节点为sum[n]（课程编号从0–n-1），从sum[n]到每个课程建一条边权为0的边，一方面所有的等级为0课程点通过sum[n]这个桥梁连接起来了，另一方面总的权值不会发生改变。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <climits>
#include <cmath>
#include <ctime>
#include <cassert>
#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
using namespace std;
typedef long long ll;
const int MAX_N = 600;
const int MAX_M = 20010;
const int INF = 0x3f3f3f3f;

int n, m, NV, NE;
int vis[MAX_N], pre[MAX_N], ID[MAX_N], sum[MAX_N], num[MAX_N], In[MAX_N];

struct Edge{
    int u, v, w;

    Edge() {}
    Edge(int _u, int _v, int _w) : u(_u), v(_v), w(_w) {}
}edge[MAX_M];

int ZLEdmonds(int root, int NV, int NE)
{
    int res = 0, u, v, w;
    while(1){
        for(int i = 0; i < NV; i++) { In[i] = INF; }
        for(int i = 0; i < NE; i++){
            u = edge[i].u, v = edge[i].v, w = edge[i].w;
            if(u != v && w < In[v]){
                pre[v] = u;
                In[v] = w;
            }
        }
        for(int i = 0; i < NV; i++){
            if(i != root && In[i] == INF) return -1;
        }

        int cnt = 0;
        memset(vis, -1, sizeof(vis));
        memset(ID, -1, sizeof(ID));
        In[root] = 0;

        for(int i = 0; i < NV; i++){
            res += In[i];
            v = i;
            while(v != root && vis[v] != i && ID[v] == -1){
                vis[v] = i;
                v = pre[v];
            }
            if(v != root && ID[v] == -1){
                for(u = pre[v]; u != v; u = pre[u]){
                    ID[u] = cnt;
                }
                ID[v] = cnt++;
            }
        }
        if(cnt == 0) break;
        for(int i = 0; i < NV; i++){
            if(ID[i] == -1) ID[i] = cnt++;
        }
        for(int i = 0; i < NE; i++){
            u = edge[i].u;
            v = edge[i].v;
            edge[i].v = ID[v];
            edge[i].u = ID[u];
            if(edge[i].u != edge[i].v){
                edge[i].w -= In[v];
            }
        }
        NV = cnt;
        root = ID[root];
    }
    return res;
}

int main()
{
    IOS;
    while(~scanf("%d%d", &n ,&m) && (n || m)){
        NE = sum[0] = 0;
        for(int i = 0; i < n; i++){
            scanf("%d", &num[i]);
            sum[i + 1] = sum[i] + (++num[i]); 
        }
        int root = sum[n];
        for(int i = 0; i < n; i++){
            for(int j = sum[i]; j < sum[i + 1] - 1; j++){
                edge[NE++] = Edge(j + 1, j, 0);
            }
            edge[NE++] = Edge(root, sum[i], 0);
        }
        NV = root + 1;
        for(int i = 0; i < m; i++){
            int a, b, c, d, e;
            scanf("%d%d%d%d%d", &a, &b, &c, &d, &e);
            edge[NE++] = Edge(sum[a - 1] + b, sum[c - 1] + d, e);
        }
        int ans = ZLEdmonds(root, NV, NE);
        printf("%d\n", ans);
    }
    return 0;
}