Question

我正在做一个小游戏，我将在一个移动的网格上有一个角色。当他们四处走动时，我将使用Dijkstra的算法进行路径测量。唯一的问题是我想制作薄壁（而不是仅仅删除节点），如：http://i.gyazo.com/85d110c17cf027d3ad0219fa26938305.png

我认为最好的方法就是编辑2个方格之间的边缘权重，使其永远不会交叉。无论如何，关于这个问题：

为网格中的每个连接分配边权重的最有效方法是什么？

我考虑使用邻接矩阵，但对于15x6网格，这是一个90x90矩阵，似乎......过度。任何帮助都会很好，谢谢（：

Answer 1

您只需要在直线方块之间存储边缘，并且方形最多可以有4个邻居，每个方向一次。将节点访问的边缘存储为最多4个枚举项{up，down，left，right}。那个小于90 x 4。

Answer 2

可以帮助您决定应该做什么的一些指示：

您的图表似乎未加权，因此您可以使用BFS，即在这种情况下，比Dijkstra的算法更容易实现和更高效。
90x90矩阵对于现代机器来说几乎不是问题（除非你打算在一个非常紧凑的循环中使用寻路算法）。
如果您使用double作为权重，则可以使用很多语言您可以使用的无限值。在java中 Double.POSITIVE_INFINITY。关于无穷大的美 - 尽管你加入它，它仍然保持无穷大（并且不会像整数一样溢出）。
您可以随时使用adjacency lists，这可以被认为是矩阵的稀疏实现 - 其中大多数边具有一些不变的预定义权重（例如，对于非现有边缘，无穷大）。
请注意，对于非常精简的图形（与您的一样）使用邻接矩阵而不是邻接列表会使BFS O(V^2)的时间复杂度变为O(V+E)（在您的情况下实际为O(V) ）和O(V^2)代替Dijkstra算法而不是O(E + VlogV)（图表为O(VlogV)）

Answer 3

我同意多岩石的回答 - 只需为数组中的每个方块存储四个方向的权重（每个数组元素将是包含四个权重的结构/元组）。要在两个任意方块之间查找边缘，首先要检查它们是否相邻，如果是，请使用数组中的适当权重。不知道为什么有人提到邻接列表或矩阵，这里是多余的。

Answer 4

尝试使用以下代码创建游戏。

b'/'

Answer 5

使用此代码初始化大型阵列的游戏板。然后为墙的位置添加空值，确保将墙添加到两个单元格。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            cell game = new cell(90, 100);
        }
    }
    public class cell
    {
        public static cell[,] board = null;

        public int index { get; set; }  //row number * 6 + col 
        public int row { get; set;}
        public int col { get; set;}
        public cell up { get; set; }
        public cell down { get; set; }
        public cell left { get; set; }
        public cell right { get; set; }
        public bool visited { get; set; }

        public cell() { }

        public cell(int rows, int cols)
        {
            board = new cell[rows, cols];
            int cellNumber = 0;

            for (int row = 0; row < rows; row++)
            {
                for (int col = 0; col < cols; col++)
                {
                    board[row, col] = new cell();
                    board[row, col].visited = false;

                }
            }

            for (int row = 0; row < rows; row++)
            {
                for (int col = 0; col < cols; col++)
                {
                    cellNumber = (row * cols) + col;

                    board[row, col].index = cellNumber;
                    board[row, col].row = row;
                    board[row, col].col = col;

                    if (col == 0)
                    {
                        board[row, col].left = null;
                    }
                    else
                    {
                        board[row, col].left = board[row, col - 1];
                    }                        


                    if (row == 0)
                    {
                        board[row, col].up = null;
                    }
                    else
                    {
                        board[row, col].up = board[row - 1, col];
                    }                        


                    if (col == cols - 1)
                    {
                        board[row, col].right = null;
                    }
                    else
                    {
                        board[row, col].right = board[row, col + 1];
                    }                        

                    if (row == rows - 1)
                    {
                        board[row, col].down = null;
                    }
                    else
                    {
                        board[row, col].down = board[row + 1, col];
                    }                        

                }
            }
        }
    }
}

表示Dijkstra算法边缘权重的最有效方法是什么

5 个答案: