poj 1821 Fence（单调队列）

题目链接：http://poj.org/problem?id=1821

题目分析来自：http://blog.csdn.net/tmeteorj/article/details/8684453

连续的N块木板，有K个粉刷匠，分别坐在第Si块木板前，每个粉刷匠不能移动位置，且最多能粉刷连续的Li块木板（必须包括Si或者不要该粉刷匠），每个粉刷匠粉刷一块木板可以得Pi块钱，求总共的最大利益。

题解：dp[i][j]代表前i个粉刷匠粉刷完成至多前j个木板的最大利益，状态转移有三种：

1、不需要第i个粉刷匠，即前i-1个粉刷匠完成前j个木板的工作：dp[i][j]=dp[i-1][j]

2、不需要粉刷第j块木板，即前i个粉刷匠完成前j-1个木板的工作：dp[i][j]=dp[i][j-1]

3、前i-1个粉刷匠粉刷到了第k块木板，然后第i个粉刷匠从第k+1开始一直粉刷到第j个木板：dp[i][j]=max(dp[i-1][k]+p[i]*(j-k))

前两种直接转移即可，第三种必须要用些优化才能节约时间dp[i-1][k]+p[i]*(j-k)=dp[i-1][k]- p[i]*k+p[i]*j，其中p[i]*j对固定dp[i][j]是固定的，即dp[i-1][k]-p[i]*k越大越好，所以可以用优先队列将所 有能够通过第三种方式更新dp[i][j]储存起来，能够更新需要满足两个条件k<Si且k+Li>=j，所以可以首先将[Si- Li，Si-1]区间的值预处理出来，并在每次选取优先队列中元素时判断它是否满足k+Li>=j即可（如果不满足，因为j是递增的，它以后也不会 满足，所以可以直接pop掉）

AC代码：

 1 #include<iostream>
 2 #include<algorithm>
 3 #include<cstdio>
 4 #include<cstring>
 5 using namespace std;
 6 struct TT
 7 {
 8     int len,cost,pos;
 9 }a[110];
10 int dp[110][16010];
11 int Q[16010];
12 bool cmp(TT m,TT n)
13 {
14     return m.pos<n.pos;
15 }
16 int main()
17 {
18    int m,n;
19     while(scanf("%d %d",&m,&n)!=EOF)
20     {
21         memset(dp,0,sizeof(dp));
22         for(int i=1;i<=n;i++)
23         {
24             scanf("%d %d %d",&a[i].len,&a[i].cost,&a[i].pos);
25         }
26         sort(a+1,a+n+1,cmp);
27         int base,top,ans = 0;
28         for(int i=1;i<=n;i++)
29         {
30             base = 0,top =1;
31             Q[base] = max(a[i].pos-a[i].len,0);
32             for(int j=1;j<=m;j++)
33             {
34                 dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
35                 if(j>=a[i].pos+a[i].len)//当前的位置加上能够粉刷的距离依然小于当前的距离
36                     continue;
37                     while(base<top && Q[base]+a[i].len<j)//去掉用过的
38                           base++;
39             //原型dp[i-1][k]+a[i].cost*(j-k)=dp[i-1][k]-a[i].cost*k+a[i].cost*j
40             //最后面是固定的大小
41             if(j<a[i].pos)//小于当前的位置
42             {
43                 int temp = dp[i-1][j] -  j*a[i].cost;//只需要寻找最大值
44                 while(base<top && dp[i-1][Q[top-1]] - Q[top-1] * a[i].cost<temp)
45                     top--;
46                 Q[top++] = j;
47                 continue;
48             }
49             dp[i][j] =max(dp[i][j],dp[i-1][Q[base]]+a[i].cost*(j-Q[base]));
50           }
51         }
52         printf("%d\n",dp[n][m]);
53     }
54     return 0;
55 }