Code[VS] 1035 火车停留题解

最新推荐文章于 2020-03-28 12:15:00 发布

应佑宇

最新推荐文章于 2020-03-28 12:15:00 发布

阅读量436

点赞数

分类专栏：题解

本文链接：https://blog.csdn.net/yingyouyu/article/details/98972093

版权

题解专栏收录该内容

39 篇文章 0 订阅

订阅专栏

题目

题目描述 $D e s c r i p t i o n$

“今天你要去远行，送你风雨中……”，伴着凄美的歌声，郭靖夫妇终于踏上征程。为了尽快到达边疆为国效力，他们搭上了 $2002$ 次列车。可在途径 $s w e e t$ $s t a t i o n$ 时，被该站站长缠住了身，是什么原因呢？
　　因为该车站由于经营不善，面临破产，该站负责人早闻黄蓉聪明过人，一定要她帮忙出出主意，挽救车站。
　　该车站有 $n$ 个车道，由于车道的长度有限，每个车道在某一时刻最多只能停靠一列火车。该站每天将有 $m$ 列火车从车站经过，其中第i列火车到达车站的时间为 $Reach_i$ ，火车上装有价值 $Cost_i$ 的货物。
　　如果该火车进站，则车站将获得 $Cost_i$ 的1%收益，但由于货物的搬运时间，该火车将在车站停留一段时间 $Stay_i$ ，这段时间内，火车将占用车站中的某一个车道。当然，火车也可以不在站中停靠而直接出站，但这样车站将得不到一分钱。
　　要挽救车站，就是要对车站的列车进行调度，使获得的效益最大。当然，解决这个问题对于黄蓉来说并不难，但边疆吃紧，时间不等人，你能帮帮黄蓉，让她脱身吗？
任务:运行你的程序得到该站的最大效益。

输入描述 $I n p u t$ $D e s c r i p t i o n$

第1行中为两个正整数： $n$ （ $n \leq 20$ ） $m$ （ $m \leq 100$ ），第 $2$ 行到第 $m + 1$ 行，每行有 $3$ 个不超过 $1000$ 正整数。第 $i + 1$ 行的 $3$ 个数分别为： $Reach_i$ ， $Cost_i$ 和 $Stay_i$ ，它们用单个空格分隔。

输出描述 $O u t p u t$ $D e s c r i p t i o n$

仅有一行，为车站的最大收益（精确到小数点后 $2$ 位）。注意，如果火车 $a$ 从第 $i$ 车道离开时，火车 $b$ 刚好到站（即 $Reach_a+Stay_a=Reach_b$ ），则它不能进入第 $i$ 车道。

样例输入 $S a m p l e$ $I n p u t$

样例输出 $S a m p l e$ $O u t p u t$

0.11

数据范围及提示 $D a t a$ $S i z e$ & $H i n t$

题解

前往题目
分析：读题之后发现是让费用最大，不容易考虑到费用流，其实费用最大和最小是一样的，费用最大的话可以把费用变为负值求最小的。

建图方法：

超级源点 $s s$ 连接 $s$ ，容量为 $n$ ，费用为 $0$

把每个列车拆成两个点 $i$ 和 $i i$ ，之间建边容量为 $1$ ，费用为给车站交的钱的相反数

$s$ 连接 $i$ ，容量 $i n f$ ，费用 $0$

$i i$ 连接 $t$ ，容量 $i n f$ ，费用 $0$

所有时刻末点在初点前面的，枚举建边，容量为 $1$ ，费用 $0$

然后求一次费用流，其相反数就是 $a n s$

$A C$ 代码：

/*
作者:应佑宇
题目:p1035 火车停留
*/
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
#include <cstring>
#include <queue>
#include <string>
#include <map>
using namespace std;
#define Del(a,b) memset(a,b,sizeof(a))
const int inf = 0x3f3f3f3f;
const int N = 220;
struct Node
{
    int from,to,cap,flow;
    double cost;
};
vector<Node> e;
vector<int> v[N];
int vis[N];
double dis[N];
int p[N],a[N];  //p保存father，a保存cap
void Clear(int x)
{
    for(int i=0;i<=x;i++)
        v[i].clear();
    e.clear();
}
void add_Node(int from,int to,int cap,double cost)  //shaB
{
    e.push_back((Node){from,to,cap,0,cost});
    e.push_back((Node){to,from,0,0,-cost});
    int len = e.size()-1;
    v[to].push_back(len);
    v[from].push_back(len-1);
}
bool BellmanFord(int s,int t,int& flow,double& cost)
{
    for(int i=0;i<=N;i++)
        dis[i] = 1000000000;
    Del(vis,0);
    dis[s] = 0;
    vis[s] = 1;
    p[s] = 0;
    a[s] = inf;
    queue<int> q;
    q.push(s);
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        vis[u] = 0;
        for(int i=0; i<v[u].size(); i++)
        {
            Node& g = e[v[u][i]];
            if(g.cap>g.flow && dis[g.to] > dis[u]+g.cost)
            {
                dis[g.to] = dis[u] + g.cost;
                //printf("%.5lf\n",g.cost);
                p[g.to] = v[u][i];  //保存前驱
                a[g.to] = min(a[u],g.cap-g.flow);
                if(!vis[g.to])
                {
                    q.push(g.to);
                    vis[g.to]=1;
                }
 
            }
        }
    }
    if(dis[t] == 1000000000)
        return false;
    flow += a[t];
    cost += dis[t]*a[t];
    int u = t;
    while(u!=s)
    {
        e[p[u]].flow += a[t];
        e[p[u]^1].flow -= a[t];
        u = e[p[u]].from;
    }
    return true;
}
double Min_Cost(int s,int t)
{
    int flow=0;
    double cost = 0;
    while(BellmanFord(s,t,flow,cost));
    return cost;
}
struct Tree{
    int fir,sec;
    double val;
};
Tree kf[200];
int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        int ss = 0 , s = 1;
        int t = 2*m + 3 ,tt = t+1;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%lf%d",&kf[i].fir,&kf[i].val,&kf[i].sec);
            kf[i].sec+=kf[i].fir;
            add_Node(s,2*i,inf,0);
            double cs = kf[i].val * 0.01;
            //printf("%.5lf \n",cs);
            add_Node(2*i,2*i+1,1,-cs);
            add_Node(2*i+1,t,inf,0);
        }
        for(int i=1;i<=m;i++)
        {
            for(int j=1;j<=m;j++)  //注意这里
            {
                if(i==j)
                    continue;
                if(kf[j].fir>kf[i].sec)
                    add_Node(i*2+1,j*2,1,0);
            }
        }
        add_Node(ss,s,n,0.0);
        double ans = Min_Cost(ss,t);
        printf("%.2lf\n",-ans);
        Clear(tt);
    }
    return 0;
}