单调队列优化DP能到什么程度(今天中午进行的实验记录)

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/zhjchengfeng5/article/details/7653120

想了一早上单调队列优化DP,总觉得不能优化到哪里去,又从来没有做过这种需要用单调队列优化的DP,于是自己用手模拟了一下实现过程,瞬间就明白了单调队列优化DP,这个DP的转移方程应该具有的性质。

单调队列很好理解,就是一个双向队列,队首队尾允许删除操作,队尾进行添加操作,维护整个队列的严格单调性,即队列中不存在相等的元素(这样时间常数小一点)。

那么用单调队列优化的DP应该具有怎样的性质呢?

假如我们有下面的DP转移方程:

    f[i] = min( f[j] ) + a[i]

那么当 j 满足一个条件: Low[i] <= j <= Up[i] ,这里的 Low 和 Up 是关于 i 的单调函数,而且是单调递增的,为什么呢?联系经典的单调队列入门题: Sliding Window 想想就清楚了: 当我用下一个 Low[i] 的时候,Low[i] 必须大于等于 Low[i-1] ,因为队首涉及到了要出队列的操作,而队尾的元素上界: Up 也是必须具有单调递增的性质,因为再用队尾的元素的时候,涉及到添加元素的操作。如果还是不很明白,那么联系 Sliding Window 仔细想想这个单调队列删除插入的过程即可。很好想通的。

那么单调队列到底能优化到怎么样的程度呢?我们来看看下面的实验:

【实验方程】:

f[i] = min ( f[j] ) + a[i] ( 1<= j <= i-1 )

【实验过程】:

我做了个测试数据,不大,刚好有 10^5 个数。用传统的 o( n^2 ) 的算法铁定超时,二这个转移方程来看,我们可以不用单调队列优化到 o ( n ) 的复杂度:就是记录一个 1——i 的最小值 Min 每次计算 f[i] 的时候用 Min + a[i] 即可。

那么这道题总共就可以写出三个程序,时间复杂度分别是;

传统的二重循环判定: o( n^2 )

用最小值优化:o( n )

用单调队列优化:未知 (这就是这个实验要探讨的内容)

下面先给出实验程序:

1、传统的二重循环判定:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<ctime>
#include<cstdlib>
#define INF 0x7fffffff
using namespace std;
int main()
{
    freopen("in.in","r",stdin);
    freopen("out.out","w",stdout);
    int n,a[100005],f[100005];
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    f[1]=a[1];
    for(int i=2;i<=n;i++)
    {
        int Min=INF;
        for(int j=1;j<i;j++)
            if(Min>f[j]) Min=f[j];
        f[i]=Min+a[i];
    }
    for(int i=1;i<=n;i++)
    {
        printf("%d",f[i]);
        if(i==n) printf("\n");
        else printf(" ");
    }
    return 0;
}


用最小值优化:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<ctime>
#include<cstdlib>
#define INF 0x7fffffff
using namespace std;
int main()
{
    freopen("in.in","r",stdin);
    freopen("out.out","w",stdout);
    int n,a[100005],f[100005];
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    f[1]=a[1];
    int Min=f[1];
    for(int i=2;i<=n;i++)
    {
        f[i]=Min+a[i];
        if(f[i]<Min) Min=f[i];
    }
    for(int i=1;i<=n;i++)
    {
        printf("%d",f[i]);
        if(i==n) printf("\n");
        else printf(" ");
    }
    return 0;
}


用单调队列优化:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<ctime>
#include<cstdlib>
#define INF 0x7fffffff
using namespace std;
int main()
{
    freopen("in.in","r",stdin);
    freopen("out.out","w",stdout);
    int n,a[100005],f[100005];
    int q[200000],head,tail;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    f[1]=a[1];
    tail=1; head=0; q[1]=1;
    for(int i=2;i<=n;i++)
    {
        f[i]=f[q[1]]+a[i];
        //printf("f[q[1]]=%d\n",f[q[1]]);
        //printf("f[%d]=%d\n",i,f[i]);
        while(f[i]<=f[q[tail]] && 1<=tail) tail--;
        q[++tail]=i;
    }
    for(int i=1;i<=n;i++)
    {
        printf("%d",f[i]);
        if(i==n) printf("\n");
        else printf(" ");
    }
    return 0;
}


程序有了,我们就可以做实验了:

我先用了一个 10^4 的数据规模来测试这三个程序,下面我们看看他们跑的时间:

从上面的数据结果可以看出,使用赤果果的的 二重循环 的话,消耗的时间几乎是使用 o( n )算法的 60 倍,然而使用 单调队列 优化的方法时,时间竟然和我预想的 “和赤果果的 o( n^2 ) 差不多”有很大的差别,竟然和 o( n ) 几乎一样了!于是不信邪的我又试了一组数据,这下我把数据规模弄到了 10^5 这个级别,下面是实验结果:

我想,到了这个地步,单调队列的时间复杂度我们不用质疑了,相当于去掉了一重循环,碉堡有木有!!

所以以后能用单调队列就尽量用单调队列吧

阅读更多
换一批

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