### [$CSP-J$ $2022$] 上升点列
[P8816 [CSP-J 2022] 上升点列（民间数据）](https://www.luogu.com.cn/problem/P8816)

[前导知识练习 力扣 664. 奇怪的打印机](https://www.cnblogs.com/littlehb/p/16869777.html)


样例$1$输入解析
![](http://dsideal.obs.cn-north-1.myhuaweicloud.com/HuangHai/BlogImages/2022/12/2dc17e2354277c36a0153d24b915021c.png)

![](http://dsideal.obs.cn-north-1.myhuaweicloud.com/HuangHai/BlogImages/2022/12/355e3f69c3a6f89d990f9f8d8a50b5fd.png)

#### 动态规划解法

这种题目乍一看就能想到是 **$dp$**  或者 **二分**，从哪个先开始考虑都没问题

思考二分最后会发现不知道该从何入手，如果是二分长度，那不知道起点，二分起点，那也没有意义

再配合数据范围只有$500$，这种数据范围大概率就是$dp$,那么来思考$dp$

#### 状态表示
很容易想到$f[i][j]$表示到第$i$个节点，已经用掉了$j$个可添加点的 **最大长度**

#### 状态转移
状态有了，转移应该也很容易想到，对于第$i$个节点，无非就是枚举其他节点$j$,如果$j$在$i$的左下方即可进行转移，计算
$$\large d=a[i].x-a[j].x+a[i].y-a[j].y-1$$
即$j$到$i$ 需要使用 $d$ 个可添加点

现在的场景是从$j->i$,对于状态表示$f[i][?]$的一维已经确定是从$f[j][?]->f[i][??]$了，这两个问题间的转移是关键问题了：

那么枚举$f[j][k]$,即可得到方程
$$\large f[i][k+d]=max(f[j][k]+d+1)$$

最后答案即为
$$\large ans = max(ans, f[i][k + d] + m - k - d)$$

#### 注意
这里注意一个小细节，如果总共有 $m$ 个可添加点，只用了$k+d$个，多出来的$m-k-d$个直接加在最后即可，不要忘记这个，不过这个坑在第二组$sample$里就给出来了，基本不会有人踩 

<font color='red' size=4><b>不把测试用例看完，画出来，理解掉的人是傻子！！！</b></font>

检查一下复杂度，是$O(n^2K)$,显然没有问题
```cpp {.line-numbers}
#include <bits/stdc++.h>
using namespace std;
const int N = 510;
const int M = 110;
struct Node {
    int x, y;
    /*
     Q1:为什么要排序？
     A:因为要DP，需要解决无后效性。也就是有一定的单调性，从左向右，从上向下填表，填完的数值不能再被修改，需要有一定的依赖关系顺序

     Q2:按什么来排序？
     A:可以按x+y来排序，也可以按先x,后y的方式来排序，都是一样的。

     1.按x+y排序
     const bool operator<(const Node &t) {
         return x + y < t.x + t.y;
     }
    */
    // 2.先按x,再按y排序
    const bool operator<(const Node &t) {
        if (x == t.x) return y < t.y;
        return x < t.x;
    }
} a[N];

int f[N][M];
int ans;

int main() {
    //文件输入
    // freopen("point.in", "r", stdin);

    int n, m;
    cin >> n >> m;

    for (int i = 1; i <= n; ++i) cin >> a[i].x >> a[i].y;
    sort(a + 1, a + 1 + n);

    // dp初始化,最后一个点是以i号点选中，并且,使用了j个虚拟点情况下，获得的最长序列长度
    for (int i = 1; i <= n; i++)
        for (int j = 0; j <= m; j++)
            f[i][j] = j + 1; //以i点结束，并且，使用了j个虚拟点，最起码可以构成一个最长长度为j+1的序列

    //状态转移
    for (int i = 1; i <= n; i++)      //枚举每个原始点
        for (int j = 1; j < i; j++) {                         //枚举每个前序点
            if (a[i].x < a[j].x || a[i].y < a[j].y) continue; //如果j不在i的左下方，无效转移
            int d = a[i].x - a[j].x + a[i].y - a[j].y - 1;    // j->i 需要增加的虚拟点个数

            /*
             讨论j点的哪些子状态 可以转移到 i的哪些子状态？
             思考一下f[j]的二维状态，最小值是0,最大值是m
             现在f[j]的二维状态变化量是固定的，是d
             所以需要枚举j的所有以转移的二维状态值：0 ~ m-d
            */
            for (int k = 0; k <= m - d; k++) {
                // f[j][k]是前序状态，可以通过+d转移到新的状态
                // f[j][k+d]+d+1 -> f[i][k+d]
                f[i][k + d] = max(f[i][k + d], f[j][k] + d + 1);

                //在状态转移完成后，收集一下答案
                //小坑一个：给你m个虚拟点，你最后没用了的话，就是浪费，因为最起码，
                //把多出来的放在最后就可以增长序列长度
                ans = max(ans, f[i][k + d] + m - k - d); //更新序列最长长度
            }
        }

    //输出结果
    printf("%d\n", ans);
    return 0;
}
```

[最优子结构及 $dp$ 数组遍历方向的问题](https://zhuanlan.zhihu.com/p/100993613)

* $1$、遍历的过程中，所需的状态必须是已经计算出来的
* $2$、遍历的终点必须是存储结果的那个位置

#### 记忆化搜索解法I
```c++
#include <bits/stdc++.h>
const int N = 510;

//性能：第12号测试点，时间最长，65ms

/*
搜索代码：暴力枚举每次选择哪个点，能选就选，维护剩下几个自由点，加个记忆化即可通过
*/
using namespace std;
int n, m, ans;
int x[N], y[N]; //对于二维坐标，两个x,y数组，明显比使用struct的结构体数组方便,但是，不利用整体排序
int f[N][N];    //结果数组

//从u点出发，还有r个虚拟点可用,可以获得的最长序列长度是多少
int dfs(int u, int r) {
    if (~f[u][r]) return f[u][r]; //计算过则直接返回
    int ans = r + 1; //剩余r个虚拟点，再加上当前点u，最起码能有r+1点的序列长度

    for (int i = 1; i <= n; i++) {                //谁能做为我的后续点
        if (u == i) continue;                     //自己不能做为自己的直接后续点
        if (x[i] < x[u] || y[i] < y[u]) continue; //排除掉肯定不可能成为我后续点的点
        int d = x[i] - x[u] + y[i] - y[u] - 1;    // u->i之间缺少 多少个虚拟点
        if (d > r) continue;                      //如果需要的虚拟点个数大于剩余的虚拟点个数，那么i 无法做为u的后续点
        ans = max(ans, dfs(i, r - d) + d + 1);    //在消耗了d个虚拟点之后，成功到达了i这个点；
        //①已经取得的序列长度贡献u和d个虚拟点，共d+1个
        //②问题转化为求未知部分:以i点为出发点，剩余虚拟点个数r-d个的情况下可以获取到的最长序列长度
    }
    return f[u][r] = ans; //记忆化
}

int main() {
    //文件输入
    // freopen("point.in", "r", stdin);
    memset(f, -1, sizeof f);

    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> x[i] >> y[i];

    for (int i = 1; i <= n; i++) ans = max(ans, dfs(i, m));
    printf("%d\n", ans);
    return 0;
}
```

#### 记忆化搜索优化版本
```c++
#include <bits/stdc++.h>
const int N = 510;

//性能：第12号测试点，时间最长，22ms
/*
搜索代码：暴力枚举每次选择哪个点，能选就选，维护剩下几个自由点，加个记忆化即可通过
*/
using namespace std;
int n, m, ans;

int f[N][N]; //结果数组
struct Node {
    int x, y;
    const bool operator<(Node &t) const {
        if (x == t.x) return y < t.y;
        return x < t.x;
    }
} a[N];

//从u点出发，还有r个虚拟点可用,可以获得的最长序列长度是多少
int dfs(int u, int r) {
    if (~f[u][r]) return f[u][r]; //计算过则直接返回
    int ans = r + 1;              //剩余r个虚拟点，再加上当前点u，最起码能有r+1点的序列长度

    for (int i = u + 1; i <= n; i++) {                    //谁能做为我的后续点
        if (u == i) continue;                             //自己不能做为自己的直接后续点
        if (a[i].x < a[u].x || a[i].y < a[u].y) continue; //排除掉肯定不可能成为我后续点的点
        int d = a[i].x - a[u].x + a[i].y - a[u].y - 1;    // u->i之间缺少 多少个虚拟点
        if (d > r) continue;                              //如果需要的虚拟点个数大于剩余的虚拟点个数，那么i 无法做为u的后续点
        ans = max(ans, dfs(i, r - d) + d + 1);            //在消耗了d个虚拟点之后，成功到达了i这个点；
        //①已经取得的序列长度贡献u和d个虚拟点，共d+1个
        //②问题转化为求未知部分:以i点为出发点，剩余虚拟点个数r-d个的情况下可以获取到的最长序列长度
    }
    return f[u][r] = ans; //记忆化
}

int main() {
    //文件输入
    // freopen("point.in", "r", stdin);

    memset(f, -1, sizeof f);

    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> a[i].x >> a[i].y;
    sort(a + 1, a + 1 + n);

    for (int i = 1; i <= n; i++) ans = max(ans, dfs(i, m));
    printf("%d\n", ans);
    return 0;
}
```