oil倒油

skysun原创，转载请注明出处。

http://www.cnblogs.com/skysun

题目大意

一、 分油问题(oil.pas)。

设有大小不等的３个无刻度的油桶，分别能盛满X、Y、Z(都小于等于100)升油，初始时其中一个油桶盛满，另外两个为空。现在，要想分出T升油。分油时可把一个桶里的油倒入另外的桶中。设计一种以最少步骤的分油方案。

输入：以文件方式输入数据，格式为：

第一行：X  Y  Z {设一个油桶已装满油}

第二行：T {要分出的目标油量}

输出：所需要的步数{原题不是输出步数，由于评测问题……改简单了}

 

很明显是一道搜索题

方法一：bfs

一般来说，求最小步数都应该用宽搜来解，因为一旦出解就输出，并且一定是最优解；

宽搜需要注意一些赋初值问题，尤其是多遍搜索，不是改一个h，t就可以，最基本的布尔数组得改，这也一般忘不了

还有记录是否更新ans的变量，盛放队列里每个结点的步数的数组（只需F[0]=0就可以）

再就是，也是很重要的一点，就是需要用数组储存每个状态的3个油桶的油量，虽然很简单

但是很重要，不然的话，不利用数组的有序性，直接写转移，会繁琐很多

program sky;
const
   maxn    = 1000000;
   maxq    = 1000000;
var
   flag          : boolean;
   i,j,k      : longint;
   h,t,tar,ans,tp : longint;
   f          : array[0..maxq+1] of longint;
   v          : array[0..301,0..301,0..301] of boolean;
   q          : array[0..maxq+1,1..3] of longint;
   c          : array[0..3] of longint;
procedure bfs(x      : longint );
begin
   fillchar(v,sizeof(v),0);
   h:=1; t:=1; tp:=maxn; flag:=false; f[1]:=0;
   for i:=1 to 3 do
      if i=x then q[1,i]:=c[i] else q[1,i]:=0;
   while h<>t+1 do
   begin
      for i:=1 to 3 do
     for j:=1 to 3 do
        if (i<>j) and (q[h,i]>0) and (q[h,j]<c[j]) then
        begin
           inc(t); if t=maxq then t:=1;
           f[t]:=f[h]+1;
           for k:=1 to 3 do q[t,k]:=q[h,k];
           if c[j]-q[h,j]<q[h,i] then
           begin
          q[t,i]:=q[h,i]-(c[j]-q[h,j]);
          q[t,j]:=c[j];
           end else
           begin
          q[t,j]:=q[h,j]+q[t,i];
          q[t,i]:=0;
           end;
           if v[q[t,1],q[t,2],q[t,3]] then dec(t);
           if t=0 then t:=maxq-1;
           v[q[t,1],q[t,2],q[t,3]]:=true;
           if (q[t,1]=tar) or (q[t,2]=tar) or (q[t,3]=tar) then
           begin
          flag:=true;
          tp:=f[t];
          break;
           end;
        end;
      if flag then break;
      inc(h);
   end;
   if tp<ans then ans:=tp;
end; { bfs }

begin
   assign(input,'oil.in'); reset(input);
   assign(output,'oil.out'); rewrite(output);
   readln(c[1],c[2],c[3]);
   readln(tar);
   ans:=maxn;
   bfs(1);   bfs(2);   bfs(3);
   if ans=maxn then writeln('NO ANSWER!') else writeln(ans);
   close(input); close(output);
end.

 

方法二：迭代加深dfs

我不是很擅长打dfs，所以一开始就打的bfs，后来发现这也能过

不过最坑人的地方是，dfs这个过程里若开一个小数组而不是变量，速度会慢很多，

至于循环范围（迭代深度）完全是边测试边调整，直到不超时为止……

其实过程里可能有错，因为我是看的同学的程序，他的到1500都没问题，我的50就超时了，

若有大牛发现，麻烦指正，邮箱 leaf_and_me@126.com

这样也能出解

注意点和bfs差不多

program sky;
type
   aa = array[1..3] of longint;
var
   ans,tar : longint;
   b,c       : aa;
   v       : array[0..100,0..100,0..100] of boolean;

procedure print(x :longint );
begin
   writeln(x);
   close(input); close(output);
   halt;
end;
procedure dfs(b      : aa;x:longint );
var
   i,j,z : longint;
   d     : aa;
begin
   if x>ans then exit;
   if (b[1]=tar) or (b[2]=tar) or (b[3]=tar) then print(x);
   d:= b;
   for i:=1 to 3 do
      for j:=1 to 3 do
     if (i<>j) and (b[i]>0) and (b[j]<c[j]) then
     begin
        if b[i]>c[j]-b[j] then
        begin
           b[i]:=b[i]-(c[j]-b[j]);
           b[j]:=c[j];
        end else
        begin
           b[j]:=b[j]+b[i];
           b[i]:=0;
        end;
        if not v[b[1],b[2],b[3]] then
        begin
           v[b[1],b[2],b[3]]:=true;
           dfs(b,x+1);
        end;
        b:=d;
     end;
end;
begin
   assign(input,'oil.in'); reset(input);
   assign(output,'oil.out'); rewrite(output);
   readln(c[1],c[2],c[3]);
   readln(tar);
   for ans:=1 to 10 do
   begin
      b[1]:=c[1]; b[2]:=0; b[3]:=0;
      fillchar(v,sizeof(v),0); v[b[1],b[2],b[3]]:=true;
      dfs(b,0);
      b[1]:=0; b[2]:=c[2]; b[3]:=0; 
      fillchar(v,sizeof(v),0); v[b[1],b[3],b[3]]:=true;
      dfs(b,0);
      b[1]:=0; b[2]:=0; b[3]:=c[3];
      fillchar(v,sizeof(v),0); v[b[1],b[2],b[3]]:=true;
      dfs(b,0);
   end;
   writeln('NO ANSWER!');
   close(input); close(output);
end.

 

{最新修改：已改正，速度慢是因为v数组开的太大，fillchar太费时间，宽搜由于仅进行2-3次fillchar所以可以开大些}