[BZOJ 1070][SCOI2007]修车(费用流)

Description

同一时刻有N位车主带着他们的爱车来到了汽车维修中心。维修中心共有M位技术人员,不同的技术人员对不同的车进行维修所用的时间是不同的。现在需要安排这M位技术人员所维修的车及顺序,使得顾客平均等待的时间最小。 说明:顾客的等待时间是指从他把车送至维修中心到维修完毕所用的时间。

Solution

非常经典的建图方式,将每一位技术人员拆成n个点分别他是表示倒数第几个修车的,倒数第k个修车的技术人员对所有在等待的人的贡献是tim[i][j]*k

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<queue>
#define INF 0x3f3f3f3f
#define dot(x,y) (x+(y-1)*m)    //维修人员x在倒数第y的位置
using namespace std;
int s,t,n,m,head[1005],cnt=0,tim[70][10];
int dis[5005],f[5005],pre[5005];
bool inq[5005];
int read()
{
    int x=0,f=1;char c=getchar();
    while(c<‘0‘||c>‘9‘){if(c==‘-‘)f=-1;c=getchar();}
    while(c>=‘0‘&&c<=‘9‘){x=x*10+c-‘0‘;c=getchar();}
    return x*f;
}
struct Node
{
    int next,from,to,cap,w;
}Edges[500005];
void addedge(int u,int v,int c,int w)
{
    Edges[cnt].next=head[u];
    head[u]=cnt;
    Edges[cnt].from=u,Edges[cnt].to=v;
    Edges[cnt].w=w;
    Edges[cnt++].cap=c;
}
void insert(int u,int v,int c,int w)
{
    addedge(u,v,c,w);
    addedge(v,u,0,-w);
}
queue<int>q;
int MCMF()
{
    int flow=0,cost=0;
    while(1)
    {
        memset(dis,0x3f,sizeof(dis));
        memset(f,0,sizeof(f));
        q.push(s),pre[s]=-1,inq[s]=1,dis[s]=0,f[s]=INF;
        while(!q.empty())
        {
            int u=q.front();
            q.pop(),inq[u]=0;
            for(int i=head[u];~i;i=Edges[i].next)
            {
                int v=Edges[i].to;
                if(Edges[i].cap>0&&dis[v]>dis[u]+Edges[i].w)
                {
                    dis[v]=dis[u]+Edges[i].w;
                    f[v]=min(f[u],Edges[i].cap);
                    pre[v]=i;
                    if(!inq[v])q.push(v),inq[v]=1;
                }
            }
        }
        if(dis[t]==INF)break;
        flow+=f[t],cost+=dis[t]*f[t];
        int p=t;
        while(pre[p]!=-1)
        {
            Edges[pre[p]].cap-=f[t];
            Edges[pre[p]^1].cap+=f[t];
            p=Edges[pre[p]].from;
        }
    }
    return cost;
}
int main()
{
    memset(head,-1,sizeof(head));
    m=read(),n=read(),s=0,t=n*m*2+1;
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
    {
        insert(dot(j,i),t,1,0);
        tim[i][j]=read();    //第i辆车被第j位维修员维修的时间 tim[i][j]
        for(int k=1;k<=n;k++)
        insert(n*m+i,dot(j,k),1,tim[i][j]*k);
    }
    for(int i=1;i<=n;i++)insert(s,n*m+i,1,0);
    printf("%.2lf\n",(double)MCMF()/n);
    return 0;
}
时间: 2024-01-23 01:17:28

[BZOJ 1070][SCOI2007]修车(费用流)的相关文章

bzoj 1070: [SCOI2007]修车 -- 费用流

1070: [SCOI2007]修车 Time Limit: 1 Sec  Memory Limit: 128 MB Description 同一时刻有N位车主带着他们的爱车来到了汽车维修中心.维修中心共有M位技术人员,不同的技术人员对不同的车进行维修所用的时间是不同的.现在需要安排这M位技术人员所维修的车及顺序,使得顾客平均等待的时间最小. 说明:顾客的等待时间是指从他把车送至维修中心到维修完毕所用的时间. Input 第一行有两个m,n,表示技术人员数与顾客数. 接下来n行,每行m个整数.第

BZOJ 1070: [SCOI2007]修车(最小费用最大流)

建图很神奇..建完图其实就是裸的费用流了.. -------------------------------------------------------------- #include<cstdio> #include<cstring> #include<algorithm> #include<iostream> #include<vector> #include<queue> #define rep(i,n) for(int i

BZOJ 1070 拆点 费用流

1070: [SCOI2007]修车 Time Limit: 1 Sec  Memory Limit: 128 MBSubmit: 5860  Solved: 2487[Submit][Status][Discuss] Description 同一时刻有N位车主带着他们的爱车来到了汽车维修中心.维修中心共有M位技术人员,不同的技术人员对不同 的车进行维修所用的时间是不同的.现在需要安排这M位技术人员所维修的车及顺序,使得顾客平均等待的时间最 小. 说明:顾客的等待时间是指从他把车送至维修中心到维

[BZOJ 1070] [SCOI2007] 修车 【费用流】

题目链接:BZOJ - 1070 题目分析 首先想到拆点,把每个技术人员拆成 n 个点,从某个技术人员拆出的第 i 个点,向某辆车连边,表示这是这个技术人员修的倒数第 i 辆车.那么这一次修车对整个答案的贡献就是,i * Time[j][k]. j 是车的编号,k 是技术人员编号.因为这辆车以及之后这个人要修的车的等待时间都增加了 Time[j][k], 所以包括这辆车在内一共有 i 辆车的等待时间加上了这次修车的时间.这样倒着考虑就可以用边的费用很简便的表示修车使所有人增加的时间了.从 S 到

BZOJ SCOI 2007 修车 费用流

题目大意:有一些车和一些修车的人,给出每个人修每个车的时间,问所有人等待的最短平均时间是多少. 思路:记得POJ有一个和这个很像的题,做法是一样的.对于每个人修车的时候,我们只考虑他修车的时间对在它之后修车的人的时间的影响,因此我们只要考虑每一辆车是倒数第几个修的就可以了,然后朴素的建图,跑朴素的费用流,就可以过. CODE: #include <queue> #include <cstdio> #include <cstring> #include <ioman

[BZOJ1070] [SCOI2007] 修车 (费用流 &amp; 动态加边)

Description 同一时刻有N位车主带着他们的爱车来到了汽车维修中心.维修中心共有M位技术人员,不同的技术人员对不同的车进行维修所用的时间是不同的.现在需要安排这M位技术人员所维修的车及顺序,使得顾客平均等待的时间最小. 说明:顾客的等待时间是指从他把车送至维修中心到维修完毕所用的时间. Input 第一行有两个m,n,表示技术人员数与顾客数. 接下来n行,每行m个整数.第i+1行第j个数表示第j位技术人员维修第i辆车需要用的时间T. Output 最小平均等待时间,答案精确到小数点后2位

BZOJ 1070 [SCOI2007]修车 最小费用流

题意:链接 方法:最小费用最大流 解析:前几天做的费用流,很经典,很神奇,很6的一道题,不过当时做完没时间写博客,所以今天给他传上来. 所以没看题解前我并没有做出来这道题,当时满脑子退?流?的思想啥都搞不出来. 看完题解后感觉好神奇! 假设n个人m辆车,那么每一个人都有一行状态,对应的是什么呢?是他倒数第几个修的是哪辆车,而这又是不确定的,所以我们还得将这个点连向m辆车,流量就是1,而费用呢就是倒数第几个乘以修理时间,原因呢?就是如果这个人倒数第几个修的这辆车的话,那么其他人都需要等他修完,所以

bzoj 1070: [SCOI2007]修车

1 #include<cstdio> 2 #include<iostream> 3 #include<cstring> 4 #define M 10000 5 #define inf 2139062143 6 using namespace std; 7 int cnt=1,n,m,T,d[M],q[2*M],f[M],head[M],next[10*M],u[10*M],v[10*M],w[10*M],fro[10*M],fr[M]; 8 int mp[100][10

P2053 [SCOI2007]修车 费用流

https://www.luogu.org/problemnew/show/P2053 题意 同一时刻有N位车主带着他们的爱车来到了汽车维修中心.维修中心共有M位技术人员,不同的技术人员对不同的车进行维修所用的时间是不同的.现在需要安排这M位技术人员所维修的车及顺序,使得顾客平均等待的时间最小. 说明:顾客的等待时间是指从他把车送至维修中心到维修完毕所用的时间. 思路 左边放n个点,表示n辆车.右边放m * n个点,表示m个工人,拆除n个点表示不同阶段.即如果第i辆车连上了第m个工人的第k个阶段