0

我正在做一个 ADA 项目。本质上，我创建了一个列表和一个列表列表。

所以假设我有一个像 A -> B -> D -> E -> F 这样的列表，这意味着塔 A 连接到塔 B、D、E 和 F。

现在我还需要一个列表来存储所有的主塔。所以假设我有 A -> B -> D -> E -> F，我有 C->X->Y->Q 和 E->P->R，列表列表应该是这样的：

A-> C-> E （本质上是所有主要节点的列表）。如上所述，我有一个列表及其连接。现在我需要遍历这些列表以找出是否可以连接。例如：我有 A -> B -> D -> E -> F，我有 C->X->Y->Q 和 E->P->R。如果我被问到是 A -> R 可能的答案应该是真的。由于 A -> E -> R。我怀疑我应该使用什么方法？BFS？递归？什么会是最好的？

4

1 回答 1

1

嵌套for/of循环？像这样的东西：

Function Exists( Target, Source : Node ) return boolean is
begin
    if Target = Source then
        return True;
    else
        for List of Source loop
            for Item of List loop
                if Item = Target then
                    return True;
                end if;
            end loop;
        end loop;
    end if;

    return false;
end Exists;

或者，如果您将 Vector 用于容器，则可以使用以下功能：

 function Contains
   (Container : Vector;
    Item      : Element_Type) return Boolean;

你会这样申请：

Package Inner_List is new Ada.Containers.Indefinite_Vectors(
                    Index_Type   => Positive,
                    Element_Type => Integer
                     );
Package Outer_List is new Ada.Containers.Indefinite_Vectors(
                    Index_Type   => Positive,
                    Element_Type => Inner_List.Vector,
                    "="          => Inner_List."="
                     );

Function Exists( Item : Integer; List : Outer_List.Vector ) return boolean is
begin
    for Items of List loop
        if Items.Contains(Item) then
            return true;
        end if;
    end loop;

    return false;
End Exists;
于 2013-11-03T18:08:52.577 回答