SDOI2009 晨跑

题目描述 Description

Elaxia最近迷恋上了空手道，他为自己设定了一套健身计划，比如俯卧撑、仰卧起坐等等，不过到目前为止，他坚持下来的只有晨跑。

现在给出一张学校附近的地图，这张地图中包含N个十字路口和M条街道，Elaxia只能从一个十字路口跑向另外一个十字路口，街道之间只在十字路口处相交。Elaxia每天从寝室出发跑到学校，保证寝室编号为1，学校编号为N。

Elaxia的晨跑计划是按周期（包含若干天）进行的，由于他不喜欢走重复的路线，所以在一个周期内，每天的晨跑路线都不会相交（在十字路口处），寝室和学校不算十字路口。Elaxia耐力不太好，他希望在一个周期内跑的路程尽量短，但是又希望训练周期包含的天数尽量长。

除了练空手道，Elaxia其他时间都花在了学习和找MM上面，所有他想请你帮忙为他设计一套满足他要求的晨跑计划。

输入描述 Input Description

第一行：两个数N,M。表示十字路口数和街道数。

接下来M行，每行3个数a,b,c，表示路口a和路口b之间有条长度为c的街道（单向）。

输出描述 Output Description

两个数，第一个数为最长周期的天数，第二个数为满足最长天数的条件下最短的路程长度。

样例输入 Sample Input

7 10

1 2 1

1 3 1

2 4 1

3 4 1

4 5 1

4 6 1

2 5 5

3 6 6

5 7 1

6 7 1

样例输出 Sample Output

2 11

数据范围及提示 Data Size & Hint

对于30%的数据，N ≤ 20，M ≤ 120。

对于100%的数据，N ≤ 200，M ≤ 20000。

 

 

　　这个题目，是一个最小费用最大流问题（如果没有接触过该类问题，请自行百度），费用相当于路程，流量相当于路途种数。因为一个节点只能走一遍，所以一条道路也只能走一遍，所以每条道路的流量限制为1就可以。

　　可如果单纯把每条道路限制为1的话，还是无法保证每个节点都只能走一遍，所以我们可以把一个节点拆成两个节点A,B，两个节点中间有一条流量限制为1的单向边A->B，指向该节点的边都让他指向A，流出的边都让他从B流出，这样一个节点的访问边数就被限制住了。

 

代码如下：

 1 #include<iostream>
 2 #include<vector>
 3 #include<queue>
 4 #include<cmath>
 5 #include<cstring>
 6 using namespace std;
 7 
 8 int n, m, flow;
 9 int cost;
10 
11 struct Edge{
12     int from, to, cap, flow, cost;
13     Edge(int u, int v, int c, int f, int o): from(u), to(v), cap(c), flow(f), cost(o){}
14 };
15 
16 struct MCMF{
17     vector<Edge> edges;
18     vector<int> G[500];
19     int a[500];
20     int p[500];
21     int b[500];
22     int inq[500];
23     
24     void init() {      //初始化
25         for (int i = 1; i <= 500; i++)
26             G[i].clear();
27         edges.clear();
28     }
29     
30     void AddEdge(int from, int to, int cost) {       //加边
31         edges.push_back(Edge(from, to, 1, 0, cost));
32         edges.push_back(Edge(to, from, 0, 0, -cost));
33         int m = edges.size();
34         G[from].push_back(m - 2);
35         G[to].push_back(m - 1);
36     } 
37     
38     bool BellmanFord(int s, int t, int& flow, int& cost) {               //最小费用最大流
39         for (int i = 1; i <= 2 * n; i++)
40             b[i] = 1 << 30;
41         memset(inq, 0, sizeof(inq));
42         a[s] = 1 << 30; b[s] = 0; p[s] = 0; inq[s] = 1;
43         queue<int> Q;
44         Q.push(s);
45         while (!Q.empty()) {
46             int u = Q.front(); Q.pop();
47             inq[u] = 0;
48             for (int i = 0; i < G[u].size(); i++) {
49                 Edge& e = edges[G[u][i]];
50                 if (e.cap > e.flow && b[e.to] > b[u] + e.cost) {
51                     p[e.to] = G[u][i];
52                     b[e.to] = b[u] + e.cost;
53                     a[e.to] = min(e.cap - e.flow, a[u]);
54                     if (!inq[e.to]) {
55                         inq[e.to] = 1;
56                         Q.push(e.to);
57                     }
58                 }
59             }
60         }
61         if (b[t] == 1 << 30) return false;
62         cost += b[t] * a[t];
63         flow += a[t];
64         for (int u = t; u != s; u = edges[p[u]].from) {
65             edges[p[u]].flow += a[t];
66             edges[p[u] ^ 1].flow -= a[t];
67         }            
68         return true;
69     }
70 };
71 
72 int main() {
73     ios::sync_with_stdio(false);
74     cin >> n >> m;
75     MCMF a;
76      for (int i = 2; i < n; i++)
77         a.AddEdge(i, n + i, 0);    //拆点
78     for (int i = 0; i < m; i++) {
79         int s, t, leng;
80         cin >> s >> t >> leng;
81         if (s != 1 && s != n) s = n + s;   //改变流出位置
82         a.AddEdge(s, t, leng);
83     }
84     while (a.BellmanFord(1, n, flow, cost)) {}   //最小费用最大流
85     cout << flow << ' ' << cost;
86     return 0;
87 }

 

posted @ 2015-03-18 10:33  Xstsow  阅读(332)  评论(0)  编辑  收藏  举报