UVA 1349 Optimal Bus Route Design 最优公交路线（最小费用流，拆点）

 

 

题意：给若干景点，每个景点有若干单向边到达其他景点，要求规划一下公交路线，使得每个景点有车可达，并且每个景点只能有1车经过1次，公车必须走环形回到出发点（出发点走2次）。问是否存在这样的线路？若存在就给出所有公交车需要走过的路的长度，要求长度尽量小。

 

分析：这超级难发现是网络流来做的。要将每个点归结到某个环上，那么环上的点都是只有1个前驱，1个后继。如果1个前驱配1个后继，就是匹配问题了。但是这样的匹配有点混杂，所以要拆点，将1个点拆成2个，分别处于X和Y集中，然后根据有向边建图。成了带权二分图的匹配了，只是要求权最小。

　　建图步骤，对于每条有向边a->b，由于b放在Y集中，编号就改变为2*b+1，而a在左边，改变为a*2，容量是1，因为只能匹配一次，费用为长度。当然肯定需要反边了！接着添加汇点，由Y集到汇点都有边，再添加源点，源点到X集都有边，他们容量都是1费用0。

 

  1 #include <bits/stdc++.h>

  2 #define LL long long

  3 #define pii pair<int,int>

  4 #define INF 0x7f7f7f7f

  5 using namespace std;

  6 const int N=200+50;

  7 

  8 struct node

  9 {

 10     int from;

 11     int to;

 12     int val;

 13     int cap;

 14     int flow;

 15 }edge[N*N];

 16 int edge_cnt, ans_cost;

 17 int flow[N], cost[N], path[N], inq[N];

 18 

 19 vector<int> vect[N];

 20 

 21 void add_node(int from,int to,int val,int cap,int flow)

 22 {

 23     edge[edge_cnt].from=from;

 24     edge[edge_cnt].to=to;

 25     edge[edge_cnt].val=val;

 26     edge[edge_cnt].cap=cap;

 27     edge[edge_cnt].flow=flow;

 28     vect[from].push_back(edge_cnt++);

 29 }

 30 

 31 

 32 int spfa(int s,int e)

 33 {

 34     deque<int> que(1,s);

 35     inq[s]=1;

 36     flow[s]=INF;

 37     cost[s]=0;

 38     while(!que.empty())

 39     {

 40         int x=que.front();que.pop_front();

 41         inq[x]=0;

 42         for(int i=0; i<vect[x].size(); i++)

 43         {

 44             node e=edge[vect[x][i]];

 45             if( e.cap>e.flow && cost[e.to]>cost[e.from]+e.val )

 46             {

 47                 flow[e.to]=min(flow[e.from], e.cap-e.flow);

 48                 cost[e.to]=cost[e.from]+e.val;

 49                 path[e.to]=vect[x][i];

 50                 if(!inq[e.to])

 51                 {

 52                     inq[e.to]=1;

 53                     que.push_back(e.to);

 54                 }

 55             }

 56         }

 57     }

 58     return flow[e];

 59 }

 60 

 61 

 62 int cal(int s,int e)

 63 {

 64     int ans_flow=0;

 65     while(true)

 66     {

 67         memset(flow,0,sizeof(flow));

 68         memset(path,0,sizeof(path));

 69         memset(cost,0x7f,sizeof(cost));

 70         memset(inq,0,sizeof(inq));

 71 

 72         int tmp=spfa(s,e);

 73         if(!tmp)    return ans_flow;

 74         ans_flow+=tmp;

 75         ans_cost+=cost[e];//长度

 76 

 77         int ed=e;

 78         while(ed!=s)

 79         {

 80             int t=path[ed];

 81             edge[t].flow+=flow[e];

 82             edge[t^1].flow-=flow[e];

 83             ed=edge[t].from;

 84         }

 85     }

 86 }

 87 

 88 

 89 int main()

 90 {

 91     freopen("input.txt", "r", stdin);

 92     int n, b, v;

 93     while(scanf("%d",&n), n)

 94     {

 95         ans_cost=edge_cnt=0;

 96         for(int i=N-1; i>=0; i--)   vect[i].clear();

 97         memset(edge,0,sizeof(edge));

 98 

 99         for(int i=1; i<=n; i++)

100         {

101             while(scanf("%d",&b),b)

102             {

103                 scanf("%d",&v);

104                 add_node( i*2, b*2+1, v, 1, 0 );    //编号从2~n*2+1。

105                 add_node( b*2+1, i*2, -v, 0, 0 );

106             }

107         }

108         //添加汇点n*2+2，源点0

109         for(int i=1; i<=n; i++)

110         {

111             add_node(0, i*2, 0, 1, 0);

112             add_node(i*2, 0, 0, 0, 0);

113         }

114 

115         for(int i=1; i<=n; i++)

116         {

117             add_node(i*2+1, n*2+2, 0, 1, 0);

118             add_node(n*2+2, i*2+1, 0, 0, 0);

119         }

120 

121         if(cal(0, n*2+2)!=n)    puts("N");

122         else    printf("%d\n",ans_cost);

123 

124     }

125     return 0;

126 }

AC代码