BZOJ1003物流運輸 DP + SPFA

@[DP, SPFA]

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

Sample Output

Solution

傻題...

看起來很可怕, 然而數據範圍實在是良心...

SPFA + 暴力 + DP即可

暴力枚举第$i$天到第$j$天（不改线路）的最小费用

然後DP

\[f(i) = min(f(i), f(j) + cost(j + 1, i) * (i - j + 1) + K)
\]

这样也能过……

#include<cstdio>
#include<cctype>
#include<cstring>
#include<algorithm>
#include<climits>
using namespace std;
inline int read()
{
    int x = 0, flag = 1;;
    char c;
    while(! isdigit(c = getchar()))
        if(c == '-')
            flag *= - 1;
    while(isdigit(c))
        x = x * 10 + c - '0', c = getchar();
    return x * flag;
}
void println(int x)
{
    if(x < 0)
        putchar('-'), x *= - 1;
    if(x == 0)
        putchar('0');
    int ans[10], top = 0;
    while(x)
        ans[top ++] = x % 10, x /= 10;
    for(; top; top --)
        putchar(ans[top - 1] + '0');
    putchar('\n');
}
const int N = 1 << 7, M = 1 << 5, E = M * M;
int top;
int head[M];
struct Edge
{
	int v, w, next;
}G[E << 1];
void add_edge(int u, int v, int w)
{
	G[top].v = v, G[top].w = w, G[top].next = head[u];
	head[u] = top ++;
}
const int D = N * M;
struct Modi
{
	int p, L, R;
}oper[D];
int flag[M];
int Q[M * E];
int dis[M];
int inQ[M];
int SPFA(int s, int t)
{
	Q[0] = s;
	int L = 0, R = 1;
	memset(dis, 127, sizeof(dis));
	dis[s] = 0;
	memset(inQ, 0, sizeof(inQ));
	while(L < R)
	{
		for(int i = head[Q[L]]; i != - 1; i = G[i].next)
			if(dis[Q[L]] + G[i].w < dis[G[i].v] && ! flag[G[i].v])
			{
				dis[G[i].v] = dis[Q[L]] + G[i].w;
				if(! inQ[G[i].v])
					inQ[G[i].v] = 1, Q[R ++] = G[i].v;
			}
		inQ[Q[L ++]] = 0;	//忘了標記出隊, 結果調試了將近一個小時..還要上極限數據才發現錯誤
	}
	if(dis[t] > (int)2e9)
		return - 1;
	return dis[t];	//漏了這一句, 結果調完了剩下的整個晚上QAQ
}
int cost[N][N];
int f[N];
const int oo = INT_MAX;
int main()
{
	#ifndef ONLINE_JUDGE
	freopen("BZOJ1003.in", "r", stdin);
	freopen("BZOJ1003.out", "w", stdout);
	#endif
	int n = read(), m = read(), K = read(), e = read();
	top = 0;
	memset(head, - 1, sizeof(head));
	for(int i = 0; i < e; i ++)
	{
		int u = read(), v = read(), w = read();
		add_edge(u, v, w);
		add_edge(v, u, w);
	}
	int d = read();
	for(int i = 0; i < d; i ++)
		oper[i].p = read(), oper[i].L = read(), oper[i].R = read();
	for(int i = 1; i <= n; i ++)
		for(int j = i; j <= n; j ++)
		{
			memset(flag, 0, sizeof(flag));
			for(int k = 0; k < d; k ++)
				if(oper[k].L <= j && oper[k].R >= i)
					flag[oper[k].p] = 1;
			cost[i][j] = SPFA(1, m);
		}
	memset(f, 127, sizeof(f));
	f[0] = 0;
	for(int i = 1; i <= n; i ++)
		for(int j = 0; j < i; j ++)
		{
			if(cost[j + 1][i] == - 1)
				continue;
			f[i] = min(f[i], cost[j + 1][i] * (i - j) + f[j] + K);
		}
	println(f[n] - K);
}