小编Dom*_*tin的帖子

我正在尝试在ASP网页上绘制图表.我希望API可以提供帮助,但到目前为止我还没有找到它.

该图包含标记的节点和未标记的有向边.理想的输出就是这样的.

任何人都知道预先建造的东西比可以帮助吗？

我可以轻松地为有向图的节点定义数据类型.

data Node = Node String [Node] derving (Show, Read)

我可以使用show函数将图形保存到文件中,然后使用read恢复它.但是,节目不会应付一个周期.是否有一种保存和恢复图形的简单方法？

我必须开发一个与拓扑排序相关的O(| V | + | E |)算法,它在有向无环图(DAG)中确定从图的每个顶点到t的路径数(t是一个节点) out-degree 0).我已经开发了DFS的修改如下:

DFS(G,t):
    for each vertex u ? V do
        color(u) = WHITE
        paths_to_t(u) = 0
    for each vertex u ? V do
        if color(u) == WHITE then
            DFS-Visit(u,t)

DFS-Visit(u,t):
    color(u) = GREY
    for each v ? neighbors(u) do
        if v == t then
            paths_to_t(u) = paths_to_t(u) + 1
        else then
            if color(v) == WHITE then
                DFS-Visit(v)
            paths_to_t(u) = paths_to_t(u) + paths_to_t(v)
    color(u) = BLACK

但我不确定这个算法是否与拓扑排序有关,或者我是否应该以另一种观点重构我的工作.

我在比赛的某个地方发现了这个问题,但还没有找到解决方案.

我有正整数.我必须找到最长的子集,在每两个相邻元素中,一个除以另一个.

我正在做的是:我正在创建图形.然后我正在连接其中数字彼此分开的节点.之后我正在使用DFS(一个节点可以连接两个节点).

但并非所有测试用例都适用于系统.在使用之前我是否必须对数组进行排序DFS？也许有特殊的(动态)算法？

失败的测试用例:

N = 5
1 1 3 7 13

我的代码给出了输出4.但如果我arrange这个数组像这样:

3 1 7 1 13

输出是5,这是真正的答案.

我也使用了递归方法.但我需要更快的东西.

我的知识存在差距,但我不确定究竟在哪里.维基百科解释说,拓扑排序可以使用深度优先搜索来完成.但是我只看到了为树实现的深度优先搜索,其中拓扑排序是针对DAG的.

1. 树是DAG的特殊情况,其中边的隐含方向是从根节点向下
2. 用于拓扑排序的算法不是真正做DFS,只有很多类似的东西吗？

例如,拓扑排序可以处理断开连接的图形,其中DFS无法遍历节点而没有边缘连接它...可以吗？

我正在寻找具有一些不寻常属性的图算法.

图中的每条边都是"向上"边缘或"向下"边缘.

有效路径可以是无限数量的"向上",然后是无限数量的"向下",反之亦然.然而,它不能多次改变方向.

例如,有效路径可能是A"向上"B"向上"C"向下"E"向下"F无效路径可能是A"向上"B"向下"C"向上"D

找到两个节点之间最短有效路径的好算法是什么？如何找到所有等长的最短路径？

我在网上发现了一些文章,提供了如何在SQL中对各种图形(特别是DAG)进行建模的示例,但考虑到它们的建模相对简单,它们看起来都非常复杂.

这样做有最佳/标准的方法吗？我目前的想法是这样的:

create table node (
  id int not null auto_increment,
  name TEXT
)

create table edge (
  from_node int not null,
  to_node int not null,  
  weight float
) 

那有什么不对吗？任何人都知道更好(更强大,也许)的方式？

我在网上找到了一个例子,然而,只返回BFS元素的序列不足以进行计算.比方说,根是BFS树的第一层,那么它的孩子是第二级,等我怎样才能知道哪一级是他们,谁是从下面的代码中的每个节点的父(我将创建一个对象存储其父级和树级)？

# sample graph implemented as a dictionary
graph = {'A': ['B', 'C', 'E'],
         'B': ['A','D', 'E'],
         'C': ['A', 'F', 'G'],
         'D': ['B'],
         'E': ['A', 'B','D'],
         'F': ['C'],
         'G': ['C']}

# visits all the nodes of a graph (connected component) using BFS
def bfs_connected_component(graph, start):
   # keep track of all visited nodes
   explored = []
   # keep track of nodes to be checked
   queue = [start]

   # keep looping until there are nodes still to be checked
   while queue:
       # …

我正在尝试通过创建一个程序来学习 DFS，该程序可以通过迷宫（二维数组）导航我的食人魔。这类似于日常编程挑战，但我只使用 1x1 食人魔。

我的迷宫：

static int[][] maze = { 
{2,1,0,0,0,0,0,0,0,0},
{0,0,1,0,0,0,0,0,0,0},
{1,0,0,0,0,1,0,1,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,1,1,0,0,0,0,0,0},
{0,0,1,0,0,0,0,1,0,1},
{1,1,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,1,1,0,0,0},
{0,0,0,0,0,1,0,0,0,3}};

其中 2 是我的英雄 (0,0)，3 是我的目标 (9,9)，1 是障碍物，0 是可穿越的空间。

由于我是新手，我怀疑是否需要它，但为了便于复制和故障排除，我将包含整个程序。

import java.awt.Point;
import java.util.ArrayList;


public class OgrePath {

    static int[][] maze = { 
        {2,1,0,0,0,0,0,0,0,0},
        {0,0,1,0,0,0,0,0,0,0},
        {1,0,0,0,0,1,0,1,0,0},
        {0,0,0,0,0,0,0,0,0,0},
        {0,0,1,1,0,0,0,0,0,0},
        {0,0,1,0,0,0,0,1,0,1},
        {1,1,0,0,0,0,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,0},
        {0,0,0,0,0,1,1,0,0,0},
        {0,0,0,0,0,1,0,0,0,3}};
public static boolean[][] visited = new boolean[maze.length][maze[0].length];
static ArrayList<Point> neighbors = new ArrayList<Point>();

public static void main(String[] args) {
    OgrePath OP = new OgrePath();
    for (int i=0;i<maze.length;i++){
        for …

在概念上,图表中的生成树和生成森林之间有什么区别.

此外,是否可以通过DFS或BFS遍历构建生成林？为什么？怎么样？

我理解生成树,但我找不到任何关于跨越森林的明确解释.甚至维基百科(https://en.wikipedia.org/wiki/Spanning_tree)也没有给出明确的定义.我的书(数据结构和算法,Wiley - 第六版)也没有关于跨越森林的定义.

我想知道,如果我们有一个图表,例如其中包含三个连接组件,是否可以通过DFS/BFS遍历构建生成林？