sgu 252. Railway Communication （最小费用最大流）

252. Railway Communication

time limit per test: 0.25 sec.
memory limit per test: 65536 KB

input: standard
output: standard

There are N towns in the country, connected with M railroads. All railroads are one-way, the railroad system is organized in such a way that there are no cycles. It's necessary to choose the best trains schedule, taking into account some facts. 
Train path is the sequence of towns passed by the train. The following conditions must be satisfied. 
1) At most one train path can pass along each railroad. 
2) At most one train path can pass through each town, because no town can cope with a large amount of transport. 
3) At least one train path must pass through each town, or town economics falls into stagnation. 
4) The number of paths must be minimal possible. 
Moreover, every railroad requires some money for support, i-th railroad requires c[i] coins per year to keep it intact. That is why the president of the country decided to choose such schedule that the sum of costs of maintaining the railroads used in it is minimal possible. Of course, you are to find such schedule.

Input

The first line of input contains two integers N and M (1<=N<=100; 0<=M<=1000). Next M lines describe railroads. Each line contains three integer numbers a[i], b[i] and c[i] - the towns that the railroad connects (1<=a[i]<=N; 1<=b[i]<=N, a[i]<>b[i]) and the cost of maintaining it (0<=c[i]<=1000). Since the road is one-way, the trains are only allowed to move along it from town a[i] to town b[i]. Any two towns are connected by at most one railroad.

Output

On the first line output K - the number of paths in the best schedule and C - the sum of costs of maintaining the railroads in the best schedule. 
After that output K lines, for each train path first output L[i] (1<=L[i]<=N) - the number of towns this train path uses, and then L[i] integers identifying the towns on the train path. If there are several optimal solutions output any of them.

Sample test(s)

Input

4 4 1 2 1 1 3 2 3 4 2 2 4 2

Output

2 3 
2 1 2 
2 3 4

一个有向无环图，要求用最少的不相交路径覆盖所有的点，多解使路径权和最小。把每个点拆分成入点和出点，原图中的边a到b，对应为aout到bin，然后跑费用流。这样匹配，每一个没有被匹配过的入点，就意味着必须有一条路径以它为起点。

#include<cstdio>
#include<map>
#include<queue>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<list>
#include<set>
#include<cmath>
using namespace std;
const int maxn = 1e3 + 5;
const int INF = 1e9;
const double eps = 1e-6;
typedef unsigned long long ULL;
typedef long long LL;
typedef pair<int, int> P;
#define fi first
#define se second

struct Edge {
  int from, to, cap, flow, cost;
};

struct MCMF {
  int n, m, s, t;
  vector<Edge> edges;
  vector<int> G[maxn];
  int inq[maxn];         // 是否在队列中
  int d[maxn];           // Bellman-Ford,单位流量的费用
  int p[maxn];           // 上一条弧
  int a[maxn];           // 可改进量

  void init(int n) {
    this->n = n;
    for(int i = 0; i < n; i++) G[i].clear();
    edges.clear();
  }

  void AddEdge(int from, int to, int cap, int cost) {
    edges.push_back((Edge){from, to, cap, 0, cost});
    edges.push_back((Edge){to, from, 0, 0, -cost});
    m = edges.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
  }

  bool BellmanFord(int s, int t, int &flow,int &cost) {
    for(int i = 0; i < n; i++) d[i] = INF;
    memset(inq, 0, sizeof(inq));
    d[s] = 0; inq[s] = 1; p[s] = 0; a[s] = INF;

    queue<int> Q;
    Q.push(s);
    while(!Q.empty()) {
      int u = Q.front(); Q.pop();
      inq[u] = 0;
      for(int i = 0; i < G[u].size(); i++) {
        Edge& e = edges[G[u][i]];
        if(e.cap > e.flow && d[e.to] > d[u] + e.cost) {
          d[e.to] = d[u] + e.cost;
          p[e.to] = G[u][i];
          a[e.to] = min(a[u], e.cap - e.flow);
          if(!inq[e.to]) { Q.push(e.to); inq[e.to] = 1; }
        }
      }
    }
    if(d[t] == INF) return false;//s-t不连通，失败退出
    flow += a[t];
    cost += d[t] * a[t];
    int u = t;
    while(u != s) {
      edges[p[u]].flow += a[t];
      edges[p[u]^1].flow -= a[t];
      u = edges[p[u]].from;
    }
    return true;
  }

  // 需要保证初始网络中没有负权圈
  int Mincost(int s, int t, int& flow) {
    int cost = 0;
    while(BellmanFord(s, t,flow, cost));
    return cost;
  }

    void print(int total){
        for(int i = total;i >= 1;i--){
            int e = G[i+total][0];
            int f = edges[e].flow;
            if(f == 0){
                vector<int> path;
                path.clear();
                path.push_back(i);
                int pos = i;
                int tag = 1;
                while(tag){
                    tag = 0;
                    for(int u = 0;u < G[pos].size();u++){
                        int e = G[pos][u];
                        int f = edges[e].flow;
                        if(f != 0 && edges[e].to > total){
                            pos = edges[e].to-total;
                            path.push_back(pos);
                            tag = 1;
                            break;
                        }
                    }
                }

                printf("%d", path.size());
                for(int j = 0;j < path.size();j++){
                    printf(" %d", path[j]);
                }
                puts("");
            }
        }
    }
};

MCMF solver;

int main(){
    int n, m;
    while(scanf("%d%d", &n, &m) != EOF){
        solver.init(2*n+5);
        int source = 0, sink = 2*n+1;
        for(int i = 1;i <= n;i++){
            solver.AddEdge(source, i, 1, 0);
            solver.AddEdge(i+n, sink, 1, 0);
        }
        while(m--){
            int x, y, c;
            scanf("%d%d%d", &x, &y, &c);
            solver.AddEdge(x, y+n, 1, c);
        }
        int flow = 0;
        int cost = solver.Mincost(source, sink, flow);
        printf("%d %d\n", n-flow, cost);
        solver.print(n);
    }
    return 0;
}