程序实现建立六条边和十二个顶点的有向图G的邻接矩阵和邻接表存储结构，并输出这两种结构，根据邻接表，实现图G从顶点0开始的深度优先遍历和广度优先遍历算法，并输出从顶点5到顶点2的所有长度为3的简单路径，从顶点5到顶点2的最短路径最后销毁图G的邻接表的设计思路

好的，我会根据您的要求进行回答。首先是邻接矩阵和邻接表的存储结构：

邻接矩阵：

   0 1 2 3 4 5
0  0 1 0 0 0 1
1  0 0 1 0 0 0
2  1 0 0 1 0 0
3  0 0 0 0 1 0
4  0 0 1 0 0 1
5  0 0 0 1 1 0

邻接表：

0 -> 1 -> 5
1 -> 2
2 -> 0 -> 3
3 -> 4
4 -> 2 -> 5
5 -> 3 -> 4

接下来是深度优先遍历和广度优先遍历算法的实现，以及从顶点5到顶点2的所有长度为3的简单路径：

深度优先遍历算法：

def dfs(graph, start):
    visited = set()
    stack = [start]
    while stack:
        vertex = stack.pop()
        if vertex not in visited:
            visited.add(vertex)
            stack.extend(graph[vertex] - visited)
    return visited

广度优先遍历算法：

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    while queue:
        vertex = queue.popleft()
        if vertex not in visited:
            visited.add(vertex)
            queue.extend(graph[vertex] - visited)
    return visited

从顶点5到顶点2的所有长度为3的简单路径：

def find_all_paths(graph, start, end, path=[]):
    path = path + [start]
    if start == end:
        return [path]
    if start not in graph:
        return []
    paths = []
    for node in graph[start]:
        if node not in path:
            new_paths = find_all_paths(graph, node, end, path)
            for p in new_paths:
                if len(p) == 4 and p[-1] == end:
                    paths.append(p)
    return paths

使用 `find_all_paths(graph, 5, 2)` 即可输出所有长度为3的简单路径。

最后是从顶点5到顶点2的最短路径，可以使用 Dijkstra 算法或者 Floyd 算法，这里给出 Dijkstra 算法的实现：

Dijkstra 算法：

import heapq

def dijkstra(graph, start, end):
    heap = [(0, start)]
    visited = set()
    while heap:
        (cost, vertex) = heapq.heappop(heap)
        if vertex not in visited:
            visited.add(vertex)
            if vertex == end:
                return cost
            for next_vertex, c in graph[vertex].items():
                if next_vertex not in visited:
                    heapq.heappush(heap, (cost + c, next_vertex))
    return float("inf")

使用 `dijkstra(graph, 5, 2)` 即可输出从顶点5到顶点2的最短路径长度。

最后是邻接表的销毁，只需将所有链表节点释放即可，示例代码如下：

def destroy_graph(graph):
    for node in graph:
        graph[node] = None
    del graph