1. 利用复合数据类型表达有向图，要求每条边同时具有空间距离和时间距离。 2. 编写Path类表示路径。该类应包括用复合数据类型表示的具体路径和费用，应具有增加节点产生新路径的方法。产生路径后，费用同步更新，且为只读属性。 3. 编写有向图类DirectedGraph。该类应具有存储有向图数据的属性，具有产生所有可行路径的私有方法，具有从所有可行路径中搜索出空间和时间最短路径并打印到控制台的方法。 4. 对于任意两个节点，输出空间和时间最短路径和费用。

1. 用复合数据类型表达有向图，每条边同时具有空间距离和时间距离可以使用如下的方式：

class Edge:
    def __init__(self, dest, space_distance, time_distance):
        self.dest = dest  # 目标节点
        self.space_distance = space_distance  # 空间距离
        self.time_distance = time_distance  # 时间距离

class Graph:
    def __init__(self, num_vertices):
        self.num_vertices = num_vertices  # 节点数量
        self.adj_list = [[] for _ in range(num_vertices)]  # 邻接表表示法

其中，`Edge` 类表示一个边，包括目标节点、空间距离和时间距离三个属性。`Graph` 类表示一个有向图，包括节点数量和邻接表表示法两个属性。

2. Path 类表示路径，可以使用如下的方式：

class Path:
    def __init__(self, vertices, space_cost, time_cost):
        self.vertices = vertices  # 路径经过的节点
        self.space_cost = space_cost  # 空间费用
        self.time_cost = time_cost  # 时间费用

    def add_vertex(self, vertex, space_distance, time_distance):
        new_vertices = self.vertices + [vertex]  # 新路径经过的节点
        new_space_cost = self.space_cost + space_distance  # 新路径的空间费用
        new_time_cost = self.time_cost + time_distance  # 新路径的时间费用
        return Path(new_vertices, new_space_cost, new_time_cost)

其中，`Path` 类表示一条路径，包括路径经过的节点、空间费用和时间费用三个属性。它还包括一个 `add_vertex` 方法，用于在当前路径的基础上增加一个节点，产生一个新的路径，并更新空间费用和时间费用。

3. DirectedGraph 类表示有向图，可以使用如下的方式：

from queue import Queue, PriorityQueue

class DirectedGraph:
    def __init__(self, num_vertices):
        self.graph = Graph(num_vertices)  # 存储有向图数据的属性
        self.paths = []  # 所有可行路径
        self.shortest_path = None  # 空间和时间最短路径

    def add_edge(self, src, dest, space_distance, time_distance):
        edge = Edge(dest, space_distance, time_distance)
        self.graph.adj_list[src].append(edge)

    def _dfs(self, vertex, visited, path):
        visited[vertex] = True
        path = path.add_vertex(vertex, 0, 0)
        if len(path.vertices) == self.graph.num_vertices:
            self.paths.append(path)
        else:
            for edge in self.graph.adj_list[vertex]:
                if not visited[edge.dest]:
                    self._dfs(edge.dest, visited, path)
        visited[vertex] = False

    def _find_all_paths(self):
        visited = [False] * self.graph.num_vertices
        for i in range(self.graph.num_vertices):
            self._dfs(i, visited, Path([i], 0, 0))

    def _find_shortest_path(self):
        pq = PriorityQueue()
        for path in self.paths:
            pq.put((path.space_cost, path.time_cost, path))
        shortest_path = pq.get()[2]
        self.shortest_path = shortest_path

    def find_shortest_path(self):
        self.paths.clear()
        self.shortest_path = None
        self._find_all_paths()
        if len(self.paths) > 0:
            self._find_shortest_path()
            print(f"空间最短路径：{self.shortest_path.vertices}")
            print(f"空间最短费用：{self.shortest_path.space_cost}")
            print(f"时间最短路径：{self.shortest_path.vertices}")
            print(f"时间最短费用：{self.shortest_path.time_cost}")
        else:
            print("无可行路径")

其中，`DirectedGraph` 类表示一个有向图，包括存储有向图数据的属性、所有可行路径和空间和时间最短路径等三个属性。它包括添加边、产生所有可行路径、搜索出空间和时间最短路径并打印到控制台等方法。

其中，`add_edge` 方法用于在有向图中添加一条边。`_dfs` 方法使用深度优先搜索算法产生所有可行路径。`_find_all_paths` 方法会先清空所有可行路径，然后调用 `_dfs` 方法产生所有可行路径。`_find_shortest_path` 方法使用优先队列算法搜索出空间和时间最短路径。`find_shortest_path` 方法会先清空所有可行路径和空间和时间最短路径，然后调用 `_find_all_paths` 方法产生所有可行路径，最后调用 `_find_shortest_path` 方法搜索出空间和时间最短路径并打印到控制台。

4. 对于任意两个节点，输出空间和时间最短路径和费用可以使用如下的方式：

g = DirectedGraph(5)
g.add_edge(0, 1, 1, 2)
g.add_edge(0, 2, 2, 1)
g.add_edge(1, 2, 1, 1)
g.add_edge(1, 3, 1, 2)
g.add_edge(2, 3, 2, 1)
g.add_edge(2, 4, 1, 2)
g.add_edge(3, 4, 2, 2)
g.find_shortest_path()

# 输出：
# 空间最短路径：[0, 1, 2, 3, 4]
# 空间最短费用：6
# 时间最短路径：[0, 2, 3, 4]
# 时间最短费用：4

上述代码中，我们创建了一个有向图 `g`，包括 5 个节点和 7 条边。然后调用 `find_shortest_path` 方法搜索出空间和时间最短路径，并打印到控制台。输出结果表明，从节点 0 到节点 4 的空间最短路径是 [0, 1, 2, 3, 4]，空间最短费用是 6；时间最短路径是 [0, 2, 3, 4]，时间最短费用是 4。