BZOJ 1003 [SPFA][DP]

1003: [ZJOI2006]物流运输
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
HINT

Source题意简单就是每个码头有几段时间无法停靠，共有n天每天都要从1码头到m码头，如果更换路线花费为k。
个人感觉因为更换路线不能保证答案最优，于是不能贪心。 于是需要DP
因为数据很小 所以 我们用一个cost[i][j]数组来存储 第 i 天 到 第 j 天 都选择同一条路走的花费。
用dp[i]来存储前 i 天的最优值 于是就得到了 方程

                                        dp[0] = 0
                            i : 1 to n; j : 0 to i - 1;
                        dp[i] = min(dp[i], dp[j] + cost[j + 1] + k)

最后因为第一次选择不需要k的花费所以输出dp[n] - 1

最后附代码：

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cstring>
#include <queue>
#define N 25
#define M N * N * 6
using namespace std;

struct edge {
  int to, key, next;
  edge(void) {}
  edge(int t, int k, int n):to(t), key(k), next(n) {}
}G[M];
struct node {
private:
  int a[110];
public:
  inline void fill(int b, int e) {
    for(int i = b; i <= e; i++) a[i] = 0;
  }
  inline bool can(int day) {return a[day];}
}p[N];
int head[N], dist[N], vis[N], cost[110][110], dp[110];
bool usable[N];
int cnt = 0, n, m, ans = 0, e, k, d, x, y, z;
queue<int> Q;

inline char get_char(void) {
  static char buf[100000], *p1 = buf, *p2 = buf;
  if (p1 == p2) {
    p2 = (p1 = buf) + fread(buf, 1, 100000, stdin);
    if (p1 == p2) return EOF;
  }
  return *p1++;
}
inline void read(int &x) {
  x = 0; char c;
  for(c = get_char(); c < '0' || c > '9'; c = get_char());
  for(; c >= '0' && c <= '9'; x = x * 10 + c - '0', c = get_char());
}
inline void add_edge(int from, int to, int key) {
    G[cnt] = edge(to, key, head[from]);
    head[from] = cnt++;
}
int spfa(int s, int t) {
  memset(dist, 0x3f, sizeof(dist));
  memset(vis, 0, sizeof(vis));
  dist[s] = 0; Q.push(s); vis[s] = 1;
  while(!Q.empty()) {
    int x = Q.front(); Q.pop(); vis[x] = 0;//spfa记得vis[x] = 0;
    for(int i = head[x]; i != -1; i = G[i].next) {
      edge &e = G[i];
      if (usable[e.to] && dist[e.to] > dist[x] + e.key) {
        dist[e.to] = dist[x] + e.key;
        if (!vis[e.to]) {
          vis[e.to] = 1; Q.push(e.to);
        }
      }
    }
  }
  return dist[t];
}

int main(void) {
  read(n); read(m); read(k); read(e);
  memset(dp, 0x3f, sizeof(dp));
  memset(head, -1, sizeof(head));
  memset(p, 1, sizeof(p));
  for(int i = 0; i < e; i++) {
    read(x); read(y); read(z);
    add_edge(x, y, z);
    add_edge(y, x, z);
  }
  read(d);
  for(int i = 0; i < d; i++) {
    read(x); read(y); read(z);
    p[x].fill(y, z);
  }
  for(int i = 1; i <= n; i++) {
    memset(usable, 1, sizeof(usable));
    for(int j = i; j <= n; j++) {
      for(int x = 1; x <= m; x++) usable[x] &= p[x].can(j);
      cost[i][j] = spfa(1, m) == 0x3f3f3f3f ? dist[m] : dist[m] * (j - i + 1);
    }
  }
  dp[0] = 0;
  for(int i = 1; i <= n; i++)
    for(int j = 0; j < i; j++) {
       dp[i] = min(dp[i], dp[j] + cost[j + 1][i] + k);
    }
  printf("%d\n", dp[n] - k);
  return 0;
}