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

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

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

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

例题1:最大子段和

题目描述

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

输入输出格式

输入格式:

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

输出格式:

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

输入输出样例

输入样例#1:

7
2 -4 3 -1 2 -4 3

输出样例#1:

4

说明

【数据规模与约定】
对于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:

2

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

算法一:枚举
枚举正方形的某一个定点坐标(O(n×m)),在枚举正方形边长(O(max(n,m))),再累加(O(n×m))
时间复杂度:O(n^5)

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

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

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

那么,为什么要这样表示呢?那是因为简便计算矩阵和啊!
求和
看上图,假设我们要求计算的矩形(注意,这里是可以推广到一般情况的,矩形!)是图示红色方框所包括的部分(x1,y1)——(x2,y2)。
那么,这个答案可以通过图示 褐色方框 - 两个青色方框 + 黑色方框(由于多减了一次) 得到。
所以,

s=sum[x2][y2]sum[x2][y11]sum[x11][y2]+sum[x11][y11]

这就是我们的计算式。
但是,怎么计算sum[][]呢?
sum[i][j]=sum[i1][j]+sum[i][j1]sum[i1][j1]+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个石子在数轴上的位置(数据保证桥的起点和终点处没有石子)。所有相邻的整数之间用一个空格隔开。

输出格式:

输出文件river.out只包括一个整数,表示青蛙过河最少需要踩到的石子数。

输入输出样例

输入样例#1:

10
2 3 5
2 3 5 6 7

输出样例#1:

2
说明
对于30%的数据,L <= 10000;
对于全部的数据,L <= 109。

分析:

To Be Continue … …
低价购买
尼克的任务
多米诺骨牌
合唱队形
奇怪的字符串

阅读更多
版权声明:hhhhh https://blog.csdn.net/WT_cnyali/article/details/52950578
文章标签: dp 动态规划 算法
个人分类: Sol 算法 总结
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

不良信息举报

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

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭