用plsql developer编程实现路径规划功能（北京，上海，广州，深圳），给我代码和运行结果

很抱歉，作为一个语言模型AI，我没有能力运行代码和生成实际的运行结果。但是，我可以给你提供一个大致的思路和代码示例，供你参考。

首先，路径规划可以使用图论中的最短路径算法来解决。在这个问题中，我们可以将四个城市看作图中的节点，将它们之间的距离看作边的权重，然后使用Dijkstra算法或者A*算法来找到任意两个城市之间的最短路径。

接下来，我们可以使用PL/SQL来实现这个算法。下面是一个简单的示例代码，它实现了Dijkstra算法来找到北京和深圳之间的最短路径：

DECLARE
  -- 定义节点和边
  TYPE node IS RECORD (name VARCHAR2(30), visited BOOLEAN, distance NUMBER, previous VARCHAR2(30));
  TYPE edge IS RECORD (start_node VARCHAR2(30), end_node VARCHAR2(30), weight NUMBER);
  
  -- 定义节点列表和边列表
  TYPE node_list IS TABLE OF node INDEX BY VARCHAR2(30);
  TYPE edge_list IS TABLE OF edge INDEX BY PLS_INTEGER;
  
  -- 初始化节点和边
  nodes node_list;
  edges edge_list;
  
  -- 定义算法变量
  current_node VARCHAR2(30);
  next_node VARCHAR2(30);
  min_distance NUMBER;
  
  -- 定义目标节点
  target_node VARCHAR2(30) := '深圳';
BEGIN
  -- 初始化节点列表
  nodes('北京').name := '北京';
  nodes('北京').visited := FALSE;
  nodes('北京').distance := 0;
  
  nodes('上海').name := '上海';
  nodes('上海').visited := FALSE;
  nodes('上海').distance := NULL;
  
  nodes('广州').name := '广州';
  nodes('广州').visited := FALSE;
  nodes('广州').distance := NULL;
  
  nodes('深圳').name := '深圳';
  nodes('深圳').visited := FALSE;
  nodes('深圳').distance := NULL;
  
  -- 初始化边列表
  edges(1).start_node := '北京';
  edges(1).end_node := '上海';
  edges(1).weight := 1000;
  
  edges(2).start_node := '北京';
  edges(2).end_node := '广州';
  edges(2).weight := 1500;
  
  edges(3).start_node := '上海';
  edges(3).end_node := '广州';
  edges(3).weight := 700;
  
  edges(4).start_node := '上海';
  edges(4).end_node := '深圳';
  edges(4).weight := 1200;
  
  edges(5).start_node := '广州';
  edges(5).end_node := '深圳';
  edges(5).weight := 800;
  
  -- 开始算法
  current_node := '北京';
  
  WHILE current_node IS NOT NULL LOOP
    -- 标记当前节点已访问
    nodes(current_node).visited := TRUE;
    
    -- 更新相邻节点的距离
    FOR i IN 1..edges.COUNT LOOP
      IF edges(i).start_node = current_node THEN
        next_node := edges(i).end_node;
        IF nodes(next_node).visited = FALSE THEN
          min_distance := nodes(current_node).distance + edges(i).weight;
          IF nodes(next_node).distance IS NULL OR min_distance < nodes(next_node).distance THEN
            nodes(next_node).distance := min_distance;
            nodes(next_node).previous := current_node;
          END IF;
        END IF;
      END IF;
    END LOOP;
    
    -- 找到下一个未访问的节点
    min_distance := NULL;
    FOR i IN 1..nodes.COUNT LOOP
      IF nodes(i).visited = FALSE AND nodes(i).distance IS NOT NULL THEN
        IF min_distance IS NULL OR nodes(i).distance < min_distance THEN
          min_distance := nodes(i).distance;
          current_node := nodes(i).name;
        END IF;
      END IF;
    END LOOP;
  END LOOP;
  
  -- 输出结果
  DBMS_OUTPUT.PUT_LINE('从北京到深圳的最短路径为：');
  current_node := target_node;
  WHILE current_node IS NOT NULL LOOP
    DBMS_OUTPUT.PUT(current_node);
    IF nodes(current_node).previous IS NOT NULL THEN
      DBMS_OUTPUT.PUT(' -> ');
    END IF;
    current_node := nodes(current_node).previous;
  END LOOP;
END;

上面的代码将四个城市看作节点，将它们之间的距离看作边的权重，然后使用Dijkstra算法来找到北京和深圳之间的最短路径。你可以根据这个示例代码来编写你自己的路径规划算法，以满足你的具体需求。