POJ 3565 Ants（最佳完美匹配）

Description

Young naturalist Bill studies ants in school. His ants feed on plant-louses that live on apple trees. Each ant colony needs its own apple tree to feed itself.

Bill has a map with coordinates of n ant colonies and n apple trees. He knows that ants travel from their colony to their feeding places and back using chemically tagged routes. The routes cannot intersect each other or ants will get confused and get to the wrong colony or tree, thus spurring a war between colonies.

Bill would like to connect each ant colony to a single apple tree so that all n routes are non-intersecting straight lines. In this problem such connection is always possible. Your task is to write a program that finds such connection.

On this picture ant colonies are denoted by empty circles and apple trees are denoted by filled circles. One possible connection is denoted by lines.

Input

The first line of the input file contains a single integer number n (1 ≤ n ≤ 100) — the number of ant colonies and apple trees. It is followed by n lines describing n ant colonies, followed by n lines describing n apple trees. Each ant colony and apple tree is described by a pair of integer coordinates x and y (−10 000 ≤ x, y ≤ 10 000) on a Cartesian plane. All ant colonies and apple trees occupy distinct points on a plane. No three points are on the same line.

Output

Write to the output file n lines with one integer number on each line. The number written on i-th line denotes the number (from 1 to n) of the apple tree that is connected to the i-th ant colony.

题目大意：n个点A和n个点B，每一点A到一点B连一条线，要求n条线互不相交，求一种方案。

思路：可以证明，在费用最小的完美匹配下，所有连线没有相交。这里不证。

PS：WA了几遍才发现平方和最小，和不一定最小……

PS2：跑的是ZKW费用流，我是一个懒人没有改邻接矩阵……

代码（1797MS）（ZKW费用流）：

 //忘删调试语句了……
 #include <cstdio>
 #include <iostream>
 #include <queue>
 #include <cmath>
 #include <cstring>
 using namespace std;

 const int MAXV = ;
 const int MAXE = MAXV * MAXV;
 const double INF = 1e100;
 const double EPS = 1e-;

 inline int sgn(double x) {
     return (x > EPS) - (x < -EPS);
 }

 struct ZWK_FLOW {
     int head[MAXV];
     double dis[MAXV];
     int next[MAXE], to[MAXE], cap[MAXE];
     double cost[MAXE];
     int st, ed, ecnt, n;

     void init() {
         memset(head, , sizeof(head));
         ecnt = ;
     }

     void add_edge(int u, int v, int c, double w) {
         to[ecnt] = v; cap[ecnt] = c; cost[ecnt] = w; next[ecnt] = head[u]; head[u] = ecnt++;
         to[ecnt] = u; cap[ecnt] = ; cost[ecnt] = -w; next[ecnt] = head[v]; head[v] = ecnt++;
         //printf("%d %d %f\n", u, v - 5, w);
     }

     void SPFA() {
         for(int i = ; i <= n; ++i) dis[i] = INF;
         priority_queue<pair<double, int> > que;
         dis[st] = ;
         que.push(make_pair(, st));
         while(!que.empty()) {
             int u = que.top().second; double d = -que.top().first; que.pop();
             if(sgn(d - dis[u]) != ) continue;
             for(int p = head[u]; p; p = next[p]) {
                 int &v = to[p];
                 if(cap[p] && sgn(dis[v] - d - cost[p]) > ) {
                     dis[v] = d + cost[p];
                     que.push(make_pair(-dis[v], v));
                 }
             }
         }
         for(int i = ; i <= n; ++i) dis[i] = dis[ed] - dis[i];
     }

     double minCost;
     int maxFlow;
     bool use[MAXV];

     int add_flow(int u, int aug) {
         if(u == ed) {
             maxFlow += aug;
             minCost += dis[st] * aug;
             return aug;
         }
         use[u] = true;
         int now = aug;
         for(int p = head[u]; p; p = next[p]) {
             int &v = to[p];
             if(cap[p] && !use[v] && sgn(dis[u] - dis[v] - cost[p]) == ) {
                 int t = add_flow(v, min(now, cap[p]));
                 cap[p] -= t;
                 cap[p ^ ] += t;
                 now -= t;
                 if(!now) break;
             }
         }
         return aug - now;
     }

     bool modify_label() {
         double d = INF;
         for(int u = ; u <= n; ++u) if(use[u])
             for(int p = head[u]; p; p = next[p]) {
                 int &v = to[p];
                 if(cap[p] && !use[v]) d = min(d, dis[v] + cost[p] - dis[u]);
             }
         if(sgn(INF - d) == ) return false;
         for(int i = ; i <= n; ++i) if(use[i]) dis[i] += d;
         return true;
     }

     double min_cost_flow(int ss, int tt, int nn) {
         st = ss, ed = tt, n = nn;
         minCost = maxFlow = ;
         SPFA();
         while(true) {
             while(true) {
                 for(int i = ; i <= n; ++i) use[i] = ;
                 if(!add_flow(st, 0x7fffffff)) break;
             }
             if(!modify_label()) break;
         }
         return minCost;
     }

     void output(int n) {
         for(int i = ; i <= n; ++i) {
             for(int p = head[i]; p; p = next[p]) {
                 int &v = to[p];
                 if(!cap[p]) {printf("%d\n", v - n); break;}
             }
         }
     }
 } G;

 struct Point {
     int x, y;
     Point() {}
     Point(int x, int y): x(x), y(y) {}
     void read() {
         scanf("%d%d", &x, &y);
     }
     Point operator - (const Point &rhs) const {
         return Point(x - rhs.x, y - rhs.y);
     }
     double operator * (const Point &rhs) const {
         Point a(*this - rhs);
         return sqrt(a.x * a.x + a.y * a.y);
     }
 };

 Point p[MAXV];
 int n;

 int main() {
     bool flag = true;
     while(scanf("%d", &n) != EOF) {
         if(flag) flag = false; else puts("");
         for(int i = ; i <=  * n; ++i) p[i].read();
         G.init();
         for(int i = ; i <= n; ++i) {
             for(int j = n + ; j <=  * n; ++j) G.add_edge(i, j, , p[i] * p[j]);
         }
         int ss =  * n + , tt =  * n + ;
         for(int i = ; i <= n; ++i) G.add_edge(ss, i, , );
         for(int i = n + ; i <= n + n; ++i) G.add_edge(i, tt, , );
         G.min_cost_flow(ss, tt, tt);
         //printf("%d\n", x);
         G.output(n);
     }
 }

代码（94MS）（顺便用一下KM算法）：

 //囧，KM都写了顺便改一下吧
 #include <cstdio>
 #include <cctype>
 #include <cstring>
 #include <algorithm>
 #include <cmath>
 using namespace std;

 const int MAXN = ;
 const double INF = 1e100;
 const double EPS = 1e-;

 inline int sgn(double x) {
     return (x > EPS) - (x < -EPS);
 }

 int n;
 double mat[MAXN][MAXN], slack[MAXN], Lx[MAXN], Ly[MAXN];
 int left[MAXN];
 bool S[MAXN], T[MAXN];

 bool dfs(int i) {
     S[i] = true;
     for(int j = ; j <= n; ++j) if(!T[j]) {
         double t = Lx[i] + Ly[j] - mat[i][j];
         if(sgn(t) == ){
             T[j] = true;
             if(!left[j] || dfs(left[j])){
                 left[j] = i;
                 return true;
             }
         }
         else slack[j] = min(slack[j],t);
     }
     return false;
 }

 void update() {
     double a = INF;
     for(int i = ; i <= n; ++i) if(!T[i])
         a = min(slack[i],a);
     for(int i = ; i <= n; ++i){
         if(S[i]) Lx[i] -= a;
         if(T[i]) Ly[i] += a; else slack[i] -= a;
     }
 }

 void KM() {
     for(int i = ; i <= n; ++i) {
         Lx[i] = Ly[i] = left[i] = ;
         for(int j = ; j <= n; ++j) Lx[i] = max(Lx[i], mat[i][j]);
     }
     for(int i = ; i <= n; ++i) {
         for(int j = ; j <= n; ++j) slack[j] = INF;
         while(true){
             for(int j = ; j <= n; ++j) S[j] = T[j] = ;
             if(dfs(i)) break; else update();
         }
     }
     //int ans = 0;
     //for(int i = 1; i <=n; ++i) ans += Lx[i] + Ly[i];
     //return ans;
 }

 void output() {
     for(int i = ; i <= n; ++i) printf("%d\n", left[i]);
 }

 struct Point {
     int x, y;
     Point() {}
     Point(int x, int y): x(x), y(y) {}
     void read() {
         scanf("%d%d", &x, &y);
     }
     Point operator - (const Point &rhs) const {
         return Point(x - rhs.x, y - rhs.y);
     }
     double operator * (const Point &rhs) const {
         Point a(*this - rhs);
         return sqrt(a.x * a.x + a.y * a.y);
     }
 };

 Point p1[MAXN], p2[MAXN];

 int main() {
     bool flag = true;
     while(scanf("%d", &n) != EOF) {
         if(flag) flag = false; else puts("");
         for(int i = ; i <= n; ++i) p1[i].read();
         for(int i = ; i <= n; ++i) p2[i].read();
         for(int i = ; i <= n; ++i) {
             for(int j = ; j <= n; ++j) mat[j][i] = -(p1[i] * p2[j]);
         }
         KM();
         output();
     }
 }