• 【BZOJ1003】物流运输(动态规划,最短路)


    【BZOJ1003】物流运输(动态规划,最短路)

    题面

    Description

    物流公司要把一批货物从码头A运到码头B。由于货物量比较大,需要n天才能运完。货物运输过程中一般要转停好几个码头。物流公司通常会设计一条固定的运输路线,以便对整个运输过程实施严格的管理和跟踪。由于各种因素的存在,有的时候某个码头会无法装卸货物。这时候就必须修改运输路线,让货物能够按时到达目的地。但是修改路线是一件十分麻烦的事情,会带来额外的成本。因此物流公司希望能够订一个n天的运输计划,使得总成本尽可能地小。

    Input

    第一行是四个整数n(1<=n<=100)、m(1<=m<=20)、K和e。n表示货物运输所需天数,m表示码头总数,K表示每次修改运输路线所需成本。
    接下来e行每行是一条航线描述,包括了三个整数,依次表示航线连接的两个码头编号以及航线长度(>0)。其中码头A编号为1,码头B编号为m。单位长度的运输费用为1。航线是双向的。
    再接下来一行是一个整数d,后面的d行每行是三个整数P( 1 < P < m)、a、b(1 < = a < = b < = n)。表示编号为P的码头从第a天到第b天无法装卸货物(含头尾)。同一个码头有可能在多个时间段内不可用。但任何时间都存在至少一条从码头A到码头B的运输路线。

    Output

    包括了一个整数表示最小的总成本。总成本 = n天运输路线长度之和 + K * 改变运输路线的次数。

    Sample Input

    5 5 10 8
    1 2 1
    1 3 3
    1 4 2
    2 3 2
    2 4 4
    3 4 1
    3 5 2
    4 5 2
    4
    2 2 3
    3 1 1
    3 3 3
    4 4 5

    Sample Output

    32

    Hint

    样例提示:
    前三天走1-4-5,后两天走1-3-5,这样总成本为(2+2) * 3+(3+2) * 2+10=32

    题解

    首先,如果不考虑路径的问题,如果告诉你每一段时间的费用,让你(DP),这是很显然,很简单的。
    考虑到数据范围如此之小,那么,我们就直接暴力(SPFA)预处理每一段时间的费用,然后(O(n^2)DP)即可

    #include<iostream>
    #include<cstdio>
    #include<cstdlib>
    #include<cstring>
    #include<cmath>
    #include<algorithm>
    #include<set>
    #include<map>
    #include<vector>
    #include<queue>
    using namespace std;
    #define MAX 120
    inline int read()
    {
    	int x=0,t=1;char ch=getchar();
    	while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
    	if(ch=='-')t=-1,ch=getchar();
    	while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
    	return x*t;
    }
    struct Line
    {
    	int v,next,w;
    }e[MAX*200];
    int h[MAX],cnt=1,n,m,K,E;
    bool vis[MAX];
    bool Use[200][30],uu[50];
    int Dis[200][200],dis[50];
    long long f[200];
    inline void Add(int u,int v,int w)
    {
    	e[cnt]=(Line){v,h[u],w};
    	h[u]=cnt++;
    }
    inline bool check(int p,int l,int r)
    {
    	for(int i=l;i<=r;++i)
    		if(Use[i][p])
    			return false;
    	return true;
    }
    inline void SPFA(int l,int r)
    {
    	for(int i=1;i<=m;++i)uu[i]=check(i,l,r);
    	memset(dis,63,sizeof(dis));dis[1]=0;
    	memset(vis,0,sizeof(vis));vis[1]=true;
    	queue<int> Q;Q.push(1);
    	while(!Q.empty())
    	{
    		int u=Q.front();Q.pop();
    		for(int i=h[u];i;i=e[i].next)
    		{
    			int v=e[i].v;
    			if(!uu[v])continue;
    			int w=e[i].w+dis[u];
    			if(dis[v]>w)
    			{
    				dis[v]=w;
    				if(!vis[v])
    				{
    					vis[v]=true;
    					Q.push(v);
    				}
    			}
    		}
    		vis[u]=false;
    	}
    	Dis[l][r]=dis[m];
    }
    int main()
    {
    	n=read();m=read();K=read();E=read();
    	for(int i=1,u,v,w;i<=E;++i)
    	{
    		u=read();v=read();w=read();
    		Add(u,v,w);Add(v,u,w);
    	}
    	int D=read();
    	for(int i=1;i<=D;++i)
    	{
    		int P=read(),a=read(),b=read();
    		for(int j=a;j<=b;++j)Use[j][P]=true;
    	}
    	for(int i=1;i<=n;++i)
    		for(int j=i;j<=n;++j)
    			SPFA(i,j);
    	for(int i=1;i<=n;++i)f[i]=1e11;
    	f[0]=-K;
    	for(int i=1;i<=n;++i)
    		for(int j=0;j<i;++j)
    			f[i]=min(f[i],f[j]+1ll*Dis[j+1][i]*(i-j)+K);
    	printf("%lld
    ",f[n]);
    	return 0;
    }
    
    
  • 相关阅读:
    super返回不过来
    对象与内存控制
    java数组学习
    careercup-递归和动态规划 9.8
    careercup-递归和动态规划 9.7
    careercup-递归和动态规划 9.6
    careercup-递归和动态规划 9.5
    careercup-递归和动态规划 9.4
    careercup-递归和动态规划 9.3
    careercup-递归和动态规划 9.2
  • 原文地址:https://www.cnblogs.com/cjyyb/p/7764009.html
Copyright © 2020-2023  润新知