寒假：Day5

Day5

今天开始刷提高课的全部内容，把之前一些遗忘的没搞明白的都抓一抓，还有就是把cf的题都补一补！

带权值的并查集

经典例题：240. 食物链 - AcWing题库

通过维护子节点到根节点的距离来维护两个点之间的其他关系，通过对3取模即可，妙哉！

学习代码实现

#include<bits/stdc++.h>
using namespace std;
const int N = 50010;
int d[N], p[N], n, m;

int find(int x) 
{
    if (x != p[x]) {
        int t = find(p[x]); // 让父节点的距离变成父节点到根节点的距离
        d[x] += d[p[x]]; // 让子节点的距离加上当前父节点的距离
        p[x] = t; // 父节点等于根节点，路径压缩
    }
    return p[x];
}

int main(void)
{
    scanf("%d %d", &n, &m);
    for (int i = 1; i <= n; i++ ) p[i] = i; // 初始化父节点
    int res = 0;
    while (m--) {
        int t, x, y;
        scanf("%d %d %d", &t, &x, &y);
        if (x > n || y > n) res ++;
        else {
            int px = find(x), py = find(y); // 先求出x和y的父节点编号
            if (t == 1) {
                if (px == py && (d[x] - d[y]) % 3) res ++; // 如果他们在一棵树上且他们并不是同类
                else if (px != py) { // 如果他们不在同一棵树上
                    p[px] = py;
                    d[px] = d[y] - d[x]; // 从x的父节点接一条向y的父节点的边，并且附上权值保证关系
                }
            }
            else {
                if (px == py && (d[x] - d[y] - 1) % 3) res++; // 如果他们在一棵树上但是x不被y吃
                else if (px != py) {
                    p[px] = py;
                    d[px] = d[y] + 1 - d[x]; // 从x的父节点向y的父节点接一条边，附上权值保证关系
                }
            }
        }
    }
    printf("%d", res);
    return 0;
}

数字三角形模型

数字三角形是一个很经典的DP模型，给定一张带权图，让你输出权值之和最大的一条路径

1015. 摘花生 - AcWing题库

最经典的例题，也特别容易理解，递推公式：$f[i,j]=max(f[i-1,j],f[i,j-1])$

#include<bits/stdc++.h>
using namespace std; 
int n, m ;
int g[110][110] ;
int main(void)
{
    int t ;
    cin >> t ;
    while (t--)
    {
        cin >> n >> m ;
        for (int i = 1 ; i <= n ; i++) {
            for (int j = 1 ; j <= m ; j++) {
                cin >> g[i][j] ;
            }
        }
        for (int i = 1 ; i <= n ; i++) {
            for (int j = 1 ; j <= m ; j++) {
                g[i][j] += max(g[i - 1][j], g[i][j - 1]) ;
            }
        }
        cout << g[n][m] << endl ;
    }
    return 0 ;
}

现在把一条路径变成两条路径，求从起点到终点的两条路径权值之和最大，且同一个格子的权值只能使用一次

275. 传纸条 - AcWing题库

这里我们采取的是两条路同时走，状态是$f[i1,j1,i2,j2]$，用来表示路径1到$(i1,j1)$时路径2到$(i2,j2)$的总权值和，但是可见这样需要枚举四层循环，时间复杂度很大，而且不好确定他们相交时的情况，所以我们设想两条路径相交时，存在 $i1+j1=i2+j2$ ，这样我们令 $k=i1+j1=i2+j2$ ，状态表示就变成 $f[k,i1,i2]$ 了，$j1j2$ 都可以用 $k-i1$或 $k-i2$ 来表示，一下子减少了一层循环，接下来就是状态集合划分了。

我们以最后一步时两条路径的方向进行划分，有四种状态：1下2下，1下2右，1右2下，1右2右，这样划分集合不重不漏，接下来就是求每一个集合的最大值
$$f[k,i1,i2]=max(f[k-1,i1-1,i2-1],f[k-1,i1-1,i2],f[k-1,i1,i2-1],f[k-1,i1,i2])+w$$
思路巧妙，值得多琢磨琢磨！

#include<bits/stdc++.h>
using namespace std;
const int N = 55;
int m, n;
int w[N][N];
int f[N * 2][N][N];

int main(void) {
    scanf("%d %d", &m, &n);
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            scanf("%d", &w[i][j]);
        }
    }
    for (int k = 2; k <= n + m; k++) { // 先枚举横纵坐标之和
        for (int i1 = 1; i1 <= m; i1++) { // 再枚举i1
            for (int i2 = 1; i2 <= m; i2++) { // 再枚举i2
                int j1 = k - i1;
                int j2 = k - i2;
                if (j1 >= 1 && j1 <= n && j2 >= 1 && j2 <= n) { // j必须合法才行
                    int t = w[i1][j1];
                    if (i1 != i2) t += w[i2][j2]; //两条路径未相交，则权值为两个格子之和
                    int &x = f[k][i1][i2];
                    x = max(x, f[k - 1][i1 - 1][i2 - 1] + t); // 枚举四个方向
                    x = max(x, f[k - 1][i1 - 1][i2] + t);
                    x = max(x, f[k - 1][i1][i2 - 1] + t);
                    x = max(x, f[k - 1][i1][i2] + t);
                }
            }
        }
    }
    printf("%d", f[m + n][m][m]);
    return 0;
}

最长上升子序列模型

896. 最长上升子序列 II - AcWing题库

将数据扩大使得时间复杂度控制在 $n(logn)$，开一个数组记录的是到当前数时，长度为1，长度为2，长度为3…的最长上升子序列的最小尾巴，然后二分查找第一个比当前数要小的尾巴，这样我们就可以把这个数接上去，比起DP更像是一个贪心的思想。

#include<bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, a[N], q[N];

int main(void)
{
    scanf("%d", &n);
    for (int i = 0 ; i < n; i++) scanf("%d", &a[i]); 
    int len = 0;
    q[0] = -2e9; // 设置一个哨兵防止边界问题
    for (int i = 0 ; i < n ; i ++) {
        int l = 0, r = len;
        while (l < r) { // 二分查找第一个小于a[i]的下标
            int mid = l + r + 1 >> 1;
            if (q[mid] < a[i]) l = mid;
            else r = mid - 1;
        }
        len = max(len, r + 1);
        q[r + 1] = a[i]; // 把后一个改成当前数
    }
    cout << len << endl ;
    return 0;
}

1017. 怪盗基德的滑翔翼 - AcWing题库

顾名思义，就是求最长上升子序列的最大长度，状态是 $f[i]$，表示以 $i$ 结尾的最长上升子序列是多长，遍历从1到 $i$ 可得：
$$f[i]=max(f[i],f[j]+1)$$
简单递推！

#include<bits/stdc++.h>
using namespace std;
int t, n;
const int N = 110;
int a[N], f[N];

int main(void)
{
    scanf("%d", &t);
    while (t--) {
        scanf("%d", &n);
        for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
        int res = 0;
        for (int i = 1; i <= n; i++ ) { // 正方向做一遍
            f[i] = 1; 
            for (int j = 1; j < i; j++) {
                if (a[i] > a[j]) {
                    f[i] = max(f[i], f[j] + 1);
                }
            }
            res = max(res, f[i]);
        }
        for (int i = n; i >= 1; i--) { // 反方向做一遍
            f[i] = 1;
            for (int j = n; j > i; j--) {
                if (a[i] > a[j]) {
                    f[i] = max(f[i], f[j] + 1);
                }
            }
            res = max(res, f[i]);
        }
        printf("%d\n", res);
    }
    return 0;
}

1012. 友好城市 - AcWing题库

最长上升子序列的一个应用，给出了两个序列，不让他们两两之间的关系产生交叉，所以我们先对一边进行排序，然后对另一边进行最长上升子序列，这样就保证了不会有交叉，妙哉！

#include<bits/stdc++.h>
using namespace std;
const int N = 5010;
pair<int, int> arr[N];
int f[N], n;
int main(void)
{
    cin >> n;
    for (int i = 1; i <= n; i++) {
        int a, b;
        cin >> a >> b ;
        arr[i] = {a, b};
    }
    sort(arr + 1, arr + n + 1);
    int res = 0;
    for (int i = 1; i <= n; i++) {
        f[i] = 1;
        for  (int j = 1; j < i; j++) {
            if (arr[i].second > arr[j].second)
                f[i] = max(f[i], f[j] + 1);
        }
        res = max(res, f[i]);
    }
    cout << res << endl ;
    return 0;
}