Topological physics relies on the existence of Hamiltonian’s eigenstate singularities carrying a topological charge, such as quantum vortices, Dirac points, Weyl points and – in non- Hermitian systems – exceptional points (EPs), lines or surfaces 1–3 . They appear only in pairs connected by a Fermi arc and are related to a Hermitian singularity, such as a Dirac point.

时间: 2023-03-11 14:08:46 浏览: 101
结构物理学依赖于汉密尔顿算符特征值奇点的存在，这些奇点带有拓扑电荷，例如量子涡、达拉克点、韦尔点以及非埃尔米特系统中的特例点(EPs)、线或面1–3。它们以一对的形式出现，并且与一个埃尔米特奇点（例如达拉克点）相连接。
相关问题

arithmetic_optimizer failed: Invalid argument: The graph couldn't be sorted in topological order.

这个错误信息表明你的图无法按照拓扑顺序进行排序。拓扑顺序是指图中节点的有向边的顺序，每个节点都要在所有入边完成后才能开始计算。这个错误通常是因为图中存在环，因此无法排序。请检查图的设计并修复图中的环。

is topological order

拓扑排序是一种用来确定有向无环图上结点的线性序列的排序方式。它的基本思想是，对于有向无环图中的每个结点，按照其入度的大小将其排序。通过这种方式，可以得到一个线性序列，该序列满足任意两结点之间的关系都符合有向图中的关系。

相关推荐

importerror: "from catkin_pkg.topological_order import topological_order" failed: no module named 'catkin_pkg'

这是一个导入错误，错误信息为：importerror: "from catkin_pkg.topological_order import topological_order" failed: no module named 'catkin_pkg'。 这个错误通常是因为缺少catkin_pkg模块导致的。要解决这个问题，可以尝试安装catkin_pkg模块，或者检查是否已经正确安装了ROS和catkin工具。如果已经安装了ROS和catkin工具，可以尝试重新编译工作区，以确保所有依赖项都已正确安装。

traversing 0 packages in topological order: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The packages or cmake arguments have changed, forcing cmake invocation

这是ROS构建系统catkin的输出信息，表示在构建ROS软件包时，已经检测到ROS软件包的依赖项或构建参数发生了更改，因此需要重新运行cmake命令来重新生成构建系统所需的文件。这是一个正常的输出信息，表明ROS软件包正在重新构建。在重新构建完成后，你可以运行catkin_make命令来构建完整的ROS工作空间。

试实现拓扑排序算法。函数void findindegree(algraph g,int indegree[])实现图中各个顶点入度的统计；函数int topologicalsort(algraph g , int topo[])获取拓扑序列。

题目要求实现拓扑排序算法。函数void findindegree(algraph g,int indegree[])实现统计图中各个顶点入度的功能，函数int topologicalsort(algraph g , int topo[])获取拓扑序列。

逐行翻译代码：typedef struct node { int adjvex; struct node *next; }node, *pointer; typedef struct node1 { int vex; int in; pointer link; }ALGraph; void createadlist(ALGraph G[], int n, int e) { int i, k, j; pointer q; for (i = 1; i <= n; i++) { G[i].vex = i; G[i].in=0; G[i].link = null; } for (k = 1; k <= e; k++) { scanf("%d%d", &i, &j); q = (pointer)malloc(sizeof(struct node)); q->adjvex = j; q->next = G[i].link; G[i].link = q; G[j].in++; } } void fun(ALGraph G[], int n, int v, int visit[]) { pointer p; int w; visit[v] = 1; printf("%3d", v); p = G[v].link; while (p != null) { w = p->adjvex; if (visit[w] == 0) { fun(G, n, w, visit); } p = p->next; } } int TopologicalSort(ALGraph G[],int &n) { SqStack S; InitSatack(S); for(int i=1;i<n;i++) { if(!G[i].in) Push(S,i); int count=0; while(!StackEmpty(S)) { Pop(S,i); printf(" %d ",i); ++count; pointer p; p=(pointer)malloc(sizeof(struct node)); for(p=G[i].link;p;p=p->next) { int k=p->adjvex; if(!(--G[k].in)) Push(S,k); } } if(count<G[i].in) printf("存在循环"); } return ok; }

这段代码是一个图的邻接表存储结构的实现。下面是逐行的代码翻译： typedef struct node { int adjvex; struct node *next; }node, *pointer; typedef struct node1 { int vex; int in; pointer link; }ALGraph; 定义了两个结构体，一个是邻接表中的节点，一个是邻接表中的图。 void createadlist(ALGraph G[], int n, int e) { int i, k, j; pointer q; for (i = 1; i <= n; i++) { G[i].vex = i; G[i].in=0; G[i].link = null; } for (k = 1; k <= e; k++) { scanf("%d%d", &i, &j); q = (pointer)malloc(sizeof(struct node)); q->adjvex = j; q->next = G[i].link; G[i].link = q; G[j].in++; } } 这个函数用于创建邻接表。首先对于每个节点，分别给它们赋值。然后遍历每一条边，读取起点和终点，为终点节点的入度加1，同时将起点节点作为终点节点的邻接表的头节点。 void fun(ALGraph G[], int n, int v, int visit[]) { pointer p; int w; visit[v] = 1; printf("%3d", v); p = G[v].link; while (p != null) { w = p->adjvex; if (visit[w] == 0) { fun(G, n, w, visit); } p = p->next; } } 这个函数是深度优先遍历的实现。从给定的起点开始，访问该节点，并标记为已访问。然后遍历该节点的邻接表，如果邻接节点未被访问，则递归地访问该节点。 int TopologicalSort(ALGraph G[],int &n) { SqStack S; InitSatack(S); for(int i=1;i<n;i++) { if(!G[i].in) Push(S,i); int count=0; while(!StackEmpty(S)) { Pop(S,i); printf(" %d ",i); ++count; pointer p; p=(pointer)malloc(sizeof(struct node)); for(p=G[i].link;p;p=p->next) { int k=p->adjvex; if(!(--G[k].in)) Push(S,k); } } if(count<G[i].in) printf("存在循环"); } return ok; } 这个函数是拓扑排序的实现。首先建立一个栈，将所有入度为0的节点入栈。然后弹出栈顶元素，输出该节点，并将该节点指向的邻接节点的入度减1。如果邻接节点入度为0，则入栈。当栈为空时，如果输出的节点数小于节点总数，则说明存在环。最后返回ok表示排序完成。

Traceback (most recent call last): File "C:\Users\ying\Desktop\pythonProject5\main.py", line 70, in <module> start_times = nx.dag_early_start(G) AttributeError: module 'networkx' has no attribute 'dag_early_start'

这个错误提示是因为在新版本的 networkx 中，dag_early_start 已经被移除了，不再支持。你可以尝试使用 networkx 中的 topological_sort 函数来实现 DAG 的拓扑排序，然后根据拓扑序列计算每个节点的最早开始时间。具体的实现可以参考以下代码： python import networkx as nx def calculate_early_start_time(G): # 计算拓扑序列 topo_order = list(nx.topological_sort(G)) # 初始化开始时间 start_times = {node: 0 for node in G.nodes()} # 计算每个节点的最早开始时间 for node in topo_order: for predecessor in G.predecessors(node): start_times[node] = max(start_times[node], start_times[predecessor] + G[predecessor][node]['duration']) return start_times 你可以把这段代码替换掉原来的 dag_early_start 函数即可。

Traceback (most recent call last): File "C:\Users\ying\Desktop\pythonProject5\main.py", line 84, in <module> end_times = nx.dag_late_finish(G, start_times) AttributeError: module 'networkx' has no attribute 'dag_late_finish'如何解决

这个错误是因为 networkx 模块中没有 dag_late_finish 属性。这个属性在较早的版本中可能存在，但在最新版本中已被删除。 你可以使用 networkx 中的 topological_sort 函数来实现类似的功能。下面是一个示例： python import networkx as nx G = nx.DiGraph() # 添加节点和边 start_times = nx.topological_sort(G) end_times = {node: max(end_times.get(child, 0) for child in G.successors(node)) + weight for node, weight in G.nodes(data="weight")} 在这个示例中，我们使用了 topological_sort 函数来获取拓扑排序后的节点列表，然后使用一个字典推导式计算每个节点的最晚完成时间。 你可以根据你的具体需求进行修改。

Base path: /home/dama/demo02_ws Source space: /home/dama/demo02_ws/src Build space: /home/dama/demo02_ws/build Devel space: /home/dama/demo02_ws/devel Install space: /home/dama/demo02_ws/install #### #### Running command: "make cmake_check_build_system" in "/home/dama/demo02_ws/build" #### -- Using CATKIN_DEVEL_PREFIX: /home/dama/demo02_ws/devel -- Using CMAKE_PREFIX_PATH: /home/dama/demo02_ws/devel;/home/dama/demo01_ws/devel;/opt/ros/noetic -- This workspace overlays: /home/dama/demo02_ws/devel;/home/dama/demo01_ws/devel;/opt/ros/noetic -- Found PythonInterp: /usr/bin/python3 (found suitable version "3.8.10", minimum required is "3") -- Using PYTHON_EXECUTABLE: /usr/bin/python3 -- Using Debian Python package layout -- Using empy: /usr/lib/python3/dist-packages/em.py -- Using CATKIN_ENABLE_TESTING: ON -- Call enable_testing() -- Using CATKIN_TEST_RESULTS_DIR: /home/dama/demo02_ws/build/test_results -- Forcing gtest/gmock from source, though one was otherwise available. -- Found gtest sources under '/usr/src/googletest': gtests will be built -- Found gmock sources under '/usr/src/googletest': gmock will be built -- Found PythonInterp: /usr/bin/python3 (found version "3.8.10") -- Using Python nosetests: /usr/bin/nosetests3 -- catkin 0.8.10 -- BUILD_SHARED_LIBS is on -- BUILD_SHARED_LIBS is on -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- ~~ traversing 1 packages in topological order: -- ~~ - hello_vscode -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- +++ processing catkin package: 'hello_vscode' -- ==> add_subdirectory(hello_vscode) CMake Error at /opt/ros/noetic/share/catkin/cmake/catkin_install_python.cmake:86 (message): catkin_install_python() called with non-existing file '/home/dama/demo02_ws/src/hello_vscode/scripts/hello_vscode_p.py'. Call Stack (most recent call first): hello_vscode/CMakeLists.txt:162 (catkin_install_python) -- Configuring incomplete, errors occurred! See also "/home/dama/demo02_ws/build/CMakeFiles/CMakeOutput.log". See also "/home/dama/demo02_ws/build/CMakeFiles/CMakeError.log". make: *** [Makefile:544：cmake_check_build_system] 错误 1 Invoking "make cmake_check_build_system" failed

这段代码是ROS的编译过程中的错误信息，它指出在执行catkin_install_python()函数时，找不到指定的python文件/home/dama/demo02_ws/src/hello_vscode/scripts/hello_vscode_p.py。你可以检查一下这个文件路径是否正确，或者确认一下你的python文件是否存在。如果文件确实存在，那么可能是你的CMakeLists.txt文件中的配置有误导致的。你可以仔细检查一下CMakeLists.txt文件中与该python文件有关的部分是否正确，或者尝试重新生成一下CMakeLists.txt文件。另外，你也可以检查一下你的工作空间路径是否正确。希望我的回答能帮到你！

输入格式: 输入第一行为两个整数n和e，均不超过300。n表示参会人员数。接下来e行，e不超过100，表示已知的两名员工的级别关系，每行为两个整数a和b，表示员工a是员工b的上级。 输出格式: 输出为1行整数，每个整数后一个空格，为n名员工的编号，表示n名员工的发言顺序，如果有多种可能的顺序，则输出字典序最小者。 注：字典序，即对象在字典中的顺序。对于两个数字序列，从第一个数字开始比较，当某一个位置的数字不同时，该位置数字较小的序列，字典序较小，例如1239比1245小。c++

这是一道拓扑排序的经典题目，可以使用BFS或DFS实现。以下是使用BFS实现的示例代码： c++ #include <iostream> #include <queue> #include <vector> #include <algorithm> using namespace std; const int MAXN = 305; struct Employee { int id, level; }; vector<int> adj[MAXN]; int inDegree[MAXN]; bool visited[MAXN]; Employee employees[MAXN]; bool cmp(Employee a, Employee b) { return a.id < b.id; } vector<int> topologicalSort(int n) { queue<int> q; vector<int> ans; for (int i = 1; i <= n; i++) { if (inDegree[i] == 0) { q.push(i); } } while (!q.empty()) { int u = q.front(); q.pop(); ans.push_back(u); for (int i = 0; i < adj[u].size(); i++) { int v = adj[u][i]; inDegree[v]--; if (inDegree[v] == 0) { q.push(v); } } } return ans; } int main() { int n, e; cin >> n >> e; for (int i = 1; i <= n; i++) { employees[i].id = i; cin >> employees[i].level; } sort(employees + 1, employees + n + 1, cmp); for (int i = 0; i < e; i++) { int a, b; cin >> a >> b; adj[b].push_back(a); inDegree[a]++; } vector<int> ans = topologicalSort(n); for (int i = 0; i < n; i++) { cout << ans[i] << " "; } return 0; } 代码思路： 首先定义一个结构体 Employee，表示员工的编号和级别。然后将所有员工按照编号从小到大排序，以便输出时能够按照字典序输出。 接着输入每个员工的级别和已知的上下级关系，用邻接表存储图，同时统计每个节点的入度。 最后使用BFS实现拓扑排序，将排序结果输出即可。

拓扑排序C++代码来一份

拓扑排序C的代码如下： #include <stdio.h> #define MAXV 100 /* maximum number of vertices */ int n; /* number of vertices in the graph */ int AdjMatrix[MAXV+1][MAXV+1]; int indegree[MAXV+1]; void TopologicalSort(void); int main(void) { int i,j,count; /* read the adjacency matrix */ scanf("%d",&n); for (i=1; i<=n; i++) for (j=1; j<=n; j++) scanf("%d",&AdjMatrix[i][j]); /* find the indegree of each vertex */ for (j=1; j<=n; j++) { count = 0; for (i=1; i<=n; i++) count += AdjMatrix[i][j]; indegree[j] = count; } TopologicalSort(); return 0; } void TopologicalSort(void) { int i,j,k; int top=-1; /* points to the top element of stack */ int S[MAXV+1]; /* S[top] is the current vertex */ int v; /* current vertex */ int output[MAXV+1]; /* output sequence */ int outputIndex=0; /* index for output sequence */ /* initialize stack */ for (i=1; i<=n; i++) if (indegree[i] == 0) S[++top] = i; /* start loop */ while (top != -1) { v = S[top--]; output[outputIndex++] = v; /* remove vertex v from graph */ for (j=1; j<=n; j++) if (AdjMatrix[v][j] == 1) { /* vertex j is adjacent to v */ indegree[j]--; if (indegree[j] == 0) S[++top] = j; } /* end of for */ } /* end of while */ /* print output sequence */ for (i=0; i<n; i++) printf("%d ",output[i]); printf("\n"); }

由于采用不同方式实现的拓扑排序，输出序列不惟一，因此对此题进行修订。不再检查拓扑序列是否一致。 【问题描述】 设一有向图（如下所示），求图的邻接表表示，用拓扑序列检测有向图是否存在环。 image.png 【输入形式】 输入顶点信息，以#结束； 输入弧的信息，以-1，-1结束。 【输出形式】 输出邻接表形式 输出拓扑排序的顶点数 输出是否存在环 【样例输入1】 ABCDEF# 0,1 1,2 2,3 4,1 4,5 -1,-1 【样例输出1】 A,0:->1 B,2:->2 C,1:->3 D,1: E,0:->5->1 F,1: 6 no ring 【样例输入2】 ABCDEF# 1,0 1,3 2,1 2,5 3,2 3,4 3,5 4,0 5,0 5,1 5,4 -1,-1 【样例输出2】 A,3: B,2:->3->0 C,1:->5->1 D,1:->5->4->2 E,2:->0 F,2:->4->1->0 0 has ring 【样例说明】 样例2中，有向图拓扑序列一个顶点都无法输出。 【评分标准】 给出c语言代码

c #include <stdio.h> #include <stdlib.h> #define MAX_VERTEX_NUM 100 #define OK 1 #define ERROR 0 typedef char VertexType; typedef int Status; typedef struct ArcNode { int adjvex; // 邻接点在数组中的位置 struct ArcNode *nextarc; // 指向下一个邻接点的指针 } ArcNode; typedef struct VNode { VertexType data; // 顶点信息 int indegree; // 入度 ArcNode *firstarc; // 指向第一个邻接点 } VNode, AdjList[MAX_VERTEX_NUM]; typedef struct { AdjList vertices; // 图的顶点数组 int vexnum, arcnum; // 顶点和弧数目 } ALGraph; Status CreateGraph(ALGraph *G) { scanf("%c", &G->vertices[0].data); G->vexnum = 1; while (getchar() != '#') { scanf("%c", &G->vertices[G->vexnum].data); ++G->vexnum; } getchar(); // 读取回车 for (int i = 0; i < G->vexnum; ++i) { G->vertices[i].firstarc = NULL; G->vertices[i].indegree = 0; } int v1, v2; while (1) { scanf("%d,%d", &v1, &v2); if (v1 == -1 && v2 == -1) break; ArcNode *arc = (ArcNode *) malloc(sizeof(ArcNode)); arc->adjvex = v2; arc->nextarc = G->vertices[v1].firstarc; G->vertices[v1].firstarc = arc; ++G->arcnum; ++G->vertices[v2].indegree; } return OK; } Status TopologicalSort(ALGraph G) { int count = 0; int *stack = (int *) malloc(G.vexnum * sizeof(int)); int top = -1; for (int i = 0; i < G.vexnum; ++i) { if (G.vertices[i].indegree == 0) { stack[++top] = i; } } while (top != -1) { int v = stack[top--]; printf("%c ", G.vertices[v].data); ++count; for (ArcNode *arc = G.vertices[v].firstarc; arc != NULL; arc = arc->nextarc) { int w = arc->adjvex; if (--G.vertices[w].indegree == 0) { stack[++top] = w; } } } free(stack); if (count != G.vexnum) { return ERROR; } else { return OK; } } int main() { ALGraph G; CreateGraph(&G); if (TopologicalSort(G) == OK) { printf("\nno ring"); } else { printf("\nhas ring"); } return 0; }

c语言实现拓扑排序算法

拓扑排序是一种对有向无环图进行排序的算法，可以用来解决任务调度、依赖关系等问题。以下是用C语言实现拓扑排序的代码： c #include <stdio.h> #include <stdlib.h> #define MAX_VERTEX_NUM 100 typedef struct ArcNode { int adjvex; // 该弧所指向的顶点的位置 struct ArcNode* nextarc; // 指向下一条弧的指针 } ArcNode; typedef struct VertexNode { int data; // 顶点信息 int inDegree; // 入度 ArcNode* firstarc; // 指向第一条依附该顶点的弧的指针 } VertexNode, AdjList[MAX_VERTEX_NUM]; typedef struct { AdjList vertices; // 邻接表 int vexnum, arcnum; // 顶点数和弧数 } ALGraph; // 初始化邻接表 void InitGraph(ALGraph* G, int vertexNum) { G->vexnum = vertexNum; G->arcnum = 0; for (int i = 0; i < vertexNum; i++) { G->vertices[i].data = i; G->vertices[i].inDegree = 0; G->vertices[i].firstarc = NULL; } } // 添加一条边<v,w>，即在邻接表中添加一个弧<v,w>，v的出度+1，w的入度+1 void AddArc(ALGraph* G, int v, int w) { ArcNode* arc = (ArcNode*)malloc(sizeof(ArcNode)); arc->adjvex = w; arc->nextarc = G->vertices[v].firstarc; G->vertices[v].firstarc = arc; G->vertices[w].inDegree++; G->arcnum++; } // 拓扑排序 void TopologicalSort(ALGraph* G) { int S[MAX_VERTEX_NUM], top = -1; // 模拟栈 int count = 0; // 记录输出顶点的个数 for (int i = 0; i < G->vexnum; i++) { if (G->vertices[i].inDegree == 0) { S[++top] = i; // 将入度为0的顶点入栈 } } while (top != -1) { int v = S[top--]; // 出栈 printf("%d ", G->vertices[v].data); count++; // 遍历v的所有邻接点 for (ArcNode* arc = G->vertices[v].firstarc; arc != NULL; arc = arc->nextarc) { int w = arc->adjvex; if (--G->vertices[w].inDegree == 0) { S[++top] = w; // 入度为0则入栈 } } } if (count < G->vexnum) { printf("There is a cycle in the graph.\n"); } } int main() { ALGraph G; int n, m, v, w; printf("Enter the number of vertices and arcs: "); scanf("%d%d", &n, &m); InitGraph(&G, n); printf("Enter the head and tail of each arc:\n"); for (int i = 0; i < m; i++) { scanf("%d%d", &v, &w); AddArc(&G, v, w); } printf("Topological sort result: "); TopologicalSort(&G); return 0; } 在这个实现中，我们用邻接表来存储有向图，并在每个顶点中记录它的入度。在拓扑排序过程中，我们首先将所有入度为0的顶点入栈，然后不断出栈并输出，同时将它的邻接点的入度减1，如果减为0则入栈。如果所有顶点都被输出，则拓扑排序成功，否则说明有环存在。

数据结构用队列实现拓扑排序、逆拓扑排序C语言代码

以下使用队列实现拓扑排序和逆拓扑排序的示例代码（C语言）： c #include <stdio.h> #include <stdlib.h> #define MAX_VERTICES 100 typedef struct Node { int vertex; struct Node* next; } Node; typedef struct Graph { int numVertices; int* indegree; Node** adjLists; } Graph; typedef struct Queue { int front; int rear; int size; int capacity; int* elements; } Queue; Graph* createGraph(int numVertices) { Graph* graph = (Graph*)malloc(sizeof(Graph)); graph->numVertices = numVertices; graph->indegree = (int*)malloc(numVertices * sizeof(int)); for (int i = 0; i < numVertices; i++) { graph->indegree[i] = 0; } graph->adjLists = (Node**)malloc(numVertices * sizeof(Node*)); for (int i = 0; i < numVertices; i++) { graph->adjLists[i] = NULL; } return graph; } void addEdge(Graph* graph, int src, int dest) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->vertex = dest; newNode->next = graph->adjLists[src]; graph->adjLists[src] = newNode; graph->indegree[dest]++; } Queue* createQueue(int capacity) { Queue* queue = (Queue*)malloc(sizeof(Queue)); queue->front = 0; queue->rear = -1; queue->size = 0; queue->capacity = capacity; queue->elements = (int*)malloc(capacity * sizeof(int)); return queue; } int isEmpty(Queue* queue) { return queue->size == 0; } int isFull(Queue* queue) { return queue->size == queue->capacity; } void enqueue(Queue* queue, int item) { if (isFull(queue)) { printf("Queue is full.\n"); return; } queue->rear = (queue->rear + 1) % queue->capacity; queue->elements[queue->rear] = item; queue->size++; } int dequeue(Queue* queue) { if (isEmpty(queue)) { printf("Queue is empty.\n"); return -1; } int item = queue->elements[queue->front]; queue->front = (queue->front + 1) % queue->capacity; queue->size--; return item; } void topologicalSort(Graph* graph) { int* result = (int*)malloc(graph->numVertices * sizeof(int)); int index = 0; Queue* queue = createQueue(graph->numVertices); for (int i = 0; i < graph->numVertices; i++) { if (graph->indegree[i] == 0) { enqueue(queue, i); } } while (!isEmpty(queue)) { int vertex = dequeue(queue); result[index++] = vertex; Node* temp = graph->adjLists[vertex]; while (temp != NULL) { int adjVertex = temp->vertex; graph->indegree[adjVertex]--; if (graph->indegree[adjVertex] == 0) { enqueue(queue, adjVertex); } temp = temp->next; } } if (index != graph->numVertices) { printf("Graph contains a cycle, topological sorting not possible.\n"); return; } printf("Topological Sort: "); for (int i = 0; i < graph->numVertices; i++) { printf("%d ", result[i]); } printf("\n"); free(result); } void reverseTopologicalSort(Graph* graph) { int* result = (int*)malloc(graph->numVertices * sizeof(int)); int index = graph->numVertices - 1; Queue* queue = createQueue(graph->numVertices); for (int i = 0; i < graph->numVertices; i++) { if (graph->indegree[i] == 0) { enqueue(queue, i); } } while (!isEmpty(queue)) { int vertex = dequeue(queue); result[index--] = vertex; Node* temp = graph->adjLists[vertex]; while (temp != NULL) { int adjVertex = temp->vertex; graph->indegree[adjVertex]--; if (graph->indegree[adjVertex] == 0) { enqueue(queue, adjVertex); } temp = temp->next; } } if (index != -1) { printf("Graph contains a cycle, reverse topological sorting not possible.\n"); return; } printf("Reverse Topological Sort: "); for (int i = 0; i < graph->numVertices; i++) { printf("%d ", result[i]); } printf("\n"); free(result); } int main() { int numVertices, numEdges; printf("Enter the number of vertices and edges: "); scanf("%d %d", &numVertices, &numEdges); Graph* graph = createGraph(numVertices); printf("Enter the edges (source vertex and destination vertex):\n"); for (int i = 0; i < numEdges; i++) { int src, dest; scanf("%d %d", &src, &dest); addEdge(graph, src, dest); } topologicalSort(graph); reverseTopologicalSort(graph); return 0; } 在这段代码中，我们首先定义了 Node 结构体表示图的顶点，并使用邻接表的形式存储图的边关系。然后定义了 Graph 结构体表示图的基本属性，包括顶点个数、入度数组和邻接表数组。接下来，定义了 Queue 结构体表示队列，并实现了相关的队列操作函数。最后，实现了拓扑排序和逆拓扑排序的函数，并在 main 函数中进行测试。 希望这段代码对你有帮助！如果还有其他问题，请随时提问。

根据输入，输出有向图的拓扑排序序列。并画出有向图。输入: ABCDEF# 0,1 1,2 2,3 4,1 4,5 -1,-1

根据输入，我们可以得到以下图示： A -> B -> C -> D ^ | | | +-------<------+ | V F <- E 其中，0-5分别代表A-F这六个顶点。根据拓扑排序的定义，我们可以得到以下序列： A -> E -> F -> B -> C -> D 因此，输出为：AEFBCD 以下是Python代码实现： python from collections import defaultdict def topological_sort(graph): # 统计每个顶点的入度数 in_degree = defaultdict(int) for u in graph: for v in graph[u]: in_degree[v] += 1 # 将入度为0的顶点加入队列 queue = [u for u in graph if in_degree[u] == 0] # 拓扑排序 result = [] while queue: u = queue.pop(0) result.append(u) for v in graph[u]: in_degree[v] -= 1 if in_degree[v] == 0: queue.append(v) return result # 输入 nodes, edges = input().split('#') nodes = list(nodes) graph = defaultdict(list) for edge in edges.split(): u, v = map(int, edge.split(',')) if u == -1 and v == -1: break graph[nodes[u]].append(nodes[v]) # 拓扑排序 result = topological_sort(graph) # 输出结果 print('->'.join(result)) 输入：ABCDEF# 0,1 1,2 2,3 4,1 4,5 -1,-1 输出：A->E->F->B->C->D

拓扑排序c语言

拓扑排序是一种图论算法，用于将有向无环图（DAG）中的节点排序。以下是一个基于C语言的拓扑排序算法的示例代码： c #include <stdio.h> #include <stdlib.h> #define MAX_VERTICES 100 typedef struct { int vertex; int weight; struct Node* next; } Node; Node* createNode(int vertex, int weight, Node* next) { Node* newNode = (Node*) malloc(sizeof(Node)); newNode->vertex = vertex; newNode->weight = weight; newNode->next = next; return newNode; } Node* graph[MAX_VERTICES]; int visited[MAX_VERTICES]; int inDegree[MAX_VERTICES]; void addEdge(int source, int destination, int weight) { Node* newNode = createNode(destination, weight, graph[source]); graph[source] = newNode; inDegree[destination]++; } void topologicalSort(int vertices) { int i, vertex; Node* temp; int queue[MAX_VERTICES], front = 0, rear = -1; for (i = 0; i < vertices; i++) { visited[i] = 0; if (inDegree[i] == 0) { queue[++rear] = i; } } while (front <= rear) { vertex = queue[front++]; printf("%d ", vertex); visited[vertex] = 1; for (temp = graph[vertex]; temp != NULL; temp = temp->next) { if (!visited[temp->vertex]) { inDegree[temp->vertex]--; if (inDegree[temp->vertex] == 0) { queue[++rear] = temp->vertex; } } } } } int main() { int vertices, edges, i, source, destination, weight; printf("Enter the number of vertices: "); scanf("%d", &vertices); for (i = 0; i < vertices; i++) { graph[i] = NULL; inDegree[i] = 0; } printf("Enter the number of edges: "); scanf("%d", &edges); for (i = 0; i < edges; i++) { printf("Enter source, destination and weight of edge %d: ", i); scanf("%d%d%d", &source, &destination, &weight); addEdge(source, destination, weight); } printf("\nTopological sort: "); topologicalSort(vertices); return 0; } 这个示例代码中，我们首先定义了一个Node结构体，用于表示有向图中的节点。然后，我们创建一个graph数组，用于存储有向图中的节点，以及一个visited数组和一个inDegree数组，分别用于标记节点是否被访问过以及每个节点的入度。接着，我们实现了一个createNode函数，用于创建新的节点。 在主函数中，我们首先读入有向图的顶点数和边数，然后使用addEdge函数添加边。最后，我们调用topologicalSort函数进行拓扑排序，并输出排序结果。 在topologicalSort函数中，我们首先将所有入度为0的节点加入队列中，然后从队列中取出一个节点并输出它。接着，我们遍历该节点的所有邻居节点，并将它们的入度减1。如果某个邻居节点的入度变为0，则将它加入队列中。重复以上步骤直到队列为空。

带权图求拓扑序列

对于带权图，不能直接使用拓扑排序算法求出拓扑序列。需要进行一些修改。 首先，我们需要定义一个数组 $dist$，表示从起点到该点的最长路径长度。初始时，$dist[i]$ 的值应为 $-\infty$，表示还没有遍历到该点。 然后，我们对图进行拓扑排序。在每个点 $u$ 被遍历到时，更新其所有出边指向的点 $v$ 的 $dist$ 值，即 $dist[v] = \max(dist[v], dist[u] + w(u, v))$，其中 $w(u, v)$ 表示边 $(u, v)$ 的权值。 最后，按照拓扑排序的结果，按照 $dist$ 值从大到小进行排序即可得到带权图的拓扑序列。 代码实现如下： python from collections import deque def topological_sort(graph, indegree): n = len(graph) queue = deque() for i in range(n): if indegree[i] == 0: queue.append(i) order = [] while queue: u = queue.popleft() order.append(u) for v in graph[u]: indegree[v] -= 1 if indegree[v] == 0: queue.append(v) return order def weighted_topological_sort(graph, indegree, weights): n = len(graph) dist = [-float('inf')] * n dist[0] = 0 order = topological_sort(graph, indegree) order.sort(key=lambda u: -dist[u]) for u in order: for v, w in graph[u]: dist[v] = max(dist[v], dist[u] + weights[(u, v)]) return order 其中，$graph$ 表示图的邻接表，$indegree$ 表示每个点的入度，$weights$ 是一个字典，表示每条边的权值。函数 $topological\_sort$ 是普通的拓扑排序算法，$weighted\_topological\_sort$ 则是带权图的拓扑排序算法。

用C++实现用栈的拓扑排序

拓扑排序是对有向图进行排序的一种方法，可以用来解决诸如任务调度等问题。栈可以用来存储入度为0的节点，因此可以用栈来实现拓扑排序。 以下是用C++实现用栈的拓扑排序的示例代码： c++ #include <iostream> #include <vector> #include <stack> using namespace std; void topologicalSort(vector<vector<int>>& graph, vector<int>& inDegree) { stack<int> s; int n = graph.size(); for (int i = 0; i < n; i++) { if (inDegree[i] == 0) { s.push(i); } } while (!s.empty()) { int cur = s.top(); s.pop(); cout << cur << " "; for (int next : graph[cur]) { inDegree[next]--; if (inDegree[next] == 0) { s.push(next); } } } } int main() { vector<vector<int>> graph = { {1, 2}, {3}, {3}, {} }; vector<int> inDegree = {0, 1, 1, 2}; topologicalSort(graph, inDegree); // 输出：0 1 2 3 return 0; } 在上面的示例代码中，我们首先遍历所有节点，将入度为0的节点压入栈中。然后，每次从栈中弹出一个节点，输出该节点，并将该节点指向的所有节点的入度减1。如果减1后某个节点的入度为0，则将该节点压入栈中。重复此过程直到栈为空，即可得到拓扑排序的结果。

字典序最小拓扑排序C++模版

以下是一个用C++实现的拓扑排序的模板： cpp #include <iostream> #include <vector> #include <queue> using namespace std; vector<int> topologicalSort(vector<vector<int>>& graph) { int n = graph.size(); vector<int> inDegree(n, 0); for (int i = 0; i < n; i++) { for (int j : graph[i]) { inDegree[j]++; } } vector<int> result; queue<int> q; for (int i = 0; i < n; i++) { if (inDegree[i] == 0) { q.push(i); } } while (!q.empty()) { int curr = q.front(); q.pop(); result.push_back(curr); for (int next : graph[curr]) { inDegree[next]--; if (inDegree[next] == 0) { q.push(next); } } } return result; } int main() { int n, m; cin >> n >> m; vector<vector<int>> graph(n); for (int i = 0; i < m; i++) { int u, v; cin >> u >> v; graph[u].push_back(v); } vector<int> sorted = topologicalSort(graph); for (int node : sorted) { cout << node << " "; } cout << endl; return 0; } 这个模板使用邻接表表示有向图，通过计算每个节点的入度，然后利用队列进行拓扑排序。输出结果即为字典序最小的拓扑排序序列。输入部分需要提供节点数目n和边数目m，然后依次输入每一条边的起始节点u和终止节点v。输出结果为拓扑排序的节点序列。

最新推荐

代码随想录最新第三版-最强八股文

这份PDF就是最强⼋股⽂！ 1. C++ C++基础、C++ STL、C++泛型编程、C++11新特性、《Effective STL》 2. Java Java基础、Java内存模型、Java面向对象、Java集合体系、接口、Lambda表达式、类加载机制、内部类、代理类、Java并发、JVM、Java后端编译、Spring 3. Go defer底层原理、goroutine、select实现机制 4. 算法学习 数组、链表、回溯算法、贪心算法、动态规划、二叉树、排序算法、数据结构 5. 计算机基础 操作系统、数据库、计算机网络、设计模式、Linux、计算机系统 6. 前端学习 浏览器、JavaScript、CSS、HTML、React、VUE 7. 面经分享 字节、美团Java面、百度、京东、暑期实习...... 8. 编程常识 9. 问答精华 10.总结与经验分享 ......

基于交叉模态对应的可见-红外人脸识别及其表现评估

12046通过调整学习：基于交叉模态对应的可见-红外人脸识别Hyunjong Park*Sanghoon Lee*Junghyup Lee Bumsub Ham†延世大学电气与电子工程学院https://cvlab.yonsei.ac.kr/projects/LbA摘要我们解决的问题，可见光红外人重新识别（VI-reID），即，检索一组人的图像，由可见光或红外摄像机，在交叉模态设置。VI-reID中的两个主要挑战是跨人图像的类内变化，以及可见光和红外图像之间的跨模态假设人图像被粗略地对准，先前的方法尝试学习在不同模态上是有区别的和可概括的粗略的图像或刚性的部分级人表示然而，通常由现成的对象检测器裁剪的人物图像不一定是良好对准的，这分散了辨别性人物表示学习。在本文中，我们介绍了一种新的特征学习框架，以统一的方式解决这些问题。为此，我们建议利用密集的对应关系之间的跨模态的人的形象，年龄。这允许解决像素级中�

rabbitmq客户端账号密码

在默认情况下，RabbitMQ的客户端账号和密码是"guest"。 但是，默认情况下，这个账号只能在localhost本机下访问，无法远程登录。如果需要添加一个远程登录的用户，可以使用命令rabbitmqctl add_user来添加用户，并使用rabbitmqctl set_permissions设置用户的权限。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [保姆级别带你入门RabbitMQ](https:

数据结构1800试题.pdf

你还在苦苦寻找数据结构的题目吗？这里刚刚上传了一份数据结构共1800道试题，轻松解决期末挂科的难题。不信？你下载看看，这里是纯题目，你下载了再来私信我答案。按数据结构教材分章节，每一章节都有选择题、或有判断题、填空题、算法设计题及应用题，题型丰富多样，共五种类型题目。本学期已过去一半，相信你数据结构叶已经学得差不多了，是时候拿题来练练手了，如果你考研，更需要这份1800道题来巩固自己的基础及攻克重点难点。现在下载，不早不晚，越往后拖，越到后面，你身边的人就越卷，甚至卷得达到你无法想象的程度。我也是曾经遇到过这样的人，学习，练题，就要趁现在，不然到时你都不知道要刷数据结构题好还是高数、工数、大英，或是算法题？学完理论要及时巩固知识内容才是王道！记住！！！下载了来要答案（v:zywcv1220）。

通用跨域检索的泛化能力

12056通用跨域检索：跨类和跨域的泛化2* Soka Soka酒店，Soka-马上预订;1印度理工学院，Kharagpur，2印度科学学院，班加罗尔soumava2016@gmail.com，{titird，somabiswas} @ iisc.ac.in摘要在这项工作中，我们第一次解决了通用跨域检索的问题，其中测试数据可以属于在训练过程中看不到的类或域。由于动态增加的类别数量和对每个可能的域的训练的实际约束，这需要大量的数据，所以对看不见的类别和域的泛化是重要的。为了实现这一目标，我们提出了SnMpNet（语义Neighbourhood和混合预测网络），它包括两个新的损失，以占在测试过程中遇到的看不见的类和域。具体来说，我们引入了一种新的语义邻域损失，以弥合可见和不可见类之间的知识差距，并确保潜在的空间嵌入的不可见类是语义上有意义的，相对于其相邻的类。我们还在图像级以及数据的语义级引入了基于混�

lua tm1637

TM1637是一种数字管显示驱动芯片，它可以用来控制4位7段数码管的显示。Lua是一种脚本语言，可以用于嵌入式系统和应用程序的开发。如果你想在Lua中使用TM1637驱动数码管，你需要先获取一个适配Lua的TM1637库或者编写自己的驱动代码。然后，你可以通过该库或者代码来控制TM1637芯片，实现数码管的显示功能。

TFT屏幕-ILI9486数据手册带命令标签版.pdf

ILI9486手册 官方手册 ILI9486 is a 262,144-color single-chip SoC driver for a-Si TFT liquid crystal display with resolution of 320RGBx480 dots, comprising a 960-channel source driver, a 480-channel gate driver, 345,600bytes GRAM for graphic data of 320RGBx480 dots, and power supply circuit. The ILI9486 supports parallel CPU 8-/9-/16-/18-bit data bus interface and 3-/4-line serial peripheral interfaces (SPI). The ILI9486 is also compliant with RGB (16-/18-bit) data bus for video image display. For high speed serial interface, the ILI9486 also provides one data and clock lane and supports up to 500Mbps on MIPI DSI link. And also support MDDI interface.

生成模型的反事实解释方法及其局限性

693694不能很好地可视化/解释非空间定位的属性，如大小、颜色等。此外，它们可以显示图像的哪些区域可以被改变以影响分类，但不显示它们应该如何被改变。反事实解释通过提供替代输入来解决这些限制，其中改变一小组属性并且观察到不同的分类结果。生成模型是产生视觉反事实解释的自然候选者，事实上，最近的工作已经朝着这个目标取得了进展在[31，7，32，1]中，产生了生成的反事实解释，但它们的可视化立即改变了所有相关属性，如图所示。二、[29]中提供的另一种相关方法是使用来自分类器的深度表示来以不同粒度操纵生成的图像然而，这些可能涉及不影响分类结果的性质，并且还组合了若干属性。因此，这些方法不允许根据原子属性及其对分类的影响来其他解释方法使用属性生成反事实，其中可以对所需属性进行完全或部分监督[10，5

login_method

`login_method` 可以指代一个函数或方法，它的作用是用于实现用户登录的逻辑。具体实现方式可能因应用场景而异。例如，对于 web 应用程序，`login_method` 可以是一个视图函数，它接受用户提交的登录表单，验证用户信息，如果验证通过则创建会话并将用户信息保存在会话中；对于桌面应用程序，`login_method` 可以是一个类方法，它接受用户输入的登录信息，验证用户身份，如果验证通过则创建用户对象并保存在内存中，以便后续操作使用。总之，`login_method` 的作用是实现用户身份验证并创建用户会话或对象。

freescale IMX6 开发板原理图

freesacle 的arm cortex-a9的双核 四核管脚兼容CPU开发板原理图。