BZOJ 2442 [Usaco2011 Open]修剪草坪：单调队列优化dp

题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=2442

题意：

　　有n个数a[i]从左到右排成一排。

　　你可以任意选数，但是连续的数不能超过k个。

　　问你最大的选数之和。

题解：

　　表示状态：

　　　　dp[i]表示考虑了第i个数的最大之和。

　　

　　找出答案：

　　　　ans = dp[n]

　　　　将所有的数都考虑过了

　　如何转移：

　　　　对于a[i]，要么选，要么不选。

　　　　（1）如果不选，则dp[i] = max dp[i-1]。

　　　　（2）如果选，则最多往前选k个数，且在i-k的位置一定不能选。

　　　　　　所以：

　　　　　　　　dp[i] = max dp[j] + sum(j+2,i)　(i-k-1 <= j <= i-2)

　　　　　　变成前缀和的形式：

　　　　　　　　dp[i] = max dp[j] + sum[i] - sum[j+1]

　　　　　　也就是：

　　　　　　　　dp[i] = max(dp[j] - sum[j+1]) + sum[i]

　　　　　　对于dp[j] - sum[j+1]这一部分，可以用单调队列优化。

　　边界条件：

　　　　dp[0] = 0

　　　　q[head++] = Node(-1,0)

　　　　-1为假想的位置，只是为了在n == 1的时候能够用到0这个值。

AC Code:

 // state expression:
 // dp[i] = max efficiency
 // i: selected ith cow
 //
 // find the answer:
 // max dp[n]
 //
 // transferring:
 // dp[i] = max(dp[j] + sum(j+2,i), dp[i-1])
 // dp[i] = max(dp[j] + sum[i] - sum[j+1], dp[i-1])
 // dp[i] = max(dp[j] - sum[j+1] + sum[i], dp[i-1])
 // i-k-1 <= j <= i-2
 //
 // boundary:
 // dp[0] = 0
 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 #define MAX_N 100005

 using namespace std;

 struct Node
 {
     int idx;
     long long val;
     Node(int _idx,long long _val)
     {
         idx=_idx;
         val=_val;
     }
     Node(){}
 };

 int n,k;
 int head=;
 int tail=;
 int e[MAX_N];
 long long dp[MAX_N];
 long long sum[MAX_N];
 Node q[MAX_N];

 void read()
 {
     cin>>n>>k;
     sum[]=;
     for(int i=;i<=n;i++)
     {
         cin>>e[i];
         sum[i]=sum[i-]+e[i];
     }
 }

 void solve()
 {
     dp[]=;
     q[tail++]=Node(-,);
     for(int i=;i<=n;i++)
     {
         if(i>=)
         {
             while(head<tail && q[tail-].val<dp[i-]-sum[i-]) tail--;
             q[tail++]=Node(i-,dp[i-]-sum[i-]);
         }
         while(head<tail && q[head].idx<i-k-) head++;
         dp[i]=max(q[head].val+sum[i],dp[i-]);
     }
 }

 void print()
 {
     cout<<dp[n]<<endl;
 }

 int main()
 {
     read();
     solve();
     print();
 }