POJ 3565 最小费用流

题意

传送门 POJ 3565 Ants

题解

三角形两边之和大于第三边，那么相交两条路线长度小于将其替换为不相交路线的长度。则问题转化为使各线段长度之和最小。看做蚂蚁以路径距离为权值的指向树的指派问题，则可以使用最小费用流求解。总时间复杂度 $O(N^3\log N)$。

需要注意的是，路径权值不能使用其平方简单代替，因为最小化路径距离和不等同于最小化路径距离的平方和。

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
typedef pair<double, int> P;
const double eps = 1e-8;
const int inf = 0x3f3f3f3f;
const int maxn = 105, maxv = 2 * maxn + 2, maxe = 2 * (maxn * maxn + maxv);
struct node
{
    int x, y;
} ant[maxn], tree[maxn];
int N, res[maxn];
int tot, head[maxv], to[maxe], cap[maxe], nxt[maxe];
double cost[maxe], h[maxv], ds[maxv];
int rst[maxv], pre[maxv];
bool vs[maxv];

inline void add(int x, int y, int c, double z)
{
    to[++tot] = y, cap[tot] = c, cost[tot] = z, nxt[tot] = head[x], head[x] = tot;
    to[++tot] = x, cap[tot] = 0, cost[tot] = -z, nxt[tot] = head[y], head[y] = tot;
}

bool dijkstra(int s, int t)
{
    fill(ds + s, ds + t + 1, inf);
    memset(vs, 0, sizeof(vs));
    ds[s] = 0, rst[s] = inf;
    priority_queue<P, vector<P>, greater<P>> q;
    q.push(P(0, s));
    while (q.size())
    {
        int x = q.top().second;
        q.pop();
        if (vs[x])
            continue;
        vs[x] = 1;
        for (int i = head[x]; i; i = nxt[i])
        {
            int y = to[i], c = cap[i];
            double z = cost[i];
            if (c && ds[y] > eps + ds[x] + z + h[x] - h[y])
            {
                ds[y] = ds[x] + z + h[x] - h[y], rst[y] = min(rst[x], c), pre[y] = i;
                q.push(P(ds[y], y));
            }
        }
    }
    return ds[t] != inf;
}

void min_cost_flow(int s, int t)
{
    fill(h + s, h + t + 1, 0);
    while (dijkstra(s, t))
    {
        for (int i = s; i <= t; ++i)
            h[i] += ds[i];
        int x = t, f = rst[x];
        while (x != s)
        {
            int i = pre[x];
            cap[i] -= f, cap[i ^ 1] += f, x = to[i ^ 1];
        }
    }
}

int main()
{
    tot = 1;
    scanf("%d", &N);
    for (int i = 1; i <= N; ++i)
        scanf("%d%d", &ant[i].x, &ant[i].y);
    for (int i = 1; i <= N; ++i)
        scanf("%d%d", &tree[i].x, &tree[i].y);
    int s = 0, t = N * 2 + 1;
    for (int i = 1; i <= N; ++i)
        for (int j = 1; j <= N; ++j)
        {
            int dx = ant[i].x - tree[j].x, dy = ant[i].y - tree[j].y;
            add(i, N + j, 1, sqrt((double)dx * dx + dy * dy));
        }
    for (int i = 1; i <= N; ++i)
        add(s, i, 1, 0);
    for (int i = 1; i <= N; ++i)
        add(N + i, t, 1, 0);
    min_cost_flow(s, t);
    for (int x = 1; x <= N; ++x)
        for (int i = head[x]; i; i = nxt[i])
            if (!cap[i])
            {
                res[x] = to[i] - N;
                break;
            }
    for (int i = 1; i <= N; ++i)
        printf("%d\n", res[i]);
    return 0;
}