HDU 6611 K Subsequence (最小费用最大流 相对于SPFA快一些)

传送门

题意：

给你一组数让你找前k组递增序列的和。

只需要建好一个图跑最小费用最大流即可。

关于图：

可以将一个点，给他多弄一个出点，所以相对的该点就为该点的入点，其中该点与该点的出点路径费用为-a[i]，流量为1，因为我们是跑的最小费用，如果你弄成正数，则永远不会跑该路径；

然后定义一个小源点ss 将所有的入点与ss相连，所有的出点与汇点 t 相连；

然后将满足递增的点相互连接，连接方式为权值小的点的出点与权值大的点的入点相连。

此时该图就建好了。

可是 ，我们这样的话只能得到一组最小费用，这样的话k组求不出来。

所以我们的图还是不完整的。因此我们在小源点ss前面再弄上一个大源点 s ，让大源点s与小源点ss之间流量为 k ，此时我们从大源点s 到汇点 t 跑一次最小费用最大流即可。

#include <bits/stdc++.h>
//#define int long long
using namespace std;
typedef pair<int, int> pii;
const int maxn = 4000;
const int inf = 0x7fffffff;
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 + 5], dis[maxn + 5], PreV[maxn + 5], PreE[maxn + 5];
	vector<edge> G[maxn + 5];
	void Init(int n) {
		V = n;
		for (int i = 0; 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, 0, -cost, G[from].size() - 1));
	}
	int Min_cost_max_flow(int s, int t, int f, int& flow) {
		int res = 0; fill(H, H + 1 + V, 0);
		while (f) {
			priority_queue <pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > > q;
			fill(dis, dis + 1 + V, inf);
			dis[s] = 0; q.push(pair<int, int>(0, 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 = 0; i < G[v].size(); ++i) {
					edge& e = G[v][i];
					if (e.capacity > 0 && 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 = 0; 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 = 0;
		fill(H, H + 1 + V, 0);
		while (f) {
			priority_queue <pair<int, int> > q;
			fill(dis, dis + 1 + V, -inf);
			dis[s] = 0;
			q.push(pair<int, int>(0, 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 = 0; i < G[v].size(); ++i) {
					edge& e = G[v][i];
					if (e.capacity > 0 && 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 = 0; 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 n,k,a[3000],S,T,flow;
Min_Cost_Max_Flow mfmc;
signed main()
{
	//freopen("multi.in","r",stdin);
	//freopen("out","w",stdout);
	int tT;
	scanf("%d",&tT);
	while(tT--)
	{
		
		scanf("%d %d",&n,&k);
		S=n*2+1;
		int ss=S+1;
		T=ss+1;
		mfmc.Init(T);
		mfmc.Add_Edge(S,ss,k,0);
		for(int i=0;i<n;i++)
		{
			scanf("%d",&a[i]);
			mfmc.Add_Edge(ss,i,1,0);
			mfmc.Add_Edge(i,i+n,1,-a[i]);
			mfmc.Add_Edge(i+n,T,1,0);
		}
		for(int i=0;i<n;i++)
		{
			for(int j=i+1;j<n;j++)
			{
				if(a[i]<=a[j])
				{
					mfmc.Add_Edge(i+n,j,1,0);
				}
			}
		}
		printf("%d\n",-mfmc.Min_cost_max_flow(S,T,inf,flow));
	}
	return 0;
}