【HDOJ6611】K Subsequence（费用流）

题意：给定一个长为n的正整数序列，要求从中取出至多k个不下降序列，使得它们的和最大，求这个和

n<=2e3，k<=10，a[i]<=1e5

思路：极其考验模板，反正我的spfa和zkw都挂了，就拿这题std做dijkstra费用流的板子了

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef pair<int,int> PII;
typedef pair<ll,ll> Pll;
typedef vector<int> VI;
typedef vector<PII> VII;
typedef pair<ll,ll>P;
#define N  10000
#define M  2100000
#define fi first
#define se second
#define MP make_pair
#define pb push_back
#define pi acos(-1)
#define mem(a,b) memset(a,b,sizeof(a))
#define rep(i,a,b) for(int i=(int)a;i<=(int)b;i++)
#define per(i,a,b) for(int i=(int)a;i>=(int)b;i--)
#define lowbit(x) x&(-x)
#define Rand (rand()*(1<<16)+rand())
#define id(x) ((x)<=B?(x):m-n/(x)+1)
#define ls p<<1
#define rs p<<1|1

const int MOD=998244353,inv2=(MOD+1)/2;
      double eps=1e-4;
      int INF=0x7fffffff;;
      ll inf=5e13;
      int dx[4]={-1,1,0,0};
      int dy[4]={0,0,-1,1};

struct edge
{
    int to,cap,cost,rev;
    edge(){}
    edge(int a,int b,int c,int d):
    to(a),cap(b),cost(c),rev(d){}
};

int read()
{
   int v=0,f=1;
   char c=getchar();
   while(c<48||57<c) {if(c=='-') f=-1; c=getchar();}
   while(48<=c&&c<=57) v=(v<<3)+v+v+c-48,c=getchar();
   return v*f;
}

struct MCMF
{
    int V,h[N],dis[N],preV[N],preE[N];
    vector<edge> g[N];

    void init(int n)
    {
        V=n;
        rep(i,0,V) g[i].clear();
    }

    void add(int u,int v,int cap,int cost)
    {
        g[u].pb(edge(v,cap,cost,g[v].size()));
        g[v].pb(edge(u,0,-cost,g[u].size()-1));
    }

    int minc_mf(int S,int T,int f,int &flow)
    {
        int res=0;
        fill(h,h+1+V,0);
        while(f)
        {
            priority_queue <PII,vector<PII>, greater<PII> > q;
            fill(dis,dis+1+V,INF);
            dis[S]=0;
            q.push(MP(0,S));
            while(!q.empty())
            {
                PII now=q.top(); q.pop();
                int u=now.se;
                if(dis[u]<now.fi) continue;
                for(int i=0;i<g[u].size();i++)
                {
                    edge e=g[u][i];
                    int v=e.to;
                    if(e.cap>0&&dis[v]>dis[u]+e.cost+h[u]-h[v])
                    {
                        dis[v]=dis[u]+e.cost+h[u]-h[v];
                        preV[v]=u;
                        preE[v]=i;
                        q.push(MP(dis[v],v));
                    }

                }
            }
            if(dis[T]==INF) break;
            rep(i,0,V) h[i]+=dis[i];
            int t=f,k=T;
            while(k!=S)
            {
                int e=preE[k];
                t=min(t,g[preV[k]][preE[k]].cap);
                k=preV[k];
            }
            f-=t; flow+=t; res+=t*h[T];
            k=T;
            while(k!=S)
            {
                edge &e=g[preV[k]][preE[k]];
                e.cap-=t;
                g[k][e.rev].cap+=t;
                k=preV[k];
            }
        }
        return res;
    }
}mcmf;

int num[N][2],a[N],S,T,s,flow;

int main()
{
    int cas=read();
    s=0;
    while(cas--)
    {
        int n=read(),k=read();
        rep(i,1,n) a[i]=read();
        s=0;
        rep(i,1,n)
        {
            num[i][0]=++s;
            num[i][1]=++s;
        }
        S=++s; s++; T=++s;
        mcmf.init(s);
        mcmf.add(S,S+1,k,0);
        rep(i,1,n) mcmf.add(S+1,num[i][0],1,0);
        rep(i,1,n) mcmf.add(num[i][0],num[i][1],1,-a[i]);
        rep(i,1,n)
         rep(j,i+1,n)
          if(a[j]>=a[i]) mcmf.add(num[i][1],num[j][0],1,0);
        rep(i,1,n) mcmf.add(num[i][1],T,1,0);
        flow=0;
        int ans=-mcmf.minc_mf(S,T,INF,flow);
        printf("%d
",ans);
    }
    return 0;
15nb0 }

 无敌zyd的优化建图，思路是每个i都只与后面有可能构成最优解的j连边，最坏情况下没有任何改进，但好像因为a[i]是随机数据跑的飞快

#pragma GCC optimize("O3")
#pragma G++ optimize("O3")
#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define rep(i,l,r) for(int i=l;i<=r;++i)
#define per(i,l,r) for(int i=l;i>=r;--i)
using namespace std;


const int N = 10000, M=100000;
const int INF = 1e9;
int n,m;
int a[M];

struct EG {
    int a, b, c, d, e;
} eg[M];
int head[N], en, S, T, SS;
int flow, cost;
int dis[N], pre[N], rem[N];
bool inq[N];
void insert(int u, int v, int w, int z) {
    eg[++en] = (EG) {v, head[u], w, z, u}; head[u] = en;
    eg[++en] = (EG) {u, head[v], 0, -z, v}; head[v] = en;
}
void Clear() {
    memset(head, 0, sizeof head);
    en = 1;
}
bool Spfa() {
    for (int i = 1; i <= SS; i++) dis[i] = INF, inq[i] = 0;
    dis[S] = 0;
    inq[S] = 1;
    queue<int> Q; Q.push(S);
    pre[S] = 0, rem[S] = INF;
    while (!Q.empty()) {
        int u = Q.front(); Q.pop();
        inq[u] = 0;
        for (int e = head[u]; e; e = eg[e].b) {
            int v = eg[e].a;
            if (eg[e].c > 0 && dis[u] + eg[e].d < dis[v]) {
                dis[v] = dis[u] + eg[e].d;
                pre[v] = e;
                rem[v] = min(rem[u], eg[e].c);
                if (!inq[v]) {
                    inq[v] = 1;
                    Q.push(v);
                }
            }
        }
    }
    if (dis[T] == INF) return 0;
    flow += rem[T];
    cost += dis[T] * rem[T];
    int u = T;
    while (u != S) {
        eg[pre[u]].c -= rem[T];
        eg[pre[u] ^ 1].c += rem[T];
        u = eg[pre[u]].e;
    }
    return 1;
}
void MinCost() {
    flow = cost = 0;
    while (Spfa());
}

int main() {
    //freopen("a.txt","r",stdin);

    int test_;
    cin>>test_;
    while (test_--) {
        scanf("%d%d",&n,&m);
        rep(i,1,n) scanf("%d",a+i);


        Clear();
        S = n * 2 + 10, T = S + 1, SS = T + 1;
        for (int i = 1; i <= n; i++)
        {
            insert(i, i + n, 1, -a[i]);
            insert(i, i + n, m, 0);
            int mx = INF;
            for (int j = i + 1; j <= n; j++)
            {
                if (a[j] < mx && a[j] >= a[i])
                {
                    insert(i + n, j, INF, 0);
                    mx = a[j];
                }
            }
        }
        insert(S, SS, m, 0);
        for (int i = 1; i <= n; i++)
        {
            insert(SS, i, 1, 0);
            insert(i + n, T, 1, 0);
        }
        MinCost();
        printf("%d
", -cost);
    }
}