[Luogu P3308] [BZOJ 3532] [SDOI2014]LIS

洛谷传送门

BZOJ传送门

题目描述

给定序列$A$，序列中的每一项$A_i$有删除代价$B_i$和附加属性$C_i$。请删除若干项，使得$A$的最长上升子序列长度减少至少$1$，且付出的代价之和最小，并输出方案。 如果有多种方案，请输出将删去项的附加属性排序之后，字典序最小的一种。

输入输出格式

输入格式：

输入包含多组数据。

输入的第一行包含整数$T$，表示数据组数。接下来$4\ast T$行描述每组数据。

每组数据的第一行包含一个整数$N$，表示$A$的项数。

接下来三行，每行$N$个整数$A_1...A_n$，$B_1...B_n$，$C_1...C_n$，满足$1\le Ai，Bi，Ci\le 10^9$，且$C_i$两两不同。

输出格式：

对每组数据，输出两行。第一行包含两个整数$S$，$M$，依次表示删去项的代价和与数量；接下来一行$M$个整数，表示删去项在$A$中的的位置，按升序输出。

输入输出样例

输入样例#1：

1
6
3 4 4 2 2 3
2 1 1 1 1 2
6 5 4 3 2 1

输出样例#1：

4 3
2 3 6

说明

【样例说明】

解释：删去$(A_2，A_3，A_6)，(A_1，A_6)，(A_2，A_3，A_4，A_5)$等都是合法的方案，但$(A_2，A_3，A_6)$对应的$C$值的字典序最小。

$1\le N\le 700T\le 5$

解题分析

首先没有最小字典序的限制是很好做的： 因为$LIS$本身可以将可行的转移看做一个$DAG$， 所以当$dp[i]=1$时$S$连$I_1$， 流量为$INF$； $I_1$连$I_2$， 流量为$B_i$， $I_2$连$dp[j]=dp[i]+1$且$j>i$且$A_i<A_j$的$J_1$点， 流量为$INF$， 这样拆成二分图直接跑最小割就好了。

然而现在有了$C_i$的限制， 我们需要贪心求出最小割上可能的边。 所以按$C_i$排序， 每次尝试删掉一条在最小割上的边。 这里有个小$trick$： 我们直接进行退流处理， 从$I_1$向$S$退流， $T$向$I_2$退流， 即可消除$I_1\to I_2$的影响，删掉这条边即可， 就不需要重新建图、 跑满流了。

复杂度是$O(能过)？？？$， 卡卡常就可以了…

代码如下：

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <algorithm>
#include <queue>
#define R register
#define IN inline
#define W while
#define gc getchar()
#define ll long long
#define INF 1e12
#define MX 1505
template <class C> IN C min(C a, C b) {return a < b ? a : b;}
template <class C> IN C max(C a, C b) {return a > b ? a : b;}
template <class C>
IN void in(C &x)
{
	x = 0; R char c = gc;
	for (; !isdigit(c); c = gc);
	for (;  isdigit(c); c = gc)
	x = (x << 1) + (x << 3) + c - 48;
}
int n, S, T, cnt, tot;
ll flow;
int head[MX], a[MX], b[MX], layer[MX], dp[MX], cpy[MX], ans[MX];
struct Edge {int to; ll fl; int nex;} edge[200500];
struct INFO {int id, c;} dat[MX];
IN bool operator < (const INFO &x, const INFO &y) {return x.c < y.c;}
IN void add(R int from, R int to, R ll fl)
{
	edge[++cnt] = {to, fl, head[from]}, head[from] = cnt;
	edge[++cnt] = {from, 0, head[to]}, head[to] = cnt;
}
IN int DP()
{
	int ret = 0;
	for (R int i = 1; i <= n; ++i)
	{
		dp[i] = 1;
		for (R int j = 1; j < i; ++j)
		if (a[j] < a[i]) dp[i] = max(dp[i], dp[j] + 1);
		ret = max(ret, dp[i]);
	}
	return ret;
}
namespace Dinic
{
	IN bool BFS(R int st, R int ed)
	{
		std::queue <int> q;
		std::memset(layer, 0, sizeof(layer));
		layer[st] = 1, q.push(st); R int now;
		W (!q.empty())
		{
			now = q.front(); q.pop();
			for (R int i = head[now]; ~i; i = edge[i].nex)
			{
				if ((!layer[edge[i].to]) && edge[i].fl)
				layer[edge[i].to] = layer[now] + 1, q.push(edge[i].to);
				if (now == ed) return true;//注意这里： BFS到即可返回， 因为后面的点深度一定大于等于终点了， 不可能再转移过去。 因为我们删的两个点之间是有直接连边的， 实际这样写可以快1倍。
			}
		}
		return layer[ed];
	}
	ll DFS(R int now, R ll avai, R int ed)
	{
		if (now == ed) return avai;
		R ll lef = avai, buf;
		for (int &i = head[now]; ~i; i = edge[i].nex)
		{
			if (edge[i].fl && layer[edge[i].to] == layer[now] + 1)
			{
				buf = DFS(edge[i].to, min(lef, edge[i].fl), ed);
				lef -= buf, edge[i].fl -= buf, edge[i ^ 1].fl += buf;
				if (!lef) return avai;
			}
		}
		if (lef == avai) layer[now] = -1;
		return avai - lef;
	}
	ll init(R int st, R int ed)
	{
		ll ret = 0;
		W (BFS(st, ed)) ret += DFS(st, INF, ed), std::memcpy(head, cpy, sizeof(int) * (T + 1));
		return ret;
	}
}
int main(void)
{
	int t, fmx, now;
	in(t);
	W (t--)
	{
		in(n); S = 2 * n + 1, T = 2 * n + 2; tot = 0;
		std::memset(head, cnt = -1, sizeof(head));
		for (R int i = 1; i <= n; ++i) in(a[i]);
		for (R int i = 1; i <= n; ++i) in(b[i]);
		for (R int i = 1; i <= n; ++i) in(dat[i].c), dat[i].id = i;
		std::sort(dat + 1, dat + 1 + n);
		fmx = DP();
		for (R int i = 1; i <= n; ++i) add(i, i + n, b[i]);
		for (R int i = 1; i <= n; ++i)
		{
			if (dp[i] == 1) add(S, i, INF);
			else if (dp[i] == fmx) add(i + n, T, INF);
			for (R int j = 1; j < i; ++j)
			{
				if (a[j] < a[i] && dp[j] == dp[i] - 1)
				add(j + n, i, INF);
			}
		}
		std::memcpy(cpy, head, sizeof(int) * (T + 1));
		flow = Dinic::init(S, T);
		for (R int i = 1; i <= n; ++i)
		{
			now = dat[i].id;
			if (Dinic::BFS(now, now + n)) continue;
			ans[++tot] = now;
			edge[(now - 1) * 2].fl = edge[(now - 1) * 2 + 1].fl = 0;
			Dinic::init(now, S), Dinic::init(T, now + n);
		}
		std::sort(ans + 1, ans + 1 + tot);
		printf("%lld %d\n", flow, tot);
		for (R int i = 1; i <= tot; ++i) printf("%d%c", ans[i], i == tot ? '\n' : ' ');
	}
}