help me

给个BFS题目你研究研究``骑士游历问题
const maxn=15;
type arraytype=array [1..maxn*maxn,1..maxn*maxn] of byte;
var d,i,j,k,m,n,mind,nextp,t:longint;
    p:array [1..maxn*maxn,1..2] of longint;
    g:arraytype;
    r:array [1..maxn,1..maxn] of longint;
    v,q:array [1..maxn*maxn] of longint;
procedure bfs(k:longint);
var i,head,tail:longint;
begin
     q[1]:=k;
     head:=1;
     tail:=1;
     v[1]:=1;
     while head<=tail do
     begin
          inc(t);
          k:=q[head];
          r[p[k,1],p[k,2]]:=t;
          for i:=1 to n*n do
              if (g[k,i]=1) and (v[i]=0) then
                 begin
                      inc(tail);
                      q[tail]:=i;
                      v[q[tail]]:=1
                 end;
          inc(head)
     end
end;

begin
     write('Input n:');
     readln(n);
     k:=0;
     for i:=1 to n do
         for j:=1 to n do
         begin
              inc(k);
              p[k,1]:=i;
              p[k,2]:=j
         end;
     fillchar(g,sizeof(g),0);
     for i:=1 to n*n-1 do
         for j:=i+1 to n*n do
             if abs((p[i,1]-p[j,1])*(p[i,2]-p[j,2]))=2
                then begin g[i,j]:=1; g[j,i]:=1 end;
     fillchar(v,sizeof(v),0);
     t:=0;
     bfs(1);
     for i:=1 to n do
     begin
          for j:=1 to n do write(r[i,j]:4);
          writeln
     end;
end.

不会~

偶也正在研究中哈``

我也不会！·￥·#%￥·#呵呵·￥·

同样的不会。。。我只会一点点的深搜。。。

哎我忽然觉得这几天说'不会'这两字都说了好几次了~~
看来还得更努力了~~

蛮好啊,每一个不会都是一个动力呢!

二、深度搜索与广度搜索
    深度搜索与广度搜索的控制结构和产生系统很相似，唯一的区别在于对扩展节点选取上。由于其保留了所有的前继节点，所以在产生后继节点时可以去掉一部分重复的节点，从而提高了搜索效率。这两种算法每次都扩展一个节点的所有子节点，而不同的是，深度搜索下一次扩展的是本次扩展出来的子节点中的一个，而广度搜索扩展的则是本次扩展的节点的兄弟节点。在具体实现上为了提高效率,所以采用了不同的数据结构.
[广度搜索]
<Type>
   Node(节点类型)＝Record
     Situtation:TSituation（当前节点状态）;
     Level:Integer(当前节点深度);
     Last :Integer(父节点);
   End
<Var>
   List(节点表):Array[1..Max(最多节点数)] of Node(节点类型);
   open(总节点数):Integer;
　 close(待扩展节点编号):Integer;
   New-S:TSituation;(新节点)
<Init>
   List<-0;
   open<-1;
   close<-0;
   List[1].Situation<- 初始状态;
   List[1].Level:=1;
   List[1].Last:=0;
<Main Program>
   While (close<open(还有未扩展节点)) and
         (open<Max(空间未用完)) and
         (未找到目标节点) do
   Begin
　　     close:=close+1;
         For I:=1 to TotalExpendMethod do（扩展一层子节点）
         Begin
           New-S:=ExpendNode(List[close].Situation,I);
           If Not (New-S in List) then
           (扩展出的节点从未出现过)
           Begin
             open:=open+1;
             List[open].Situation:=New-S;
             List[open].Level:=List[close].Level+1;
             List[open].Last:=close;
           End-If
         End-For;
   End-While;
[深度搜索]
<Var>
   Open:Array[1..Max] of Node;(待扩展节点表)
   Close:Array[1..Max] of Node;(已扩展节点表)
   openL,closeL:Integer;(表的长度)
   New-S:Tsituation;(新状态)
<Init>
   Open<-0; Close<-0;
   OpenL<-1;CloseL<-0;
   Open[1].Situation<- 初始状态;
   Open[1].Level<-1;
   Open[1].Last<-0;
<Main Program>
   While (openL>0) and (closeL<Max) and (openL<Max) do
   Begin
     closeL:=closeL+1;
     Close[closeL]:=Open[openL];
     openL:=openL-1;
     For I:=1 to TotalExpendMethod do（扩展一层子节点）
     Begin
       New-S:=ExpendNode(Close[closeL].Situation,I);
       If Not (New-S in List) then
       (扩展出的节点从未出现过)
       Begin
         openL:=openL+1;
         Open[openL].Situation:=New-S;
         Open[openL].Level:=Close[closeL].Level+1;
         Open[openL].Last:=closeL;
       End-If
     End-For;
   End;
范例：迷宫问题，求解最短路径和可通路径。
评价：广度搜索是求解最优解的一种较好的方法，在后面将会对其进行进一步的优化。而深度搜索多用于只      要求解，并且解答树中的重复节点较多并且重复较难判断时使用，但往往可以用A*或回溯算法代替。