hdu 4362(单调队列优化dp)

题意：有m个阶段，每个阶段都有n个龙珠，当在某一阶段选择一个龙珠，该阶段其他龙珠都会消失。给出两个m*n的矩阵，第一个矩阵表示消灭第i个阶段第j个龙珠的位置，第二个矩阵表示取第i个阶段第j个龙珠消耗的能量，同时当第x个位置到第个位置需要消耗 | y - x|的能量。问最后每个阶段取走一个龙珠最小的能量消耗。


解题思路：dp[i][j]表示第i个阶段选择第j个龙珠的最小耗能。

转移方程：dp[i][j] = min{dp[i-1][k] + abs(loc[i][j] - loc[i-1][k]) + cost[i][j]}，这里需要枚举的是i，j，k所以时间复杂度O(M*N*N)，这题数据好像卡得不是很紧，所以运气好点是可以AC的。不过不是正解。

这里可以利用单调队列。因为dp[i][j]=min{dp[i-1][k] - loc[i-1][k] + loc[i][j] + cost[i][j]}  （loc[i][j] > loc[i-1][k]）,所以可以只需要维护dp[i-1][k] - loc[i-1][k]即可。由于有绝对值，所以我这里用了两个单调队列，一个维护[b]dp[i-1][k] - loc[i-1][k]，另一个维护[b]dp[i-1][k]
+ loc[i-1][k]，但不知道什么原因WA了。。。[/b][/b]

先放在这里，等以后有思路了再改吧。。也希望路过我博客的哪位大神指点指点。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int maxn = 1005;
const int inf = 0x3f3f3f3f;
struct Node
{
int pos,cost;
}mat[55][maxn];
int n,m,x;
int dp[55][maxn],q1[maxn],q2[maxn],h1,h2,t1,t2;

bool cmp(Node a,Node b)
{
return a.pos < b.pos;
}

int main()
{
int t;
scanf("%d",&t);
while(t--)
{
scanf("%d%d%d",&m,&n,&x);
memset(dp,inf,sizeof(dp));
for(int i = 1; i <= m; i++)
for(int j = 1; j <= n; j++)
scanf("%d",&mat[i][j].pos);
for(int i = 1; i <= m; i++)
{
for(int j = 1; j <= n; j++)
scanf("%d",&mat[i][j].cost);
sort(mat[i]+1,mat[i]+1+n,cmp);<span style="white-space:pre">	</span>//排序为了保证进入队列时，位置是递增的
}
for(int i = 1; i <= n; i++)
dp[1][i] = abs(x - mat[1][i].pos) + mat[1][i].cost;
for(int i = 2; i <= m; i++)
{
h1 = h2 = t1 = t2 = 0;
for(int j = 1; j <= n; j++)	//将dp[i-1]层的最优状态放入单调队列
{
while(h1 < t1 && dp[i-1][j] - mat[i-1][j].pos <= dp[i-1][q1[t1-1]] - mat[i-1][q1[t1-1]].pos) t1--;
q1[t1++] = j;
while(h2 < t2 && dp[i-1][j] + mat[i-1][j].pos <= dp[i-1][q2[t2-1]] + mat[i-1][q2[t2-1]].pos) t2--;
q2[t2++] = j;
}
for(int j = 1; j <= n; j++)
{
while(h1 < t1 && mat[i][j].pos < mat[i-1][q1[h1]].pos) h1++;
dp[i][j] = dp[i-1][q1[h1]] + mat[i][j].pos + mat[i][j].cost;
while(h2 < t2 && mat[i][j].pos >= mat[i-1][q2[h2]].pos) h2++;
dp[i][j] = min(dp[i][j],dp[i-1][q2[h2]] - mat[i][j].pos + mat[i][j].cost);
}
}
int ans = inf;
for(int i = 1; i <= n; i++)
ans = min(ans,dp[m][i]);
printf("%d\n",ans);
}
return 0;
}

PS: 仔细想了想，确实自己的单调队列有问题，因为我是先把所有的dp[i-1]层的送入队列，就会出现问题，在我后面的循环枚举dp[i]层的时候一些有效位置可能不在队列里。所以参考了别人的代码，还是要先枚举dp[i][j]中的j，保证我先选择第j个位置，由于已经是有序的了，所以就直接找不大于mat[i][j].pos位置的最小值即可，同理，由于有绝对值，所以还要反着循环一次。

详细的过程看代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int maxn = 1005;
const int inf = 0x3f3f3f3f;
struct Node
{
int pos,cost;
}mat[55][maxn];
int n,m,x;
int dp[55][maxn],q1[maxn],q2[maxn],h1,h2,t1,t2;

bool cmp(Node a,Node b)
{
return a.pos < b.pos;
}

int main()
{
int t;
scanf("%d",&t);
while(t--)
{
scanf("%d%d%d",&m,&n,&x);
memset(dp,inf,sizeof(dp));
for(int i = 1; i <= m; i++)
for(int j = 1; j <= n; j++)
scanf("%d",&mat[i][j].pos);
for(int i = 1; i <= m; i++)
{
for(int j = 1; j <= n; j++)
scanf("%d",&mat[i][j].cost);
sort(mat[i]+1,mat[i]+1+n,cmp);
}
for(int i = 1; i <= n; i++)
dp[1][i] = abs(x - mat[1][i].pos) + mat[1][i].cost;
for(int i = 2; i <= m; i++)
{
int k = 1, Min = inf;
for(int j = 1; j <= n; j++)
{
while(k <= n && mat[i][j].pos >= mat[i-1][k].pos)
{
Min = min(Min,dp[i-1][k] - mat[i-1][k].pos);
k++;
}
dp[i][j] = Min + mat[i][j].pos + mat[i][j].cost;
}
k = n, Min = inf;
for(int j = n; j >= 1; j--)
{
while(k >= 1 && mat[i][j].pos <= mat[i-1][k].pos)
{
Min = min(Min,dp[i-1][k] + mat[i-1][k].pos);
k--;
}
dp[i][j] = min(dp[i][j],Min - mat[i][j].pos + mat[i][j].cost);
}
}
int ans = inf;
for(int i = 1; i <= n; i++)
ans = min(ans,dp[m][i]);
printf("%d\n",ans);
}
return 0;
}