需求：自己写一套简单导航逻辑。1.导航路径由一个个节点组成，每个节点自定义可到达哪几个节点，根据这样一个网络写出一套算法实时获取最近节点，然后计算出所有可能到达终点的方案中最近的方案，最后返回出最近方案的数组，用c#写

好的，以下是一个简单的节点导航逻辑示例：

using System.Collections.Generic;

public class Node
{
    public int Id { get; set; }
    public List<int> ConnectedNodes { get; set; }

    public Node(int id, List<int> connectedNodes)
    {
        Id = id;
        ConnectedNodes = connectedNodes;
    }
}

public class NavigationController
{
    private Dictionary<int, Node> _nodes;

    public NavigationController(Dictionary<int, Node> nodes)
    {
        _nodes = nodes;
    }

    public List<int> GetShortestPath(int startNodeId, int endNodeId)
    {
        Dictionary<int, int> distance = new Dictionary<int, int>();
        Dictionary<int, int> previous = new Dictionary<int, int>();
        List<int> unvisitedNodes = new List<int>();

        // 初始化距离和前置节点
        foreach (var node in _nodes)
        {
            if (node.Key == startNodeId)
            {
                distance[node.Key] = 0;
            }
            else
            {
                distance[node.Key] = int.MaxValue;
            }
            previous[node.Key] = null;
            unvisitedNodes.Add(node.Key);
        }

        while (unvisitedNodes.Count > 0)
        {
            // 获取最短距离的节点
            int currentNodeId = GetClosestNode(distance, unvisitedNodes);
            unvisitedNodes.Remove(currentNodeId);

            // 如果到达终点则停止搜索
            if (currentNodeId == endNodeId)
            {
                break;
            }

            // 更新相邻节点的距离
            foreach (var neighborNodeId in _nodes[currentNodeId].ConnectedNodes)
            {
                int tentativeDistance = distance[currentNodeId] + 1;
                if (tentativeDistance < distance[neighborNodeId])
                {
                    distance[neighborNodeId] = tentativeDistance;
                    previous[neighborNodeId] = currentNodeId;
                }
            }
        }

        // 构造路径
        List<int> path = new List<int>();
        int currentNode = endNodeId;
        while (currentNode != null)
        {
            path.Add(currentNode);
            currentNode = previous[currentNode];
        }
        path.Reverse();

        return path;
    }

    private int GetClosestNode(Dictionary<int, int> distance, List<int> unvisitedNodes)
    {
        int closestNodeId = unvisitedNodes[0];
        foreach (var nodeId in unvisitedNodes)
        {
            if (distance[nodeId] < distance[closestNodeId])
            {
                closestNodeId = nodeId;
            }
        }
        return closestNodeId;
    }
}

节点类 `Node` 包含一个 ID 和一个列表 `ConnectedNodes`，表示该节点可以到达哪些节点。导航控制器 `NavigationController` 接受一个节点字典作为参数，在构造函数中初始化后存储。

`GetShortestPath` 方法接受起点和终点节点 ID，使用 Dijkstra 算法实时获取最近节点，并计算出所有可能到达终点的方案中最近的方案。最后，该方法返回最近方案的节点数组。

在 Dijkstra 算法中，我们使用一个字典 `distance` 存储每个节点到起点的距离，使用一个字典 `previous` 存储每个节点的前置节点。我们从起点开始，将起点的距离设置为 0，其余节点的距离设置为无穷大。然后，我们从未访问的节点中选择距离最近的节点，更新其相邻节点的距离和前置节点。重复这个过程直到我们到达终点或者不存在未访问的节点为止。最后，我们使用 `previous` 字典构造路径。