【单调性dp】Vijos 1243

最新推荐文章于 2019-08-25 20:52:02 发布

CN_swords

最新推荐文章于 2019-08-25 20:52:02 发布

阅读量326

点赞数

CC 4.0 BY-SA版权

分类专栏：动态规划

本文链接：https://blog.youkuaiyun.com/qq_33199236/article/details/78554521

动态规划专栏收录该内容

82 篇文章

订阅专栏

本文介绍了一种解决多个机器人在有限连续工作步数限制下完成产品生产的最短时间问题的算法。通过动态规划与单调队列优化，实现了高效求解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

https://vijos.org/p/1243

//#pragma comment(linker, "/STACK:102400000,102400000")
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
typedef long long LL;
const int INF = 0x3f3f3f3f;
/*
一个产品的生产有m个步骤，一共n个机器人。机器人i完成步骤j的时间为T[i][j]，
每次当产品从一个机器人那里移动到另一个机器人那里需要时间K，
每个机器人不能持续工作L个步骤。问最少能在多少时间内完成。

dp[i][j] = min(dp[xi][xj]-pre[i][xj])+pre[i][j]+k;(xi!=i)(xj>=j-L&&xj<j)
单调队列优化
*/
int m,n,k,L;
int ma[6][100010];
int pre[6][100010];
int dp[6][100010];
int que[6][500010];
int qid[6][500010];
int head[6],tail[6];
int main()
{
    scanf("%d%d%d%d",&m,&n,&k,&L);
    for(int i=1; i<=n; i++)
    {
        pre[i][0] = 0;
        for(int j=1; j<=m; j++)
        {
            scanf("%d",&ma[i][j]);
            pre[i][j]=pre[i][j-1]+ma[i][j];
        }
    }
    memset(dp,INF,sizeof(dp));
    for(int i=1; i<=n; i++)
        head[i]=1,tail[i]=0;
    for(int j=0; j<=m; j++)
    {
        for(int i=1; i<=n; i++){
            while(head[i]<=tail[i] && j-L>qid[i][head[i]])
                head[i]++;
            if(j==0) dp[i][0]=-k;
            else if(head[i]>tail[i]) dp[i][j]=INF;
            else    dp[i][j]=que[i][head[i]]+pre[i][j]+k;
//            printf("%d ",dp[i][j]);
        }
//        puts("");
        for(int i=1; i<=n; i++)
            for(int f=1; f<=n; f++)
                if(f!=i) {
//                    printf("f=%d head=%d\n",f,que[f][head[f]]);
                    while(head[f]<=tail[f] && dp[i][j]-pre[f][j]<que[f][tail[f]])
                        tail[f]--;
                    que[f][++tail[f]]=dp[i][j]-pre[f][j];
                    qid[f][tail[f]]=j;
                }
    }
    int mi = INF;
    for(int i=1; i<=n; i++)
        mi = min(mi,dp[i][m]);
    printf("%d\n",mi);
    return 0;
}