求两个不相交的最长不降子序列

例题

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

*/