洛谷P2053 [SCOI2007]修车

最新推荐文章于 2021-10-16 17:56:38 发布

weixin_30497527

最新推荐文章于 2021-10-16 17:56:38 发布

阅读量70

点赞数

原文链接：http://www.cnblogs.com/gjc1124646822/p/8818416.html

版权

题目：https://www.luogu.org/problemnew/show/P2053

题目描述

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

说明：顾客的等待时间是指从他把车送至维修中心到维修完毕所用的时间。

输入输出格式

输入格式：

第一行有两个数M,N，表示技术人员数与顾客数。

接下来n行，每行m个整数。第i+1行第j个数表示第j位技术人员维修第i辆车需要用的时间T。

输出格式：

最小平均等待时间，答案精确到小数点后2位。

输入输出样例

输入样例#1：复制

2 2
3 2
1 4

输出样例#1：复制

1.50

说明

(2<=M<=9,1<=N<=60), (1<=T<=1000)

解析

AFO了回来填坑了。。。。。。

做完此题推荐P2050 [NOI2012]美食节

首先看到这道题你可能会去想贪心，

但是数据范围否定了想法。

首先这道题你要知道：

①一个人在某一时刻只能修一辆车/在偷懒

②一辆车在某一时刻只能被一个人修/被抛弃

题意清楚后我们来看这道题。

如果你要从让工人老老实实从第一辆车修到最后一辆车这样的思路去想，

那么你可以去想一个非常巧妙的贪心，然而数据范围否定了我的想法。

正着建图有点艰难，我们换一种思路。

前面修的车会对后面修的车产生影响，影响难以确定，但是后面的车对前面的没有什么影响。

我们就可以反过来思考，设第i个工人修第j辆车要的时间为tm，

那么如果这辆车是倒数第k个被修的，他的贡献就是k*tm，

因为后面（k-1）辆车要等这一段时间，当然还要加上这辆车本身。

所以思路出来了，建图如下：

①把工人拆成n个点，代表每个工人修的倒数第几辆车

②S->顾客（也就是每辆车），flow=1，cost=0

③顾客（每辆车）->修车情况（也就是①）：

　第i个顾客（车），第j个工人修的倒数第k辆车：

　flow=1，cost=k*(tm[j][i]*k)，其中tm[j][i]代表第j个工人修第i辆车话费的时间。

④修车情况->T，flow=1，cost=0

蒟蒻的代码奉上

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<algorithm>
 4 #include<cstring>
 5 #include<cmath>
 6 #include<vector>
 7 #include<queue>
 8 using namespace std;
 9 const int maxn=10010;
10 struct line{
11     int u,v;
12     int cap,flow,cost;
13 };
14 vector<line> edge;
15 vector<int> G[maxn];
16 int dis[maxn],a[maxn],pre[maxn];
17 bool vis[maxn];
18 int n,m,S,T;
19 int t[10][70];
20 double ans;
21 void addedge(int from,int to,int cap,int cost){
22     edge.push_back((line){from,to,cap,0,cost});
23     edge.push_back((line){to,from,0,0,-cost});
24     int m=edge.size();
25     G[from].push_back(m-2);
26     G[to].push_back(m-1);
27 }
28 bool spfa(int &minc){
29     memset(dis,0x3f,sizeof(dis));
30     memset(vis,false,sizeof(vis));
31     queue<int> q; q.push(S);
32     vis[S]=true; dis[S]=0;
33     a[S]=2147483647;
34     while(!q.empty()){
35         int u=q.front(); q.pop();
36         vis[u]=false;
37         for (int i=0;i<G[u].size();++i){
38             line e=edge[G[u][i]];
39             if (e.cap>e.flow&&dis[e.v]>dis[u]+e.cost){
40                 pre[e.v]=G[u][i];
41                 dis[e.v]=dis[u]+e.cost;
42                 a[e.v]=min(a[u],e.cap-e.flow);
43                 if (!vis[e.v]){
44                     vis[e.v]=true;
45                     q.push(e.v);
46                 } 
47             }
48         }
49     }
50     if (dis[T]==dis[maxn-1]) return false;
51     minc+=a[T]*dis[T];
52     int u=T;
53     while (u!=S){
54         edge[pre[u]].flow+=a[T];
55         edge[pre[u]^1].flow-=a[T];
56         u=edge[pre[u]].u;
57     }
58     return true;
59 }
60 int mcmf(){
61     int mincost=0;
62     while (spfa(mincost));
63     return mincost;
64 }
65 int main(){
66     scanf("%d%d",&m,&n);
67     for (int i=1;i<=n;++i){
68         for (int j=1;j<=m;++j){
69             scanf("%d",&t[j][i]);
70         }
71     }
72     S=0; T=n*m+n+1;
73     for (int i=1;i<=n;++i){
74         addedge(S,n*m+i,1,0);
75     }
76     for (int i=1;i<=n;++i){
77         for (int j=1;j<=m;++j){
78             for (int k=1;k<=n;++k){
79                 addedge(n*m+i,(j-1)*n+k,1,t[j][i]*k);
80             }
81         }
82     }
83     for (int j=1;j<=m;++j){
84         for (int k=1;k<=n;++k){
85             addedge((j-1)*n+k,T,1,0);
86         }
87     }
88     ans=mcmf(); ans=(double)ans/(double)n;
89     printf("%.2lf",ans);
90     return 0;
91 }