3876: [Ahoi2014&Jsoi2014]支线剧情

###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


有上下界的网络流

/**************************************************************
    Problem: 3876
    User: s_a_b_e_r
    Language: C++
    Result: Accepted
    Time:272 ms
    Memory:1820 kb
****************************************************************/

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<queue>
#include<vector>
#define ll long long
#include<cstring>
using namespace std;
inline int read(){
    int an=0,f=1;
    char ch=getchar();
    while(ch<‘0‘||ch>‘9‘){if(ch==‘-‘)f=-1;ch=getchar();}
    while(ch<=‘9‘&&ch>=‘0‘){an=an*10+(ch^48);ch=getchar();}
    return an*f;
}
const int maxn=1000,maxm=maxn*30;
const int INT=1e7;
int in[maxn],S,T,X,Y,out[maxn],f[maxn],cnt=1;
int n;
struct saber{
int nex,to,lim,wi;
};
ll ans;
vector<saber>b;
inline void add(int x,int y,int z,int wi){
    cnt++;
    b.push_back(  (saber){f[x],y,z,wi} );
    f[x]=cnt;
}
inline void prepare(){
    n=read();S=n+2;T=n+1;
    b.push_back( (saber){0,0,0,0} );
    b.push_back( (saber){0,0,0,0} );
    for(int i=2;i<=n;i++){add(i,1,INT,0),add(1,i,0,0);}
    for(int i=1;i<=n;i++){
        out[i]=read();
        for(int j=1;j<=out[i];j++){
        int x=read(),y=read();
        add(i,x,INT,y);
        add(x,i,0,-y);
        in[x]++;
        ans+=y;
        }
    }
    for(int i=1;i<=n;i++){
        int x=in[i]-out[i];
        if(x<0){
            add(i,T,-x,0);
            add(T,i,0,0);
        }
        else{
            add(S,i,x,0);
            add(i,S,0,0);
        }
    }
}
queue<int>q;
int dis[maxn];
bool vis[maxn];
bool ind[maxn];
inline int bfs(){
    while(!q.empty())q.pop();
    q.push(S);
    for(int i=1;i<=S+9;i++)dis[i]=INT;
    dis[S]=0;
    while(!q.empty()){
        int x=q.front();q.pop();
        vis[x]=0;
        for(int i=f[x];i;i=b[i].nex){
            int v=b[i].to;
            if(dis[v]>dis[x]+b[i].wi&&b[i].lim){
                dis[v]=dis[x]+b[i].wi;
                if(!vis[v]){vis[v]=1;q.push(v);}
            }
        }
    }
    return dis[T]!=INT;
}

inline int dfs(int x,int li){
    int used=li;ind[x]=1;
    if(x==T||!li)return li;
    for(int i=f[x];i&&used;i=b[i].nex){
        int v=b[i].to;
        if(ind[v])continue;
        if(dis[v]==dis[x]+b[i].wi&&b[i].lim){
            int re=dfs( v,min(used,b[i].lim) );
            b[i].lim-=re;
            b[i^1].lim+=re;
            used-=re;
        }
    }
    return li-used;
}
inline void dinic(){
    while(bfs()){
        memset(ind,0,sizeof ind);
        ans+=dis[T]*dfs(S,INT);
    }
    cout<<ans;
}
int main(){
    ios::sync_with_stdio(0);
    prepare();
    dinic();
    return 0;
}

QAQ网络流又写挂了，害得我查了好久>_<

有上下界的最小费用流~熟悉的套路x

  • 对于每个有连边的点对(u,v)，从u向v连一条费用为w，流量为inf的边，表示这段剧情最多能看无数遍；再从源点向v连一条费用w流量1的点，表示至少看一次
  • 对于每个除1以外的点，向1连一条流量inf费用0的边，代表随时可以回到点1
  • 对于每个点，向汇点连流量为该点出度，费用为0的边，因为每条边至少走一遍，对于这个点至少预留out的流量

于是跑最小费用最大流就好啦>_<

/**************************************************************
    Problem: 3876
    User: wypx
    Language: C++
    Result: Accepted
    Time:9380 ms
    Memory:40364 kb
****************************************************************/

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int N=500,M=10*N*N,inf=1e9+7;
int n,out[N],S,T,cnt=1,p[N],inp[N];
int dis[N],in[N];
bool vis[N];
struct edge{int to,nex,val,cos;}e[M];
void add(int u,int v,int lim,int cos){
    e[++cnt]=(edge){v,p[u],lim,cos};
    p[u]=cnt;
    e[++cnt]=(edge){u,p[v],0,-cos};
    p[v]=cnt;
}
queue<int>q;
bool spfa(){
    for(int i=1;i<=T;++i)dis[i]=inf;
    memset(in,0,sizeof(in));
    while(!q.empty())q.pop();
    dis[S]=0;q.push(S);
    while(!q.empty()){
        int x=q.front();q.pop();in[x]=0;
        for(int i=p[x];i;i=e[i].nex){
            int v=e[i].to;
            if(e[i].val&&dis[v]>dis[x]+e[i].cos){
                dis[v]=dis[x]+e[i].cos;
                if(!in[v]){in[v]=1;q.push(v);}
            }
        }
    }
    return dis[T]<inf;
}

int dfs(int x,int li){
    vis[x]=1;
    if(x==T)return li;
    int used=li;
    for(int i=p[x];i;i=e[i].nex){
        int v=e[i].to;
        if(!vis[v]&&used&&e[i].val&&dis[v]==dis[x]+e[i].cos){
            int re=dfs(v,min(used,e[i].val));
            used-=re;
            e[i].val-=re;
            e[i^1].val+=re;
        }
    }
    return li-used;
}
int dinic(){
    int ans=0;
    while(spfa()){
        memset(vis,0,sizeof(vis));
        ans+=dfs(S,inf)*dis[T];
    }
    return ans;
}
int main(){
    scanf("%d",&n);S=n+1,T=n+2;
    for(int i=1;i<=n;++i){
        scanf("%d",&out[i]);
        for(int j=1;j<=out[i];++j){
            int v,w;scanf("%d%d",&v,&w);
            add(i,v,inf,w);
            add(S,v,1,w);
        }
        add(i,T,out[i],0);
        if(i!=1)add(i,1,inf,0);
    }
    cout<<dinic()<<endl;
    return 0;
}
时间： 2024-10-02 05:26:01

3876: [Ahoi2014&Jsoi2014]支线剧情的相关文章

bzoj3876 [Ahoi2014&amp;Jsoi2014]支线剧情

3876: [Ahoi2014&Jsoi2014]支线剧情 Time Limit: 10 Sec  Memory Limit: 256 MBSubmit: 2180  Solved: 1300[Submit][Status][Discuss] Description [故事背景] 宅男JYY非常喜欢玩RPG游戏,比如仙剑,轩辕剑等等.不过JYY喜欢的并不是战斗场景,而是类似电视剧一般的充满恩怨情仇的剧情.这些游戏往往 都有很多的支线剧情,现在JYY想花费最少的时间看完所有的支线剧情. [问题描述

[AHOI2014/JSOI2014]支线剧情

---题面--- 题解: 第一眼费用流,,然后想了好久怎么建图,,,最后发现是最小费用可行流的板子题.... 其实还没有很懂这个算法,所以这里只是摆一下步骤,以后再补理解吧. 首先一个思路就是转换图,将有上下限的图变为普通的网络流图,然后再跑费用流. 所以建图其实和有上下界的网络流一样的... 1,首先建立超级源点汇点ss和tt 2,对于原图中每一条边x ---> y,设其上下界为(l, r),费用为cost,那么连边的时候将流量变为r - l即可 3,对于任意点i,记d[i]为它的富余流量,即

bzoj3876: [Ahoi2014&amp;Jsoi2014]支线剧情（上下界费用流）

传送门 一道题让我又要学可行流又要学zkw费用流…… 考虑一下,原题可以转化为一个有向图,每次走一条路径,把每一条边都至少覆盖一次,求最小代价 因为一条边每走过一次,就要付出一次代价 那不就是费用流了么 我们定义每走一次都会对一条边增加1的流量,1然后费用为时间 那么把下界设为1,上界设为inf,跑一个最小费用可行流就可以了 ps:不会可行流的可以去看看这个博客,我觉得写得很不错->这里 1 //minamoto 2 #include<iostream> 3 #include<cs

P4043 [AHOI2014/JSOI2014]支线剧情 上下界费用流

题意: 有个人每次可以从1出发(可以无限次)  走有向边  耗费的时间为有向边的长度   问最少耗费的时间遍历所有的边至少一次 有点像滑雪那题  不过那题求得是最少的次数 这题很显然可以转化为上下界费用流  只要设置边的容量为1-inf 即可 注意: 上下界费用流的答案为: 答案即为(求出的费用+原图中边的下界*边的费用) 答案即为(求出的费用+原图中边的下界*边的费用) 答案即为(求出的费用+原图中边的下界*边的费用) 答案即为(求出的费用+原图中边的下界*边的费用) #include<bit

BZOJ 3876 【AHOI2014】 支线剧情

题目链接:支线剧情 这道题就是一道裸裸的上下界网络流--只不过这道题边带了权,那么建出图之后跑费用流即可. 首先需要新建超级源\(S\)和超级汇\(T\).对于这道题,对于一条边\((u,v,z)\),我们从\(S\)向\(v\)连一条容量为\(1\),费用为\(z\)的边,保证下界:从\(u\)向\(T\)连一条容量为\(1\),费用为\(0\)的边,也是用来保证下界的.由于没有上界,所以直接从\(u\)向\(v\)连一条容量为\(INF\),费用为\(z\)的边即可. 注意这道题可以在任意一

bzoj3876【Ahoi2014】支线剧情

3876: [Ahoi2014]支线剧情 Time Limit: 10 Sec  Memory Limit: 256 MB Submit: 485  Solved: 297 [Submit][Status][Discuss] Description [故事背景] 宅男JYY非常喜欢玩RPG游戏,比如仙剑,轩辕剑等等.不过JYY喜欢的并不是战斗场景,而是类似电视剧一般的充满恩怨情仇的剧情.这些游戏往往 都有很多的支线剧情,现在JYY想花费最少的时间看完所有的支线剧情. [问题描述] JYY现在所玩

[AHOI2014][bzoj3876] 支线剧情 [上下界费用流]

题面 传送门 思路 转化模型:给一张有向无环图,每次你可以选择一条路径走,花费的时间为路径上边权的总和,问要使所有边都被走至少一遍(可以重复),至少需要花费多久 走至少一遍,等价于覆盖这条边 也就是说,我们要找这个图的一个可重复的路径覆盖 路径覆盖让我们想到什么算法了呢? 网络流啊! 我们考虑建立网络流图模型. 这道题里面有个关键:走过一条边,走几次就要花几次的费用,这想到什么? 费用流嘛! 我们定义走一次路径会给这条路径上的所有边增加1的流量,再给所有边赋一个费用等于边权 这样,我们只要设每条

【BZOJ3876】【Ahoi2014】支线剧情 有下界的最小费用最大流

#include <stdio.h> int main() { puts("转载请注明出处谢谢"); puts("http://blog.csdn.net/vmurder/article/details/43025375"); } [BZOJ2324]营救皮卡丘 这道题也是一道有下界的最小费用最大流. 我的题解地址:http://blog.csdn.net/vmurder/article/details/41378979 这道题其实就是模板题. 我的处理

BZOJ 3876 AHOI 2014 支线剧情 有下界有源汇的费用流

题目大意:主人公在玩游戏,他的存档系统坏了,只能从头开始游戏,不能从中途开始,问最少多长时间可以走过所有的流程. 思路:每一条边都要至少走一次,这是流量的下界,源点是游戏的开始,汇点是所有结局.裸的有下界有源汇的费用流.我也不知道为什么要那样建图.. CODE: #include <queue> #include <cstdio> #include <cstring> #include <iostream> #include <algorithm>