【HDU4966】GGS-DDU

题意

有n种科目，每个科目都有一个最高的等级a[i]。开始的时候，每个科目的等级都是0。现在要选择一些课程进行学习使得每一个科目都达到最高等级。这里有m节课可供选择。对于每门课给出L1[i],c[i],L2[i],d[i]，money[i]，要选择这门课要求科目c[i]的等级不小于L[i],可以使科目d[i]的等级升为L2[i],花费金钱money[i]。请计算最小花费是多少。

数据范围N<=50,M<=2000,sum of a[1] to a[n]不超过500.

分析

最小树形图，要用到朱刘算法。其实。。。我是昨晚在补这道题的时候才去学了一下朱刘算法。。。。。。

朱刘算法学习博客https://blog.csdn.net/txl199106/article/details/62045479

对于这道题我是这么想的，把每个科目的每个等级都拆成点，然后建一个编号为0的点向各个科目等级为0的点连一条权值为0的边。对于每个科目，将他们等级从高到低的点依次连权值为0的点，然后对于每一门课程按照要求连边，权值为这门课程的花费。

建图完成以后，以0点为root跑朱刘算法得到最小树形图，然后这就是答案了。

应该会这个算法就很好做的一道题。

 #include <cstdio>
 #include <iostream>
 #include <algorithm>
 #include <cstring>
 #include <vector>
 using namespace std;
 const int maxn=+;
 const int INF=;

 struct Edge{
     int from,to;
     long long w;
 }edges[maxn];
 int sz;
 int a[],sum[];
 int N,M;
 void add_edge(int from,int to,long long w){
     ++sz;
     edges[sz].from=from;edges[sz].to=to;edges[sz].w=w;
 }
 int pre[maxn];//存储父节点
 int vis[maxn];//标记作用
 int id[maxn];//id[i]记录节点i所在环的编号
 int in[maxn];//in[i]记录i入边中最小的权值
 long long zhuliu(int root, int n, int m, Edge *edge)//root根 n点数 m边数
 {
     long long res = ;
     int u, v;
     while()
     {
         for(int i = ; i < n; i++)
             in[i] = INF;//初始化
         for(int i = ; i <= m; i++)
         {
             Edge E = edge[i];
             if(E.from != E.to && E.w < in[E.to])
             {
                 pre[E.to] = E.from;//记录前驱
                 in[E.to] = E.w;//更新
             }
         }
         for(int i = ; i <n; i++)
             if(i != root && in[i] == INF)
                 return -;//有其他孤立点 则不存在最小树形图
         //找有向环
         int tn = ;//记录当前查找中 环的总数
         memset(id, -, sizeof(id));
         memset(vis, -, sizeof(vis));
         in[root] = ;//根
         for(int i = ; i <n; i++)
         {
             res += in[i];//累加
             v = i;
             //找图中的有向环 三种情况会终止while循环
             //1,直到出现带有同样标记的点说明成环
             //2,节点已经属于其他环
             //3,遍历到根
             while(vis[v] != i && id[v] == - && v != root)
             {
                 vis[v] = i;//标记
                 v = pre[v];//一直向上找
             }
             //因为找到某节点属于其他环  或者 遍历到根  说明当前没有找到有向环
             if(v != root && id[v] == -)//必须上述查找已经找到有向环
             {
                 for(int u = pre[v]; u != v; u = pre[u])
                     id[u] = tn;//记录节点所属的 环编号
                 id[v] = tn++;//记录节点所属的 环编号  环编号累加
             }
         }
         if(tn == ) break;//不存在有向环
         //可能存在独立点
         for(int i = ; i <n; i++)
             if(id[i] == -)
                 id[i] = tn++;//环数累加
         //对有向环缩点  和SCC缩点很像吧
         for(int i = ; i <= m; i++)
         {
             v = edge[i].to;
             edge[i].from = id[edge[i].from];
             edge[i].to = id[edge[i].to];
             //<u, v>有向边
             //两点不在同一个环 u到v的距离为 边权cost - in[v]
             if(edge[i].from != edge[i].to)
                 edge[i].w -= in[v];//更新边权值 继续下一条边的判定
         }
         n = tn;//以环总数为下次操作的点数 继续执行上述操作 直到没有环
         root = id[root];
     }
     return res;
 }

 int main(){
     while(scanf("%d%d",&N,&M)!=EOF&&N&&M){
         sz=;
         sum[]=;
         for(int i=;i<=N;i++){
             scanf("%d",&a[i]);
             sum[i]=sum[i-]+a[i]+;
         }

         int c,L1,d,L2;
         long long w;
         for(int i=;i<=M;i++){
             scanf("%d%d%d%d%lld",&c,&L1,&d,&L2,&w);
            /* for(int j=L1;j<=a[c];j++){
                 add_edge(sum[c-1]+j+1,sum[d-1]+L2+1,w);
             }*/
             add_edge(sum[c-]+L1+,sum[d-]+L2+,w);
         }
         for(int i=;i<=N;i++){
             add_edge(,sum[i-]+,);
         }
         for(int i=;i<=N;i++){
             for(int j=;j<a[i];j++){
                 add_edge(sum[i-]+j+,sum[i-]+j+,);
             }
         }
         /*printf("%d\n",sz);
         for(int i=1;i<=sz;i++){
             printf("%d %d %d\n",edges[i].from,edges[i].to,edges[i].w);
         }*/
         //cout<<sum[n]<<endl;
         long long ans=zhuliu(,sum[N]+,sz,edges);
         printf("%lld\n",ans);
     }
 return ;
 }