从Tyvj1061 Mobile Service 看DP 来源与优化

Decsription

一个公司有三个移动服务员。如果某个地方有一个请求，某个员工必须赶到那个地方去（那个地方没有其他员工），某一时刻只有一个员工能移动。被请求后，他才能移动，不允许在同样的位置出现两个员工。从p到q移动一个员工，需要花费c(p,q)。这个函数没有必要对称，但是c(p,p)=0。公司必须满足所有的请求。目标是最小化公司花费。

Input Format

第一行有两个整数L,N(3<=L<=200, 1<=N<=1000)。L是位置数；N是请求数。每个位置从1到L编号。下L行每行包含L个非负整数。第i+1行的第j个数表示c(i,j) ，并且它小于2000。最后一行包含N个数，是请求列表。一开始三个服务员分别在位置1，2，3。

Input Sample

5 9
0 1 1 1 1
1 0 2 3 2
1 1 0 4 1
2 1 5 0 1
4 2 3 4 0
4 2 4 1 5 4 3 2 1

Output Format

一个数M，表示最小服务花费。

Output Sample

5

---

我做题的思路，总是先想一个大致方向，然后简化，转化。

原始

最先想到的，就是搜索。

记需要请求队列为a[i]

代价在c[i,j]中

dfs(1，a[1]，2，3，c[1,a[1]])

dfs(1，1，a[1]，3，c[2,a[1]])

dfs(1，1，2，a[1]，c[3,a[1]])

dfs(l,x,y,z,p);

l是处理的请求数，x,y,z分别是三个服务员所在位置，p是代价和。

然后就是骇人听闻的时间复杂度。

优化1，减维

然而会发现，在每一层的递归中，其中一维是不许要传递，直接可以计算知道的。

比如

dfs(1，a[1]，2，3，c[1,a[1]])

dfs(l,x,y,z,p){

x,y,z中必然有一个是a[l]！

}

那好，我们就可以减去一维了。

dfs(l,x,y,p){

dfs(l+1,x,y,p+c[a[l],a[l+1]]);
dfs(l+1,a[l],y,p+c[x,a[l+1]]);
dfs(l+1,x,a[l],p+c[y,a[l+1]]);

}

优化2，记忆化

显然，如果是说

dfs（l，x，y，p）{

f[l,x,y]用作记录的话，如果现在的p已经大于f了，那么再往下搜已经没有意义了。可以减枝。

}

但是f的空间复杂度是NL^2，内存超的很严重。

先贴上一个代码

var
	l,n,i,j,ans:longint;
	c:array[1..200,1..200]of longint;
	a:array[1..1000] of longint;
	f:array[1..1000,1..200,1..200] of longint;
procedure work(l,x,y,p:longint);
begin
	if p<f[l,x,y] then f[l,x,y]:=p else exit;
	if l=n then begin
		if p<ans then ans:=p;
		exit;
	end;
	work(l+1,x,y,p+c[a[l],a[l+1]]);
	work(l+1,a[l],y,p+c[x,a[l+1]]);
	work(l+1,x,a[l],p+c[y,a[l+1]]);
end;

begin
	readln(l,n);
	ans:=maxlongint;
	fillchar(f,sizeof(f),127);
	for i:=1 to l do
		for j:=1 to l do
			read(c[i,j]);
	for i:=1 to n do read(a[i]);
	work(1,1,2,c[3,a[1]]);
	work(1,1,3,c[2,a[1]]);
	work(1,2,3,c[1,a[1]]);
	writeln(ans);
end.

优化3，转变搜索为动规，再减一维。

但是仔细想来可以知道，f[l,x,y]的运算只会和f[l-1,...]有关，没有后效性，那么f很多的空间在用过一次之后就完全没有用了。浪费！

但是DFS，会在深度上纵横，f在各个l的判断有会非常多。所以l是必定要保存下来的一维。

DFS不行，那么BFS呢？。。。。未免复杂了。

既然搜索的递推关系都已经这么明显了，条件又这么成熟了（无后效性，最优子结构），还不用动规？！！！

动规。有一种是当前的状态值是由曾经计算过的状态值 经过运算而来；还有一种是当前的状态主动的运算，给未运算过的状态赋值。

这次明显是第二种好用。

变成动规之后，上面的f的l一维就可以减去了，只要用循环数组就可以啦。

贴上代码：

type
num=array[0..200,0..200] of longint;
var
	l,n,i,j,k,ans:longint;
	c:array[1..200,1..200]of longint;
	p1,p2:longint;
	f1,f2:num;
function min(a,b:longint):longint;
begin
if a<b then exit(a) else exit(b);
end;
begin
	readln(l,n);
	for i:=1 to l do
		for j:=1 to l do
			read(c[i,j]);
        fillchar(f1,sizeof(f1),127);
        read(p1);
	f1[1,2]:=c[3,p1];
	f1[1,3]:=c[2,p1];
	f1[2,3]:=c[1,p1];
	for i:=1 to n-1 do begin
                read(p2);
		fillchar(f2,sizeof(f2),127);
		for j:=1 to l do
		for k:=1 to l do begin
			f2[j,k]:=min(f2[j,k],f1[j,k]+c[p1,p2]);
			f2[j,p1]:=min(f2[j,p1],f1[j,k]+c[k,p2]);
			f2[p1,k]:=min(f2[p1,k],f1[j,k]+c[j,p2]);
		end;
		f1:=f2;
		p1:=p2;
	end;
        ans:=maxlongint;
        for i:=1 to l do
        for j:=1 to l do
        ans:=min(ans,f2[i,j]);
        writeln(ans);
end.

至此，时间是 O（NL^2）

空间是O(L^2)

就基本能过了。