2019HDU多校第三场 K subsequence——最小费用最大流

题意

给定一个 $n$ 个整数的数列，从中至多选取 $k$ 个上升子序列（一个元素最多被选一次），使得选取的元素和最大。

分析

考虑这个问题和经典网络流问题“最长不下降子序列”相似，我们考虑对这个建图并用网络流解决。因为求得费用和，则使用费用流做法。

具体建图见代码，主要考虑拆点和建立超级源点和超级汇点。

（然后SPFA版的会超时，换成Dijkstra版的

#include<bits/stdc++.h>
using namespace std;
#define il inline

typedef long long ll;
const int INF = 0x3f3f3f3f;
const int maxn =  + ;
int n, k, a[maxn];

struct edge {
    int to, capacity, cost, rev;
    edge() {}
    edge(int to, int _capacity, int _cost, int _rev) :to(to), capacity(_capacity), cost(_cost), rev(_rev) {}
};
struct Min_Cost_Max_Flow {
    int V, H[maxn + ], dis[maxn + ], PreV[maxn + ], PreE[maxn + ];
    vector<edge> G[maxn + ];
    //调用前初始化
    void Init(int n) {
        V = n;
        for (int i = ; i <= V; ++i)G[i].clear();
    }
    //加边
    void Add_Edge(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, , -cost, G[from].size() - ));
    }
    //flow是自己传进去的变量，就是最后的最大流，返回的是最小费用
    int Min_cost_max_flow(int s, int t, int f, int& flow) {
        int res = ; fill(H, H +  + V, );
        while (f) {
            priority_queue <pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>> > q;
            fill(dis, dis +  + V, INF);
            dis[s] = ; q.push(pair<int, int>(, s));
            while (!q.empty()) {
                pair<int, int> now = q.top(); q.pop();
                int v = now.second;
                if (dis[v] < now.first)continue;
                for (int i = ; i < G[v].size(); ++i) {
                    edge& e = G[v][i];
                    if (e.capacity >  && dis[e.to] > dis[v] + e.cost + H[v] - H[e.to]) {
                        dis[e.to] = dis[v] + e.cost + H[v] - H[e.to];
                        PreV[e.to] = v;
                        PreE[e.to] = i;
                        q.push(pair<int, int>(dis[e.to], e.to));
                    }
                }
            }
            if (dis[t] == INF)break;
            for (int i = ; i <= V; ++i)H[i] += dis[i];
            int d = f;
            for (int v = t; v != s; v = PreV[v])d = min(d, G[PreV[v]][PreE[v]].capacity);
            f -= d; flow += d; res += d*H[t];
            for (int v = t; v != s; v = PreV[v]) {
                edge& e = G[PreV[v]][PreE[v]];
                e.capacity -= d;
                G[v][e.rev].capacity += d;
            }
        }
        return res;
    }
    int Max_cost_max_flow(int s, int t, int f, int& flow) {
        int res = ;
        fill(H, H +  + V, );
        while (f) {
            priority_queue <pair<int, int>> q;
            fill(dis, dis +  + V, -INF);
            dis[s] = ;
            q.push(pair<int, int>(, s));
            while (!q.empty()) {
                pair<int, int> now = q.top(); q.pop();
                int v = now.second;
                if (dis[v] > now.first)continue;
                for (int i = ; i < G[v].size(); ++i) {
                    edge& e = G[v][i];
                    if (e.capacity >  && dis[e.to] < dis[v] + e.cost + H[v] - H[e.to]) {
                        dis[e.to] = dis[v] + e.cost + H[v] - H[e.to];
                        PreV[e.to] = v;
                        PreE[e.to] = i;
                        q.push(pair<int, int>(dis[e.to], e.to));
                    }
                }
            }
            if (dis[t] == -INF)break;
            for (int i = ; i <= V; ++i)H[i] += dis[i];
            int d = f;
            for (int v = t; v != s; v = PreV[v])d = min(d, G[PreV[v]][PreE[v]].capacity);
            f -= d; flow += d;
            res += d*H[t];
            for (int v = t; v != s; v = PreV[v]) {
                edge& e = G[PreV[v]][PreE[v]];
                e.capacity -= d;
                G[v][e.rev].capacity += d;
            }
        }
        return res;
    }
}mcmf;

void solve()
{
    mcmf.Init(*n+);
    for(int i = ;i <= n;i++)
    {
        mcmf.Add_Edge(i, i+n, , -a[i]);
        for(int j = i+;j <= n;j++)
        {
            if(a[j] >= a[i])
            {
                mcmf.Add_Edge(i+n, j, , );  //右边每一个大于的都要连边
                //break;
            }
        }
    }
    mcmf.Add_Edge(*n+, *n+, k, );
    for(int i = ;i <= n;i++)  mcmf.Add_Edge(*n+, i, , );  //建立超级源点2n+1
    for(int i = ;i <= n;i++)  mcmf.Add_Edge(i+n, *n+, , );     //建立超级汇点2n+2
    int flow = ;
    int ans = mcmf.Min_cost_max_flow(*n+, *n+, INF, flow);
    printf("%d\n", -ans);
}

int main()
{
//    freopen("multi.in", "r", stdin);
//    freopen("out.txt", "w", stdout);
    int T;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &n, &k);
        for(int i = ;i <= n;i++)  scanf("%d", &a[i]);
        solve();
    }
}