POJ3680_Intervals_离散化&&最小费用流

最新推荐文章于 2021-10-29 16:33:45 发布

原创最新推荐文章于 2021-10-29 16:33:45 发布 · 290 阅读

0 ·

CC 4.0 BY-SA版权

网络流专栏收录该内容

13 篇文章

订阅专栏

本文介绍了一个涉及区间覆盖的优化问题，目标是在满足每个点被不超过K个区间覆盖的前提下，选择区间以最大化总权重。文章提供了详细的算法实现，包括离散化处理、最小费用流等关键步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意

给定 N 个带权的开区间。i 号区间覆盖(ai, bi)，权重为 wi。现在要从中选取一些区间，要求人一点都不被超过 K 个区间覆盖，目标是最大化总的权重。

思路

讲真这个题并没有完全参透，暂且把《挑战程序设计竞赛》247页的分析贴在这吧。
这里写图片描述
书中的分析没有提及离散化，实际上这一点非常重要。

题目链接

http://poj.org/problem?id=3680

AC代码

#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
#include<vector>
#include<algorithm>

using namespace std;

typedef pair<int, int> P;
struct edge
{
    int to, cap, cost, rev;
    edge(int a, int b, int c, int d)
    :to(a), cap(b), cost(c), rev(d){}
};

const int maxn = 210;
const int maxv = maxn * 2;
const int  inf = 0x3f3f3f3f;

int cas;
int n, k;
int A[maxn], B[maxn], C[maxn];                                      //保存区间信息
vector<int> X;                                                      //用于离散化

//最小费用流零件
vector<edge> G[maxv];
int dis0[maxv], dis1[maxv];
int pv[maxv], pe[maxv];

//向图中添加边
void add(int from, int to, int cap, int cost)
{
    G[from].push_back(edge(to, cap, cost, G[to].size()));
    G[to].push_back(edge(from, 0, -cost, G[from].size() - 1));
}

//迪杰斯特拉算法求最短路
void dijkstra(int s)
{
    memset(dis1, inf, sizeof dis1);
    dis1[s] = 0;
    priority_queue<P, vector<P>, greater<P> > qu;
    qu.push(P(0, s));

    while(qu.size())
    {
        P p = qu.top();qu.pop();
        int v = p.second;
        if(dis1[v] < p.first) continue;

        for(int i= 0; i< G[v].size(); i++)
        {
            edge e = G[v][i];
            if(e.cap > 0 && dis1[e.to] > dis1[v] + e.cost + dis0[v] - dis0[e.to])
            {
                dis1[e.to] = dis1[v] + e.cost + dis0[v] - dis0[e.to];
                pv[e.to] = v;
                pe[e.to] = i;
                qu.push(P(dis1[e.to], e.to));
            }
        }
    }
}

//最小费用流算法
int min_cost_flow(int s, int t, int f)
{
    int res = 0;
    memset(dis0, 0, sizeof dis0);

    while(f > 0)
    {
        dijkstra(s);

        if(dis1[t] == inf) return -1;

        for(int i= s; i<= t; i++)
            dis0[i] += dis1[i];

        int d = f;
        for(int v= t; v!= s; v= pv[v])
            d = min(d, G[pv[v]][pe[v]].cap);

        f -= d;
        res += d * dis0[t];

        for(int v= t; v!= s; v= pv[v])
        {
            edge &e = G[pv[v]][pe[v]];
            e.cap -= d;
            G[e.to][e.rev].cap += d;
        }
    }

    return res;
}

int main()
{
    cin >> cas;
    while(cas--)
    {
        X.clear();
        for(int i= 0; i< maxv; i++)
            G[i].clear();

        cin >> n >> k;

        for(int i= 0; i< n; i++)
        {
            cin >> A[i] >> B[i] >> C[i];
            X.push_back(A[i]);
            X.push_back(B[i]);
        }

        //离散化
        sort(X.begin(), X.end());
        X.erase(unique(X.begin(), X.end()), X.end());

        int s = 0, t = X.size() - 1;

        for(int i= 0; i< t; i++)
            add(i, i+1, inf, 0);

        for(int i= 0; i< n; i++)
        {
            int a = lower_bound(X.begin(), X.end(), A[i]) - X.begin();
            int b = lower_bound(X.begin(), X.end(), B[i]) - X.begin();
            add(a, b, 1, -C[i]);
        }

        cout << -min_cost_flow(s, t, k) << endl;
    }

    return 0;
}