bzoj 3876 [Ahoi2014]支线剧情（有上下界的最小费用流）

3876: [Ahoi2014]支线剧情

Time Limit: 10 Sec  Memory Limit: 256 MB
Submit: 484  Solved: 296
[Submit][Status][Discuss]

Description

【故事背景】

宅男JYY非常喜欢玩RPG游戏，比如仙剑，轩辕剑等等。不过JYY喜欢的并不是战斗场景，而是类似电视剧一般的充满恩怨情仇的剧情。这些游戏往往

都有很多的支线剧情，现在JYY想花费最少的时间看完所有的支线剧情。

【问题描述】

JYY现在所玩的RPG游戏中，一共有N个剧情点，由1到N编号，第i个剧情点可以根据JYY的不同的选择，而经过不同的支线剧情，前往Ki种不同的新的剧情点。当然如果为0，则说明i号剧情点是游戏的一个结局了。

JYY观看一个支线剧情需要一定的时间。JYY一开始处在1号剧情点，也就是游戏的开始。显然任何一个剧情点都是从1号剧情点可达的。此外，随
着游戏的进行，剧情是不可逆的。所以游戏保证从任意剧情点出发，都不能再回到这个剧情点。由于JYY过度使用修改器，导致游戏的“存档”和“读档”功能损
坏了，

所以JYY要想回到之前的剧情点，唯一的方法就是退出当前游戏，并开始新的游戏，也就是回到1号剧情点。JYY可以在任何时刻退出游戏并重新开始。不断开始新的游戏重复观看已经看过的剧情是很痛苦，JYY希望花费最少的时间，看完所有不同的支线剧情。

Input

输入一行包含一个正整数N。

接下来N行，第i行为i号剧情点的信息；

第一个整数为，接下来个整数对，Bij和Tij，表示从剧情点i可以前往剧

情点，并且观看这段支线剧情需要花费的时间。

Output

输出一行包含一个整数，表示JYY看完所有支线剧情所需要的最少时间。

Sample Input

6
2 2 1 3 2
2 4 3 5 4
2 5 5 6 6
0
0
0

Sample Output

24

HINT

JYY需要重新开始3次游戏，加上一开始的一次游戏，4次游戏的进程是

1->2->4，1->2->5，1->3->5和1->3->6。

对于100%的数据满足N<=300,0<=Ki<=50,1<=Tij<=300,Sigma(Ki)<=5000

Source

By 佚名上传

【思路】

　　有上下界的费用流。

　　用最短路算法慢得飞起=-=，等会学一下zkw费用流。

【代码】

 /**************************************************************
     Problem: 3876
     User: hahalidaxin2
     Language: C++
     Result: Accepted
     Time:10640 ms
     Memory:1856 kb
 ****************************************************************/

 #include<cstdio>
 #include<cstring>
 #include<queue>
 #include<vector>
 #define FOR(a,b,c) for(int a=(b);a<=(c);a++)
 using namespace std;

 typedef long long LL ;
 const int maxn = +;
 const int INF = 1e9;

 struct Edge{ int u,v,cap,flow,cost;
 };

 struct MCMF {
     int n,m,s,t;
     int inq[maxn],a[maxn],d[maxn],p[maxn];
     vector<int> G[maxn];
     vector<Edge> es;

     void init(int n) {
         this->n=n;
         es.clear();
         for(int i=;i<n;i++) G[i].clear();
     }
     void AddEdge(int u,int v,int cap,int cost) {
         es.push_back((Edge){u,v,cap,,cost});
         es.push_back((Edge){v,u,,,-cost});
         m=es.size();
         G[u].push_back(m-);
         G[v].push_back(m-);
     }

     bool SPFA(int s,int t,int& flow,LL& cost) {
         for(int i=;i<n;i++) d[i]=INF;
         memset(inq,,sizeof(inq));
         d[s]=; inq[s]=; p[s]=; a[s]=INF;
         queue<int> q; q.push(s);
         while(!q.empty()) {
             int u=q.front(); q.pop(); inq[u]=;
             for(int i=;i<G[u].size();i++) {
                 Edge& e=es[G[u][i]];
                 int v=e.v;
                 if(e.cap>e.flow && d[v]>d[u]+e.cost) {
                     d[v]=d[u]+e.cost;
                     p[v]=G[u][i];
                     a[v]=min(a[u],e.cap-e.flow);        //min(a[u],..)
                     if(!inq[v]) { inq[v]=; q.push(v);
                     }
                 }
             }
         }
         if(d[t]==INF) return false;
         flow+=a[t] , cost += (LL) a[t]*d[t];
         for(int x=t; x!=s; x=es[p[x]].u) {
             es[p[x]].flow+=a[t]; es[p[x]^].flow-=a[t];
         }
         return true;
     }
     int Mincost(int s,int t,LL& cost) {
         int flow=; cost=;
         while(SPFA(s,t,flow,cost)) ;
         return flow;
     }
 } mc;

 int n;

 int main() {
     scanf("%d",&n);
     mc.init(n+);
     int s=,t=n+;
     mc.AddEdge(t,s,INF,);
     FOR(u,,n) {
         int m,v,c; scanf("%d",&m);
         if(u!=) mc.AddEdge(u,,INF,);
         mc.AddEdge(u,t,m,);
         FOR(j,,m) {
             scanf("%d%d",&v,&c);
             mc.AddEdge(u,v,INF,c);
             mc.AddEdge(s,v,,c);
         }
     }
     LL cost;
     mc.Mincost(s,t,cost);
     printf("%lld\n",cost);
     return ;
 }

最短路算法

【代码2】

 /**************************************************************
     Problem: 3876
     User: hahalidaxin2
     Language: C++
     Result: Accepted
     Time:1884 ms
     Memory:1852 kb
 ****************************************************************/

 #include<cstdio>
 #include<cstring>
 #include<queue>
 #include<vector>
 #define FOR(a,b,c) for(int a=(b);a<=(c);a++)
 using namespace std;

 typedef long long LL ;
 const int maxn = +;
 const int INF = 1e9;

 struct Edge{ int u,v,cap,flow,cost;
 };
 struct zkw {
     int n,m,s,t;
     int vis[maxn],d[maxn];
     vector<int> G[maxn];
     vector<Edge> es;

     void init(int n) {
         this->n=n;
         es.clear();
         for(int i=;i<n;i++) G[i].clear();
     }
     void AddEdge(int u,int v,int cap,int cost) {
         es.push_back((Edge){u,v,cap,,cost});
         es.push_back((Edge){v,u,,,-cost});
         m=es.size();
         G[u].push_back(m-);
         G[v].push_back(m-);
     }
     bool spfa() {
         memset(vis,,sizeof(vis));
         for(int i=;i<n;i++) d[i]=INF;
         queue<int> q;
         d[t]= , vis[t]= , q.push(t);
         while(!q.empty()) {
             int u=q.front(); q.pop() , vis[u]=;
             for(int i=;i<G[u].size();i++) {
                 Edge& e=es[G[u][i]];
                 int v=e.v;
                 if(es[G[u][i]^].cap && d[v]>d[u]-e.cost) {
                     d[v]=d[u]-e.cost;
                     if(!vis[v]) {
                         vis[v]=;
                         q.push(v);
                     }
                 }
             }
         }
         return d[s]!=INF;
     }
     int dfs(int u,int a,LL& cost) {
         vis[u]=;  if(u==t) return a;
         int used=,w;
         for(int i=;i<G[u].size();i++) {
             Edge& e=es[G[u][i]];
             int v=e.v;
             if(d[u]-e.cost==d[v] && !vis[v] && e.cap) {
                 w=dfs(v,min(a-used,e.cap),cost);
                 cost+=w*e.cost;
                 e.cap-=w , es[G[u][i]^].cap+=w;
                 used+=w; if(used==a) return a;
             }
         }
         return used;
     }
     int Mincost(int s,int t,LL& cost) {
         this->s=s , this->t=t;
         int flow=; cost=;
         while(spfa()) {
             vis[t]=;
             while(vis[t]) {
                 memset(vis,,sizeof(vis));
                 flow+=dfs(s,INF,cost);
             }
         }
         return flow;
     }
 } mc;

 int n;

 int main() {
     scanf("%d",&n);
     mc.init(n+);
     int s=,t=n+;
     mc.AddEdge(t,s,INF,);
     FOR(u,,n) {
         int m,v,c; scanf("%d",&m);
         if(u!=) mc.AddEdge(u,,INF,);
         mc.AddEdge(u,t,m,);
         FOR(j,,m) {
             scanf("%d%d",&v,&c);
             mc.AddEdge(u,v,INF,c);
             mc.AddEdge(s,v,,c);
         }
     }
     LL cost;
     mc.Mincost(s,t,cost);
     printf("%lld\n",cost);
     return ;
 }

zkw费用流

　　跑稠密图的话，zkw的优化效果还是比较明显的。

UPD.16/4/8

按理说有上下界的处理和跑网络流的那几道题是一样的，现在没时间测了，该上车了。