编写程序对给定的有向图（不一定连通）进行深度优先遍历，图中包含n个顶点，编号为0至n-1。本题限定在深度优先遍历过程中，如果同时出现多个待访问的顶点，则优先选择编号最小的一个进行访问，以顶点0为遍历起点。

### 回答1：
以下是一个对给定的有向图进行深度优先遍历的 Python 代码示例，其中图用邻接表表示：

def dfs(graph, visited, vertex):
    visited.add(vertex)
    print(vertex, end=" ")
    for neighbor in sorted(graph[vertex]):
        if neighbor not in visited:
            dfs(graph, visited, neighbor)

# 有向图的邻接表表示
graph = {
    0: [1, 2],
    1: [2],
    2: [0, 3],
    3: [3]
}

# 初始化访问记录
visited = set()

# 从顶点0开始深度优先遍历
dfs(graph, visited, 0)

在此代码示例中，我们使用一个集合来记录已访问的顶点，并在每次访问一个顶点时将其加入集合中。对于每个顶点，我们按照其邻居的编号排序，然后依次递归访问其未访问的邻居。因为 Python 的集合是自动去重的，所以我们不需要担心重复访问同一个顶点的问题。

另外需要注意的是，题目要求在同时存在多个待访问的顶点时，优先选择编号最小的一个进行访问。因此，在代码中我们使用 Python 内置的 `sorted()` 函数对邻居顶点进行排序。

### 回答2：
深度优先遍历是图遍历中的一种常用算法，该算法的核心思想是从起点开始，遍历尽可能深的节点，直到该节点无法访问为止，然后回溯到上一个节点，继续遍历其他子节点。对于给定的有向图，我们可以通过编写程序进行深度优先遍历，下面是一份可能的代码实现。

首先，我们需要定义图类，包含图的基本信息，如图中节点个数n和节点是否被访问visited。在构造函数中，我们需要初始化节点信息和邻接表。

class Graph:
def __init__(self,n,edges):
self.adj = [[] for _ in range(n)]
self.n = n
self.visited = [False] * n

for a, b in edges:
self.adj[a].append(b)

接着，我们需要定义深度优先遍历函数dfs，遍历顺序可以通过递归实现。对于节点v，我们先将其标记为访问过visited[v]=True，然后遍历v的所有子节点，如果子节点没有被访问过visited[u]=False，则将其作为起点继续进行dfs遍历。如果有多个待访问节点，我们选择编号最小的节点进行访问。

def dfs(self,v):
print(v)
self.visited[v] = True
next_vertices = sorted([u for u in self.adj[v] if not self.visited[u]])
for u in next_vertices:
self.dfs(u)

最后，在主函数中，我们创建一个有向图对象，并以顶点0为起点调用dfs函数。

if __name__ == '__main__':
n = 6
edges = [[0,1],[1,3],[2,0],[2,1],[3,4],[4,2],[5,0],[5,4]]
graph = Graph(n, edges)
graph.dfs(0)

对于上述代码，我们使用邻接表存储图中的边，时间复杂度为O(E+V)，其中E为边数，V为点数。在遍历过程中，我们根据编号大小来选择待访问的节点，保证了遍历顺序的一致性。 最终，程序输出深度优先遍历的结果，如下所示：

0
1
3
4
2
5

该序列为从起点顶点0出发访问的节点序列，符合深度优先遍历的定义。

### 回答3：
深度优先遍历是一种经典的图遍历算法，可以通过递归或者栈来实现。本题要求在深度优先遍历的过程中优先选择编号最小的待访问顶点，因此需要在遍历过程中维护一个合适的顶点访问顺序。

在本题中，我们可以采用递归实现深度优先遍历。具体步骤如下：

1. 根据给定的有向图构造邻接表存储结构。

2. 定义一个布尔类型的数组visited来表示每个顶点是否被访问过。初始时所有元素均为false。

3. 定义一个整型变量current表示当前正在访问的顶点，默认为0（起点）。

4. 定义一个优先队列priority_queue用来存储待访问的顶点，并按照编号从小到大的顺序进行排序。初始时将起点0放入队列中。

5. 每次从队列中取出编号最小的顶点，将其标记为已访问visited[current]=true，并依次访问其所有未访问的邻居顶点。遍历顺序按照邻接表中的顺序。顶点访问顺序按照队列中的顺序。

6. 递归访问邻居顶点，直到到达没有未访问邻居的顶点为止。

7. 如果队列为空并且还有未访问的顶点，则选择编号最小的未访问顶点继续进行深度优先遍历，否则遍历结束。

下面是一个简单的C++代码实现：

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

void dfs(vector<vector<int>>& graph, vector<bool>& visited, priority_queue<int, vector<int>, greater<int>>& pq, int current) {
visited[current] = true; // 标记当前顶点已访问
cout << current << ' '; // 输出遍历结果
for (auto neighbor : graph[current]) { // 遍历邻居顶点
if (!visited[neighbor]) { // 如果邻居顶点未访问
pq.push(neighbor); // 将其放入待访问顶点队列中
}
}
while (!pq.empty()) { // 遍历待访问顶点队列
int next = pq.top();
pq.pop();
if (!visited[next]) { // 如果待访问的顶点未访问
dfs(graph, visited, pq, next); // 继续递归调用dfs函数
}
}
}

int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> graph(n); // 构造邻接表
for (int i = 0; i < m; i++) { // 读入有向边信息
int from, to;
cin >> from >> to;
graph[from].push_back(to);
}
vector<bool> visited(n, false); // 初始时所有顶点均未被访问
priority_queue<int, vector<int>, greater<int>> pq;
pq.push(0); // 将起点0放入待访问顶点队列中
dfs(graph, visited, pq, 0); // 开始深度优先遍历
return 0;
}

需要注意的是，本题中的有向图不一定连通，因此可能需要多次调用dfs函数来完成整个遍历过程。具体的代码实现中可以使用一个循环来遍历所有未访问的顶点。另外，如果某个顶点没有被访问到，说明它和起点0不连通，可以设置它的遍历顺序为INT_MAX，使其排在队列最后面。