BZOJ - 1003【dp+最短路】

1003: [ZJOI2006]物流运输

Time Limit: 10 Sec  Memory Limit: 162 MB
Submit: 7062  Solved: 2929
[Submit][Status][Discuss]

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
//前三天走1-4-5，后两天走1-3-5，这样总成本为(2+2)*3+(3+2)*2+10=32

题意：有个任务需要你n天完成，每天都要从码头1传送到码头m，每一天都会有一部分码头关闭不能用。
            如果你i天和i-1天走的路线不一样，那你就需要多花费K。现在让你求传送完任务可以的最小花费。

题解：数据范围很小，预处理出每一段i->j的最短路，则这一段的花费就是 dis[m]*(j-i+1);

            用dp[i]表示前i天任务已经完成的最小花费。易得 dp[i] = min(dp[i], dp[j] + cost[j+1][i] + k)；

            初始化 dp[i] = cost[1][i]。

            ps：题目真是坑啊，n和m给的一样，然后dijk那里一个m写成n，错了一天QAQ

代码：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <bitset>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <list>
#include <set>
#include <map>
#define rep(i,a,b) for(int i = a;i <= b;++ i)
#define per(i,a,b) for(int i = a;i >= b;-- i)
#define mem(a,b) memset((a),(b),sizeof((a)))
#define FIN freopen("in.txt","r",stdin)
#define FOUT freopen("out.txt","w",stdout)
#define IO ios_base::sync_with_stdio(0),cin.tie(0)
#define mid ((l+r)>>1)
#define ls (id<<1)
#define rs ((id<<1)|1)
#define N 100+5
#define INF 0x3f3f3f3f
#define INFF 0x3f3f3f3f3f3f3f
typedef long long ll;
const ll mod = 20071027;
const ll eps = 1e-12;
using namespace std;
 
int n,m,k,e,u,v,c,t,p,a,b;
int dis[N],cost[N][N],dp[N];
bool take[25][N],vis[N];
vector <pair<int, int> > G[N];
 
struct Node{
    int id,c;
    Node(int _id,int _c)    { id = _id; c = _c; }
    bool operator < (const Node &r) const{
        return c > r.c;
    }
};
int dijk(int l,int r){
    mem(vis, false);
    mem(dis, INF);
 
    rep(i, l, r){
        rep(j, 2, m){
            if(take[j][i])  vis[j] = true;
        }
    }
 
    priority_queue <Node> Q;
    dis[1] = 0;
    Q.push(Node(1, 0));
    while(!Q.empty()){
        Node res = Q.top();
        Q.pop();
 
        int u = res.id;
        if(vis[u])  continue;
        vis[u] = true;
 
        rep(i, 0, (int)G[u].size()-1){
            int to = G[u][i].first;
            int c = G[u][i].second;
 
            if(!vis[to] && dis[u]+c < dis[to]){
                dis[to] = dis[u]+c;
                Q.push(Node(to, dis[to]));
            }
        }
    }
    if(dis[m] == INF)   return INF;
    else
        return dis[m]*(r-l+1);
}
int main()
{IO;
    //FIN;
    while(cin >> n >> m >> k >> e){
        rep(i, 0, m)    G[i].clear();
        mem(take, false);
        mem(cost, 0);
        mem(dp, 0x3f);
 
        rep(i, 1, e){
            cin >> u >> v >> c;
            G[u].push_back(make_pair(v, c));
            G[v].push_back(make_pair(u, c));
        }
        cin >> t;
        while(t--){
            cin >> p >> a >> b;
            rep(i, a, b)    take[p][i] = true;
        }

        rep(i, 1, n){
            rep(j, 1, n)    cost[i][j] = dijk(i, j);    
        }
        rep(i, 1, n){
            dp[i] = cost[1][i];
            rep(j, 0, i-1)
                dp[i] = min(dp[i], dp[j]+k+cost[j+1][i]);
        }
        cout << dp[n] << endl;
    }
    return 0;
}