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);

}