P1725 琪露诺

P1725 琪露诺

题目描述

在幻想乡，琪露诺是以笨蛋闻名的冰之妖精。某一天，琪露诺又在玩速冻青蛙，就是用冰把青蛙瞬间冻起来。但是这只青蛙比以往的要聪明许多，在琪露诺来之前就已经跑到了河的对岸。于是琪露诺决定到河岸去追青蛙。小河可以看作一列格子依次编号为0到N，琪露诺只能从编号小的格子移动到编号大的格子。而且琪露诺按照一种特殊的方式进行移动，当她在格子i时，她只会移动到i+L到i+R中的一格。你问为什么她这么移动，这还不简单，因为她是笨蛋啊。每一个格子都有一个冰冻指数A[i]，编号为0的格子冰冻指数为0。当琪露诺停留在那一格时就可以得到那一格的冰冻指数A[i]。琪露诺希望能够在到达对岸时，获取最大的冰冻指数，这样她才能狠狠地教训那只青蛙。但是由于她实在是太笨了，所以她决定拜托你帮它决定怎样前进。开始时，琪露诺在编号0的格子上，只要她下一步的位置编号大于N就算到达对岸。

输入输出格式

输入格式：

第1行：3个正整数N, L, R

第2行：N+1个整数，第i个数表示编号为i-1的格子的冰冻指数A[i-1]

输出格式：

一个整数，表示最大冰冻指数。保证不超过2^31-1

输入输出样例

输入样例#1： 复制

5 2 3
0 12 3 11 7 -2

输出样例#1： 复制

11

说明

对于60%的数据：N <= 10,000

对于100%的数据：N <= 200,000

对于所有数据 -1,000 <= A[i] <= 1,000且1 <= L <= R <= N

洛谷题解

首先这是一道动态规划的题目

如果不优化的话 只能得到部分分 要优化 必须用单调队列，线段树等等。（看到楼下写单调队列的挺少的，那我就来一个单调队列优化dp的）

首先明确 精灵只能从[i+l,i+r]转移过来 那么状态转移方程 ：

dp[i]=max(dp[k]) (k∈[i+l,i+r]) +a[i]; 因为题意说可以由大于n的数转移 那么就新增一个点 dp[n+1]=0；(主要还是避免负数)

明确一下 q为单调队列 维护的是从[i+l,i+r] dp[k]的最大值 （递减的）

首先dp[n-l+1]~dp[n]只能等于a[i] 先预处理一下

然后枚举i从n+1到l每次用dp[i]来更新dp[i-l] 然后把dp[i-l]打入单调队列 同时进行判断 如果i-1中右端点发生改变 那么就在i这个循环的末尾进行单调队列弹出队首元素

这个人在i处只能跳到i+l~i+r处，用dp会超时，用贪心无法得出最优解（后面的值得不到）。

那么逆推，最后的状态固定，并且通过区间，可以判断使用单调队列，每个点i由i+l~i+r的最优值推出，优先队列里面放的就是i+l~i+r的最优值。

f数组代表什么你都忘记了你怎么做，dp怎么你都忘记了你怎么做。

其实这种数据量特别小的可以手动画图的

不然写代码敲中间过程也挺浪费时间的

读懂各个变量的意思，就很简单了

DP问题肯定要想办法弄清楚状态转移方程

题解的解析里面真的说的足够详细了

把状态转移方程想清楚之后，这个题目真的超级简单，

状态转移方程想清楚后，需要优化哪里也是一眼就看出来了

#include<iostream>
#include<cstdio>
#include<iomanip>
#include<cstring>
#include<cmath>
using namespace std;
int n,l,r,a[200005],f[400005],q[200005],heade=1,taile=0;
int main()
{
    cin>>n>>l>>r;
    for(int i=0;i<=n;++i)
    scanf("%d",&a[i]);
    //反过来好整，好确定来源，填表法 
    for(int i=n+l;i>=l;--i)
    {
        //单调队列找插入位置，栈底的元素大 
        while(f[q[taile]]<=f[i]&&heade<=taile) taile--;
        q[++taile]=i;//这里是把i加进单调队列 
        //f[q[heade]]+a[i-l]表示走这么多步的最优值 
        f[i-l]=max(f[i-l],f[q[heade]]+a[i-l]);
        //头被用掉 
        if(q[heade]==i+r&&heade<=taile) heade++;
    }
    cout<<f[0];
    return 0;
}

单调队列里面放的是dp的值的下标。

中间过程

-------------1、读入数据-------------

--这是a数组：
0 12 3 11 7 -2

-------------2、单调队列+dp-------------

i: 7
--这是单调队列：
0 7 0 0 0 0
heade: 1 taile:1
f[i-l]: 0 q[heade]: 7 f[q[heade]]:0 a[i-l]:-2
--这是f数组：
0 0 0 0 0 0
q[heade]: 7 i+r: 10
--这是单调队列：
0 7 0 0 0 0
heade: 1 taile:1

i: 6
--这是单调队列：
0 6 0 0 0 0
heade: 1 taile:1
f[i-l]: 7 q[heade]: 6 f[q[heade]]:0 a[i-l]:7
--这是f数组：
0 0 0 0 7 0
q[heade]: 6 i+r: 9
--这是单调队列：
0 6 0 0 0 0
heade: 1 taile:1

i: 5
--这是单调队列：
0 5 0 0 0 0
heade: 1 taile:1
f[i-l]: 11 q[heade]: 5 f[q[heade]]:0 a[i-l]:11
--这是f数组：
0 0 0 11 7 0
q[heade]: 5 i+r: 8
--这是单调队列：
0 5 0 0 0 0
heade: 1 taile:1

i: 4
--这是单调队列：
0 4 0 0 0 0
heade: 1 taile:1
f[i-l]: 10 q[heade]: 4 f[q[heade]]:7 a[i-l]:3
--这是f数组：
0 0 10 11 7 0
q[heade]: 4 i+r: 7
--这是单调队列：
0 4 0 0 0 0
heade: 1 taile:1

i: 3
--这是单调队列：
0 3 0 0 0 0
heade: 1 taile:1
f[i-l]: 23 q[heade]: 3 f[q[heade]]:11 a[i-l]:12
--这是f数组：
0 23 10 11 7 0
q[heade]: 3 i+r: 6
--这是单调队列：
0 3 0 0 0 0
heade: 1 taile:1

i: 2
--这是单调队列：
0 3 2 0 0 0
heade: 1 taile:2
f[i-l]: 11 q[heade]: 3 f[q[heade]]:11 a[i-l]:0
--这是f数组：
11 23 10 11 7 0
q[heade]: 3 i+r: 5
--这是单调队列：
0 3 2 0 0 0
heade: 1 taile:2

-------------3、输出结果-------------

11

#include<iostream>
#include<cstdio>
#include<iomanip>
#include<cstring>
#include<cmath>
using namespace std;
int n,l,r,a[200005],f[400005],q[200005],heade=1,taile=0;

void printA(){
    cout<<"--这是a数组："<<endl;
    for(int i=0;i<=n;i++){
        cout<<setw(3)<<a[i];
    }
    cout<<endl;
}

void printQ(){
    cout<<"--这是单调队列："<<endl;
    for(int i=0;i<=n;i++){
        cout<<setw(3)<<q[i];
    }
    cout<<endl;
    cout<<"heade: "<<heade<<"    taile:"<<taile<<endl;
}

void printF(){
    cout<<"--这是f数组："<<endl;
    for(int i=0;i<=n;i++){
        cout<<setw(3)<<f[i];
    }
    cout<<endl;
}

int main()
{
    freopen("in.txt","r",stdin); 
    freopen("out.txt","w",stdout); 
    cout<<endl<<"-------------1、读入数据-------------"<<endl<<endl; 
    cin>>n>>l>>r;
    for(int i=0;i<=n;++i)
    scanf("%d",&a[i]);
    printA(); 
    //反过来好整，好确定来源，填表法 
    cout<<endl<<"-------------2、单调队列+dp-------------"<<endl<<endl; 
    for(int i=n+l;i>=l;--i)
    {
        cout<<endl<<"i: "<<i<<endl; 
        //单调队列找插入位置，栈底的元素大 
        while(f[q[taile]]<=f[i]&&heade<=taile) taile--;
        q[++taile]=i;
        printQ();
        //f[q[heade]]+a[i-l]表示走这么多步的最优值 
        f[i-l]=max(f[i-l],f[q[heade]]+a[i-l]);
        cout<<"f[i-l]: "<<f[i-l]<<"  q[heade]: "<<q[heade]<<"  f[q[heade]]:"<<f[q[heade]]<<"  a[i-l]:"<<a[i-l]<<endl; 
        printF();
        //头被用掉,heade<=taile表示还有元素 
        if(q[heade]==i+r&&heade<=taile) heade++;
        cout<<"q[heade]: "<<q[heade]<<"  i+r: "<<i+r<<endl; 
        printQ();
    }
    cout<<endl<<"-------------3、输出结果-------------"<<endl<<endl; 
    cout<<f[0];
    return 0;
}