例题
Comet OJ Contest #6B 双倍快乐:https://www.cometoj.com/contest/48/problem/B?problem_id=2278
HDU 5406 CRB and Apple:http://acm.hdu.edu.cn/showproblem.php?pid=5406
题意:
Comet: 求序列 a 中的两个不相交的不下降子序列使得他们的元素和的和最大,子序列可以为空。
HDU : 一棵树有若干苹果,苹果有个甜度、高度,要求选两个的吃苹果序列的甜度与高度均单调不减。求吃最大的苹果数。
(说人话:给定n个苹果,按照高度排序后,对甜度求两个最长的不相交的LIS。)
数据:
Comet :2≤n≤500,1≤a≤1e5
HDU :1 ≤ T ≤ 48,1≤n≤1000,1≤a≤1e9
注 1:序列不下降的定义是不存在 l<r 且 a_l>a_r
注 2:两个子序列不相交的定义是:不存在元素x既在第一个子序列中也在第二个子序列中
思路:
方法一:(通用方法)
最直观的方法:费用流。
1. 两个序列的长度和(总序列和)最大,视作从超级源点出发的流量为2的费用流,建负权边。
2. 每个物品只能取一次,则拆点为 入点 和 出点,中间建容量为1,费用为-1(或者物品值)的边。
3. 源点向每个入点建容量为1,费用为0的边,表示每个点都可作为序列的首项;
每个出点向汇点建容量为1,费用为0的边,表示每个点都可作为序列的末项。
4. 从权值较小的物品向权值较大的物品建边,容量为1,费用为0。
5. 跑出费用流后,对 总最小费用 取反 就是答案。(HDU里面用spfa需要栈优化,队列会TLE)
方法二:(针对Comet数据小一点)
二维的dp,O(n^3)的复杂度。(后面还有优化)
1. dp[i][j]表示 第一个子序列末尾值为i 和 第二个子序列末尾值为j 时的最大长度(序列和)。
由于数据规模问题(HDU),需要对序列离散化。
2. 可以考虑对第k个元素来说,可以放到第一个串后面更新dp[k][j],也可以放到第二个串后面更新dp[i][k]。
3. 那么转移方程:(+1是求长度,+a[k]是求和)
dp[k][j] = max(dp[k][j], dp[i][j] + a[k]) {a[k]>=a[i]}
dp[i][k] = max(dp[i][k], dp[i][j] + a[k]) {a[k]>=a[j]}
4.整体就是个O(n^3)的dp了
方法三:(HDU数据大一点)
二维dp用树状数组优化,O(n^2logn)的复杂度。(线段树之类的也行,这个问题树状数组写起来很简洁--学到了)
1. 还是dp[i][j]表示 第一个子序列末尾为i 和 第二个子序列末尾为j 时的最大长度(序列和)。
(离散化后)
2. 其中某个dp[i][j]的值是从小于值j的最大值转移过来的:单点修改,前缀最大值查询。
即 dp[i][j] = max(dp[i][k])+a[k] {k <= j} (+1是求长度,+a[i]是求和)
3. 由于两个序列是等价的,因此dp[i][j]=dp[j][i],在更新时候只需要按照行更新,即只需要更新i行和j行就行。
4. 注意到dp[i]的值是单调不减的。每次修改,都可以用树状数组向上传递更新。(如果dp[i]的值会变小,就无法向上传递更新了。)
查询 满足k <= i 刚好是前缀查询。
代码:(HDU 5406的方法三)
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL N = 2005;
const LL M = 21;
const LL INF = 0x3f3f3f3f;
const double inf = 2e9+7;
const double Pi = acos(-1);
const LL MOD = 998244353;
const double eps = 1e-7;
struct p{
int h, d;
p(){}
p(int h, int d):h(h), d(d){}
bool operator <(const p& x) const{
return h != x.h? h > x.h : d < x.d;
}
};
p pp[N];
int s[N];
int dp[N][N], tmp[N];
void add(int* a, int x, int d){
for(int i = x; i < 1005; i += i&-i)
a[i] = max(a[i], d);
}
int sum(int* a, int x){
int ret = 0;
for(int i = x; i; i -= i&-i)
ret = max(ret, a[i]);
return ret;
}
int main(){
int t, n;
scanf("%d", &t);
while(t--)
{
scanf("%d", &n);
for(int i = 0; i < n; i++)
{
scanf("%d%d", &pp[i].h, &pp[i].d);
s[i] = pp[i].d;
}
sort(pp, pp+n);
sort(s, s+n);
for(int i = 0; i < n; i++)
pp[i].d = lower_bound(s, s+n, pp[i].d)-s+1;
memset(dp, 0, sizeof(dp));
int ans = 0;
for(int i = 0; i < n; i++)
{
int v = pp[i].d;
for(int j = 1; j <= n; j++)
{
tmp[j] = sum(dp[j], v)+1; // Comet:如果是最大和就把 +1 改成 +s[v-1]
ans = max(ans, tmp[j]);
}
for(int j = 1; j <= n; j++)
{
add(dp[j], v, tmp[j]);
add(dp[v], j, tmp[j]);
}
}
printf("%d\n", ans);
}
return 0;
}
/*
1
5
1 1
2 3
3 2
4 3
5 1
Ans = 4
*/