Acwing P298 围栏

Analysis

①首先将所有粉刷匠,按照必须刷的小木块Si从小到大排序.

上面这个操作为了保证我们可以顺序处理.

②我们可以设f[i][j]表示为,前i个粉刷匠,刷了前i个木块.可以有些木块选择不刷

状态确定好了后,我们分两种情况讨论.

第i个粉刷匠不工作,那么
f[i][j]=f[i−1][j]
第j个木板不刷,那么
f[i][j]=f[i][j−1]

.

结合上面的讨论,我们不难发现,
f[i][j]=max(f[i−1][j],f[i][j−1])
接下来的问题就是,如果说粉刷匠工作,而且也还刷第j个木块,那么我们不得不仔细思考.

对于一个粉刷匠而言,如果说聘请他工作,那么显然我们有几个条件.

他粉刷的区间长度,至少为1,最多为Li.
他粉刷的区间内必须包括Si这个小木块.
粉刷区间左端点,必须小于等于Si
综上所述我们不妨设置一个粉刷匠粉刷的区域为[k+1,j]
那么根据上面所说的条件,我们将它转换为数学计算机语言,如下面这个式子所示.
k+1≤si≤j 1≤j−(k+1)≤Li K≤Si−1
综上所述,我们可以将状态转移方程一步步出来.

f[i][j]=maxf[i−1][j],f[i][j−1],f[i][j] f[i][j]=maxj−Li≤k≤Si−1(f[i][j],f[i−1][k]+Pi∗(j−(k+1)+1)) 
得出了一个朴素的状态转移方程,我们不得不进行转换一下.

f[i][j]=maxj−Li≤k≤Si−1(f[i][j],f[i−1][k]+Pi∗(j−(k+1)+1)) 
我们不妨去掉一个括号.

f[i][j]=maxj−Li≤k≤Si−1(f[i][j],f[i−1][k]+Pi∗(j−k))

上面的一次次变换,让我们发现了,如果说我们要求的f[i][j]要选取到最大值,那么我们核心目标点就是让Max函数内部的

f[i−1][k]−Pi∗k
尽量地大.

尽然如此的话,我们发现K的取值是一个范围,但是我们并不关心这个范围内所有的数值,我们唯一的关心点就是这个范围的最大值.也就是最大的f[i−1][k]
一个区间,最大值,这些关键字眼,不得不让我们思考一下单调队列这种优秀的数据结构.因此我们把中心放到单调队列上面.

单调队列的核心要点,就是生存能力的判断.

我们逐步入手,下面给出几个判断依据.

我们设当前有两个点,一个是k1,另外一个是k2.

我们发现当前点,如果说k1<k2,也就是k2后出现.

我们将k1,k2代入到我们的状态转移方程中的决定部分.

那么将k1代入

f[i−1][k1]−Pi∗k1
再将k2代入其中

f[i−1][k2]−Pi∗k2
我们发现如果说我们再满足下面这个条件的话,那么k2一定优于k1

于是可以用单调队列维护了

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #define int long long
 #define maxn 16000+10
 #define maxm 1000+10
 using namespace std;
 inline int read()
 {
     int x=;
     bool f=;
     char c=getchar();
     for(; !isdigit(c); c=getchar()) if(c=='-') f=;
     for(; isdigit(c); c=getchar()) x=(x<<)+(x<<)+c-'';
     if(f) return x;
     return -x;
 }
 inline void write(int x)
 {
     if(x<){putchar('-');x=-x;}
     if(x>)write(x/);
     putchar(x%+'');
 }
 int n,m;
 int deque[maxn];
 int dp[maxm][maxn];
 struct node
 {
     int l,p,s;
 }x[maxm];
 inline bool cmp(node x,node y)
 {
     return x.s<y.s;
 }
 inline int calc(int i,int k)
 {
     return dp[i-][k]-x[i].p*k;
 }
 signed main()
 {
     n=read();m=read();
     for(int i=;i<=m;i++)
     {
         x[i].l=read();x[i].p=read();x[i].s=read();
     }
     sort(x+,x+m+,cmp);
     for(int i=;i<=m;i++)
     {
         int head=,tail=;
         for(int k=max(0ll,x[i].s-x[i].l);k<=x[i].s-;k++)
         {
             while(head<=tail&&calc(i,deque[tail])<=calc(i,k)) tail--;
             deque[++tail]=k;
         }
         for(int j=;j<=n;j++)
         {
             dp[i][j]=max(dp[i-][j],dp[i][j-]);
             if(j>=x[i].s)
             {
                 while(head<=tail&&deque[head]<j-x[i].l) head++;
                 if(head<=tail)
                     dp[i][j]=max(dp[i][j],calc(i,deque[head])+x[i].p*j);
             }
         }
     }
     write(dp[m][n]);
     return ;
 }

请各位大佬斧正（反正我不认识斧正是什么意思）