NOIP算法总结——关于简单线性动态规划

最新推荐文章于 2024-09-18 09:38:43 发布

WT_cnyali

最新推荐文章于 2024-09-18 09:38:43 发布

阅读量3.3k

点赞数 2

分类专栏： Sol 算法总结文章标签： dp 动态规划算法

本文链接：https://blog.csdn.net/WT_cnyali/article/details/52950578

版权

算法同时被 3 个专栏收录

43 篇文章 0 订阅

订阅专栏

Sol

30 篇文章 0 订阅

订阅专栏

总结

14 篇文章 1 订阅

订阅专栏

动态规划，显然是一个很让人头疼的地方，也没有个固定的算法，最多就是有一些模板（比如背包啊），要是想要增大做出来的机率，也就只好多做做题找找感觉了~

线性动态规划可以说是DP中最简单的类型了，当然里面很多也是不容易的题目，也是需要一点技巧了。搞了好几天了，现在就来总结一下。

一、算法的选取，动态维护。

例题1：最大子段和

题目描述

给出一段序列，选出其中连续且非空的一段使得这段和最大。

输入输出格式

输入格式：

输入文件maxsum1.in的第一行是一个正整数N，表示了序列的长度。
第2行包含N个绝对值不大于10000的整数A[i]，描述了这段序列。

输出格式：

输入文件maxsum1.out仅包括1个整数，为最大的子段和是多少。子段的最小长度为1。

输入输出样例

输入样例#1：

7
2 -4 3 -1 2 -4 3

输出样例#1：

说明

【数据规模与约定】
对于40%的数据，有N ≤ 2000。
对于100%的数据，有N ≤ 200000。
【洛谷1115】

算法一：暴力枚举。枚举每一个子段，求和，再求最大。
时间复杂度：枚举是O(n)，每次计算是O(n)，总共是O(n^3)。

#include <bits/stdc++.h>
using namespace std ;
int a[200010] ;
int main() {
    int i, j, k, m, n ;
    scanf ( "%d", &n ) ;
    for ( i = 1 ; i <= n ; i ++ ) 
        scanf ( "%d", a+i ) ;
    int ans = -2147483647 ;
    for ( i = 1 ; i <= n ; i ++ ) 
        for ( j = i ; j <= n ; j ++ ) {
            int sum = 0 ;
            for ( k = i ; k <= j ; k ++ ) 
                sum += a[k] ;
            ans = max ( ans, sum ) ;
        }
    printf ( "%d\n", ans ) ;
    return 0 ;
}

显然不可取。
看那范围，显然是TLE到干干净净。

算法二：前缀和优化。和算法一类似，也是枚举每个子段，只是子段求和的时候使用前缀和优化（O(1)）。
时间复杂度：O(n^2)

#include <bits/stdc++.h>
using namespace std ;
int a[200010] ;
int main() {
    int i, j, k, m, n ;
    scanf ( "%d", &n ) ;
    for ( i = 1 ; i <= n ; i ++ ) { 
        scanf ( "%d", a+i ) ;
        a[i] += a[i-1] ;
    } 
    int ans = -2147483647 ;
    for ( i = 1 ; i <= n ; i ++ ) 
        for ( j = i ; j <= n ; j ++ ) {
            int sum = 0 ;
            sum = a[j] - a[i-1] ;
            ans = max ( ans, sum ) ;
        }
    printf ( "%d\n", ans ) ;
    return 0 ;
}

啊！骗到了40分，还是可以的。
不过，显然不是正解。

算法三：动态维护最小前缀和。
时间复杂度： O(n)
这还是要分析一下的……
对于i~j的子段，sum = a[j] - a[i-1] ;
那么，以j为结尾的所有子段，都是a[j]减去一个什么什么东西。
显然，减去的那个东西越小越好~
那么，我们只要维护最小的那个就好了。所以时间降到了线性。

#include <bits/stdc++.h>
using namespace std ;
int a[200010] ;
int main() {
    int i, j, k, m, n ;
    scanf ( "%d", &n ) ;
    for ( i = 1 ; i <= n ; i ++ ) { 
        scanf ( "%d", a+i ) ;
        a[i] += a[i-1] ;
    } 
    int ans = -2147483647, Min = 0 ;
    for ( i = 1 ; i <= n ; i ++ ) {
        ans = max ( ans, a[i] - Min ) ;
        Min = min ( a[i], Min ) ;
    }
    printf ( "%d\n", ans ) ;
    return 0 ;
}

没话说，这还不AC？

二、前缀和的利用

就像上面那个题目里所使用的一样，前缀和经常能给我们很大的帮助。
那是一维的‘前缀和’，其实，对于一些二维甚至三维的统计（不一定是求和，也可能是求异或之类），我们也可使用前缀和。

最大正方形【洛谷1387】

题目描述

在一个n*m的只包含0和1的矩阵里找出一个不包含0的最大正方形，输出边长。

输入输出格式

输入格式：

输入文件第一行为两个整数n,m（1<=n,m<=100），接下来n行，每行m个数字，用空格隔开，0或1.

输出格式：

一个整数，最大正方形的边长

输入输出样例

输入样例#1：

4 4
0 1 1 1
1 1 1 0
0 1 1 0
1 1 0 1

输出样例#1：

分析：如果一个矩形的元素和与面积相等，那么它里面的元素就全部是1

算法一：枚举
枚举正方形的某一个定点坐标（O(n $\times$ m)），在枚举正方形边长（O(max(n,m))），再累加（O(n $\times$ m)）
时间复杂度：O(n^5)

显然会TLE的干干净净。
由于这个暴力枚举很简单，就不贴出代码了。

算法二：还是枚举，只是加前缀和优化
方法同上，但是求和的过程不是累加，而是使用前缀和（O(1)）。

怎么使用前缀和呢？
sum(i,j) 表示点(1,1)和点(i,j)围成矩形里元素的和。（如下图）
sum[i][j]

那么，为什么要这样表示呢？那是因为简便计算矩阵和啊！

看上图，假设我们要求计算的矩形（注意，这里是可以推广到一般情况的，矩形！）是图示红色方框所包括的部分(x1,y1)——(x2,y2)。
那么，这个答案可以通过图示褐色方框 - 两个青色方框 + 黑色方框（由于多减了一次）得到。
所以，

s = s u m [x 2] [y 2] - s u m [x 2] [y 1 - 1] - s u m [x 1 - 1] [y 2] + s u m [x 1 - 1] [y 1 - 1]

$s = sum[x2][y2] - sum[x2][y1-1] - sum[x1-1][y2] + sum[x1-1][y1-1]$
这就是我们的计算式。
但是，怎么计算sum[][]呢？

s u m [i] [j] = s u m [i - 1] [j] + s u m [i] [j - 1] - s u m [i - 1] [j - 1] + a [i] [j]

$sum[i][j] = sum[i-1][j] + sum[i][j-1] - sum[i-1][j-1] + a[i][j]$

接下来的任务就很简单了，直接上代码

#include <bits/stdc++.h>
using namespace std ;
const int maxn = 110 ;
bool a[maxn][maxn] ; // 记录原始数组
int sum[maxn][maxn] ; // sum意义同上所述
int main() {
    int i, j, k, m, n, l ;
    scanf ( "%d%d", &n, &m ) ;
    for ( i = 1 ; i <= n ; i ++ )
        for ( j = 1 ; j <= m ; j ++ ) 
            scanf ( "%d", &a[i][j] ) ;
    for ( i = 1 ; i <= n ; i ++ ) 
        for ( j = 1 ; j <= m ; j ++ ) 
            sum[i][j] = sum[i-1][j] + sum[i][j-1] - sum[i-1][j-1] + a[i][j] ; // 递推计算sum
    int x2, y2, x1, y1 ;
    int ans = -1000000000, L ; // 用于存储最大面积，答案边长
    for ( x1 = 1 ; x1 <= n ; x1 ++ ) 
        for ( y1 = 1 ; y1 <= m ; y1 ++ ) 
            for ( l = 1 ; l+x1-1 <= n && l+y1-1 <= m ; l ++ ){
                x2 = l+x1-1 ; y2 = l+y1-1 ;
                int s = sum[x2][y2] - sum[x2][y1-1] - sum[x1-1][y2] + sum[x1-1][y1-1] ;
                if ( s != l*l ) continue ;
                if ( s > ans ) {
                    ans = s ;
                    L = l ;
                }
            }
    printf ( "%d\n", L ) ;
    return 0 ;
}

是不是显然很简单呢~

三、简单的递推。

例题1：过河【NOIp 2005 T2】

题目描述

在河上有一座独木桥，一只青蛙想沿着独木桥从河的一侧跳到另一侧。在桥上有一些石子，青蛙很讨厌踩在这些石子上。由于桥的长度和青蛙一次跳过的距离都是正整数，我们可以把独木桥上青蛙可能到达的点看成数轴上的一串整点：0，1，……，L（其中L是桥的长度）。坐标为0的点表示桥的起点，坐标为L的点表示桥的终点。青蛙从桥的起点开始，不停的向终点方向跳跃。一次跳跃的距离是S到T之间的任意正整数（包括S,T）。当青蛙跳到或跳过坐标为L的点时，就算青蛙已经跳出了独木桥。
题目给出独木桥的长度L，青蛙跳跃的距离范围S,T，桥上石子的位置。你的任务是确定青蛙要想过河，最少需要踩到的石子数。

输入输出格式

输入格式：

输入文件river.in的第一行有一个正整数L（1 <= L <= 10^9），表示独木桥的长度。第二行有三个正整数S，T，M，分别表示青蛙一次跳跃的最小距离，最大距离，及桥上石子的个数，其中1 <= S <= T <= 10，1 <= M <= 100。第三行有M个不同的正整数分别表示这M个石子在数轴上的位置（数据保证桥的起点和终点处没有石子）。所有相邻的整数之间用一个空格隔开。