LIS最长上升子序列

题意：有一个长为n的数列，求出这个序列中最长的上升子序列长度（不连续，不能等于）。

解法1：简单dp（n²）
思路：

状态设计：F [ i ] 代表以 A [ i ] 结尾的 LIS 的长度

状态转移：F [ i ] = max { F [ j ] + 1 ，F [ i ] } (1 <= j <  i，A[ j ] < A[ i ])

边界处理：F [ i ] = 1 (1 <= i <= n)

const int maxn = 103, INF = 0x7f7f7f7f;
int a[maxn], f[maxn];
int n,ans = -INF;
int main()
{
    scanf("%d", &n);
    for(int i=1; i<=n; i++) 
    {
        scanf("%d", &a[i]);
        f[i] = 1;
    }
    for(int i=1; i<=n; i++)
        for(int j=1; j<i; j++)
            if(a[j] < a[i])
                f[i] = max(f[i], f[j]+1);
    for(int i=1; i<=n; i++) 
        ans = max(ans, f[i]);
    printf("%d
", ans);
    return 0;
}

---

解法2：贪心优化（nlogn）

思路：新建一个 low 数组，low [ i ]表示长度为i的LIS结尾元素的最小值。

注意这里的最小值需要更新，而且因为长度为3的LIS结尾元素最小值（low[3]）必定大于长度为2的LIS结尾元素最小值（low[4]），所以这个序列就是递增的。

当面对一个数字arr[i]，若其大于low[i]数组最后一个值，则增加数组长度并且将其填到最后面。否则更新low[i]，更新的时候我们由于单调递增可以二分找位置。

/* ********************************************** */
    int k = 1;
    dp[k] = arr[1];
    for(int i = 2; i <= n; i++){
        if(dp[k] < arr[i]) dp[++k] = arr[i]; //如果比最后一个元素大，那么就添加再最后末尾处
        else *(lower_bound(dp + 1, dp + 1 + k, arr[i])) = arr[i]; //如果比最后一个元素小，那么就替换该序列第一个比他大的数；
    }
 /* ********************************************** */

---

POJ3616
题意：有M个时间段，给你每个时间段的开始和结束时间，还有这个时间段的产量，每个时间段不能重合，且这个时间段用完之后在一定时间内不能再生产，问你怎样选择可以使得最后产量最大。

解法：带权的LIS，长度相当于时间段的产量，时间段相当于个数，dp跑即可

struct COW {
    int l, r, len;
    bool operator<(COW &rhs) const {
        return l == rhs.l ? r < rhs.r : l < rhs.l;
    }
} cow[MAXN];
int N, M, R, ans = -1;
int f[MAXN];
int main() {
    // freopen("input.txt", "r", stdin);
    scanf("%d %d %d", &N, &M, &R);
    rep(i, 1, M) scanf("%d %d %d", &cow[i].l, &cow[i].r, &cow[i].len);
    sort(cow + 1, cow + 1 + M);
    rep(i, 1, M) {
        f[i] = cow[i].len;
        rep(j, 1, i - 1) if (cow[j].r + R <= cow[i].l) {
            f[i] = max(f[i], f[j] + cow[i].len);
        }
    }
    rep(i, 1, M) ans = max(ans, f[i]);
    printf("%d", ans);
    return 0;
}

---

POJ1065

题意：有N个木棒，起点和终点分别为 stick[i].l 和 stick[i].r ，要将这些木棒排成不下降的序列，问最少能排成几个这样的序列。

如：( 9 , 4 ) , ( 2 , 5 ) , ( 1 , 2 ) , ( 5 , 3 ) , 和 ( 4 , 1 ) 这5根木棒，那么最少的方案是：( 4 , 1 ) , ( 5 , 3 ) , ( 9 , 4 ) , ( 1 , 2 ) , ( 2 , 5 )。 共需要两根

解法：通过鸽巢原理将题目转换为LIS问题。

为了便于理解，首先我们将所有的木棒按照起点的降序排列，我们设此基础下终点 r 的 LIS 长度为 L，我们先将LIS中包含的木棒都挖出来，形成“空穴”。

接下来假设问题的答案是将这一堆木棒分成 x 份，假如 x < L，那么根据鸽巢原理一定存在某堆木棒会有大于等于两个空穴。此时任选LIS中的两个元素放入，他们满足 stick[i].r <= stick[i+1].r 为升序，但是当前的木棒是按照起点降序的排列，此时出现了矛盾，所以木棒分成的分数一定等于木棒终点 r 的 LIS 长度。

代码里面反着写的，意思一样。

int T, N;
struct STICK {
    int l, r;
    bool operator<(const STICK& rhs) const {
        return l == rhs.l ? r <= rhs.r : l < rhs.l;
    }
} stick[MAXN];
int dp[MAXN];

int main() {
    // freopen("input.txt", "r", stdin);
    scanf("%d", &T);
    while (T--) {
        CLR(dp);
        scanf("%d", &N);
        for (int i = 1; i <= N; i++) scanf("%d%d", &stick[i].l, &stick[i].r);
        sort(stick + 1, stick + N + 1);
        for (int i = 1; i <= N; i++) {
            dp[i] = 1;
            for (int j = 1; j < i; j++)
                if (stick[j].r > stick[i].r) {
                    dp[i] = max(dp[i], dp[j] + 1);
                }
        }
        int ans = -1;
        for (int i = 1; i <= N; i++) ans = max(ans, dp[i]);
        printf("%d
", ans);
    }
    return 0;
}