单调队列优化dp


我的理解:


形如dp[i]=max/min(f[k])+g[i]     (k<i  g[i]k无关)时,可用单调队列优化。

优化的对象是f[k];

 

本来 ik是要用两个for循环来套完,但是在此处,g[i]k,无关,而f[k]又要滚动取最值,那么就可以在一个for循环中把f[k]得到最值,同时计算当前的g[i],(强调,for循环的遍历顺序要确定,要保证可能与g[i]产生结果的所有f[k]都已计算完毕)将两者的结果存入dp[i]中,就达到了降维的目的。

 

补充:上述中的k可以当成i来看,因为是与i一同遍历。




例题 CDOj 594

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<iostream>

using namespace std;
#define INF 0xfffffff
int dp[2][110]; //两个110的数组滚动优化,轮流代表上一个
int n,c;
int q[110];//存与上一个有关的最值
int head,tail,cur;


int main()
{
    int i,j,x,nowf;
    while(scanf("%d%d",&n,&c)==2)
    {
        scanf("%d",&x);
        cur=0;
        for(i=0;i<x;i++)
            dp[cur][i]=INF;
        for(i=x;i<=100;i++)
            dp[cur][i]=(x-i)*(x-i);
        for(i=1;i<n;i++){
            scanf("%d",&x);
            cur=1-cur;//切换数组

            //比上一个大
            head=tail=0;
            for(j=0;j<=100;j++){    //这个循环将两个互不干涉但对同一值起作用的两个循环套在一起,是单调队列优化的精髓(降维)
                nowf=dp[1-cur][j]-j*c;  //这个j表示的是遍历上一数组
                while(head<tail && q[tail-1]>nowf)
                    tail--;
                q[tail++]=nowf; //不断记录最值
                if(j<x){
                    dp[cur][j]=INF;
                }
                else {
                    dp[cur][j]=q[head]+j*c+(x-j)*(x-j);
                }
            }

            //比上一个小
            head=tail=0;
            for(j=100;j>=0;j--){
                nowf=dp[1-cur][j]+j*c;
                while(head<tail && q[tail-1]>nowf)
                    tail--;
                q[tail++]=nowf;
                if(j>=x){
                    dp[cur][j]=min(dp[cur][j],q[head]-j*c+(x-j)*(x-j));
                }
            }

        }
        int ans=INF;
        for(i=0;i<=100;i++){
            ans=min(ans,dp[cur][i]);
        }
        printf("%d\n",ans);
    }
    return 0;
}




前面是学的时候照着网上敲的,后来发现记录极值好像完全不用开始组。。。。。

此题可以直接只存极值,但有些题中对于k有额外的限制条件的时候们就不能简单的只存一个值,比如hdu3401,还要存之前的数量,就要使用这种队列优化

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<iostream>

using namespace std;
#define INF 0xfffffff
int dp[2][110];
int n,c;
int head,tail,cur;

int main()
{
    int i,j,x,nowf;
    int mi=INF;
    while(scanf("%d%d",&n,&c)==2)
    {
        scanf("%d",&x);
        cur=0;
        for(i=0;i<x;i++)
            dp[cur][i]=INF;
        for(i=x;i<=100;i++)
            dp[cur][i]=(x-i)*(x-i);
        for(i=1;i<n;i++){
            scanf("%d",&x);
            cur=1-cur;
            head=tail=0;
            mi=INF;
            for(j=0;j<=100;j++){
                nowf=dp[1-cur][j]-j*c;
                mi=min(mi,nowf);
                if(j<x){
                    dp[cur][j]=INF;
                }
                else {
                    dp[cur][j]=mi+j*c+(x-j)*(x-j);
                }
            }
            mi=INF;
            head=tail=0;
            for(j=100;j>=0;j--){
                nowf=dp[1-cur][j]+j*c;
                mi=min(mi,nowf);
                if(j>=x){
                    dp[cur][j]=min(dp[cur][j],mi-j*c+(x-j)*(x-j));
                }
            }
        }
        int ans=INF;
        for(i=0;i<=100;i++){
            ans=min(ans,dp[cur][i]);
        }
        printf("%d\n",ans);
    }
    return 0;
}


单调队列优化DP是一种常用的优化方法,可以将时间复杂度从 $O(n^2)$ 降低到 $O(n)$ 或者 $O(n \log n)$。以下是一道利用单调队列优化DP的典型题目: 题目描述: 给定一个长度为 $n$ 的序列 $a_i$,定义 $f(i)$ 为 $a_i$ 到 $a_n$ 中的最小值,即 $f(i) = \min\limits_{j=i}^n a_j$。现在定义 $g(i)$ 为满足 $f(j) \ge a_i$ 的最小下标 $j$,即 $g(i) = \min\{j \mid j > i, f(j) \ge a_i\}$。如果不存在这样的下标 $j$,则 $g(i) = n+1$。 现在请你计算出 $1 \le i \le n$ 的所有 $g(i)$ 的值。 输入格式: 第一行包含一个整数 $n$。 第二行包含 $n$ 个整数 $a_1,a_2,\cdots,a_n$。 输出格式: 输出 $n$ 行,第 $i$ 行输出 $g(i)$ 的值。 输入样例: 5 3 1 2 4 5 输出样例: 2 5 5 5 6 解题思路: 设 $dp(i)$ 表示 $g(i)$,那么 $dp(i)$ 与 $dp(i+1)$ 的转移关系可以表示为: $$dp(i)=\begin{cases}i+1, &\text{if}\ f(i+1)\ge a_i \\dp(i+1), &\text{else}\end{cases}$$ 这个转移方程可以使用暴力 DP 解决,时间复杂度为 $O(n^2)$。但是,我们可以使用单调队列优化 DP,将时间复杂度降为 $O(n)$。 我们定义一个单调队列 $q$,存储下标。队列 $q$ 中的元素满足: - 队列中的元素是单调递减的,即 $q_1 < q_2 < \cdots < q_k$; - 对于任意的 $i\in [1,k]$,有 $f(q_i) \ge f(q_{i+1})$。 队列 $q$ 的作用是维护一个长度为 $k$ 的区间 $[i+1,q_k]$,满足这个区间中的所有 $j$ 都满足 $f(j) < f(i+1)$。 根据定义,当我们要求 $dp(i)$ 时,只需要查找队列 $q$ 中第一个满足 $f(q_j) \ge a_i$ 的位置 $q_j$,那么 $g(i) = q_j$,如果队列 $q$ 中不存在这样的位置,则 $g(i) = n+1$。 那么如何维护单调队列 $q$ 呢?我们可以在每次 DP 的过程中,将 $i$ 加入队尾。然后判断队首元素 $q_1$ 是否满足 $f(q_1) \ge a_i$,如果满足则弹出队首元素,直到队首元素不满足条件为止。 由于每个元素最多被加入队列一次,并且最多被弹出一次,因此时间复杂度为 $O(n)$。具体实现细节可以参考下面的代码实现:
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值