Tema Descripción
La obtención de un orden total en un conjunto a partir de un orden parcial en ese conjunto se denomina clasificación topológica. Las definiciones de orden parcial y orden total son las siguientes:
Si la relación R sobre el conjunto X es reflexiva, antisimétrica y transitiva, entonces se dice que R es una relación de orden parcial sobre el conjunto X.
Sea R un orden parcial sobre el conjunto X, si para cada x, y∈X debe existir xRy o yRx, entonces se dice que R es un orden total sobre el conjunto X.
La operación de obtener un orden topológico mediante la definición de orden parcial es la clasificación topológica.
El proceso de clasificación topológica es el siguiente:
1. Seleccione un vértice sin predecesor en el gráfico dirigido y envíelo;
2. Elimine el vértice y todos los arcos que salen de él del gráfico.
Repita los dos pasos anteriores hasta que se hayan generado todos los vértices o no haya vértices sin predecesores en el gráfico actual. El último caso indica que hay un ciclo en el gráfico dirigido.
La lista de adyacencia se usa para almacenar el gráfico dirigido, y la pila se usa para almacenar temporalmente todos los vértices con grado de entrada cero. El algoritmo de clasificación topológica se puede describir de la siguiente manera:
En esta pregunta, lea una matriz de adyacencia de un gráfico dirigido (es decir, una representación de matriz), construya un gráfico dirigido y juzgue si el gráfico tiene un bucle de acuerdo con el algoritmo descrito anteriormente, y genere una secuencia de vértices ordenada topológicamente si hay no hay bucle.
ingresar
La primera línea de entrada contiene un número entero positivo n, lo que indica que hay n vértices en el gráfico. donde n no excede de 50.
Cada una de las siguientes n líneas tiene n enteros separados por espacios 0 o 1. Para el j-ésimo entero en la i-ésima línea, si es 1, significa que el i-ésimo vértice tiene un borde dirigido que apunta al j -ésimo vértice, 0 significa que no hay un borde dirigido de i a j. Cuando i y j son iguales, se garantiza que el entero correspondiente es 0.
producción
Si la lectura del gráfico dirigido contiene ciclos, genera "ERROR" sin comillas.
Si el gráfico dirigido de lectura no contiene bucles, siga el algoritmo en la descripción del tema para generar la secuencia ordenada topológicamente del gráfico a su vez y generar un espacio después de cada número entero.
Tenga en cuenta la salida de nueva línea al final de la línea.
#include <iostream>
#include <iomanip>
using namespace std;
#define Max 1000
#define MVNum 100 //最大顶点数
#define OK 1
#define ERROR 0
#define OVERFLOW - 2
#define MAXSIZE 10 //顺序栈存储空间的初始分配量
typedef int Status;
typedef int SElemType;
typedef int VerTexType; //顶点信息
typedef int OtherInfo; //和边相关的信息
typedef int ArcType;
//- - - - -图的邻接表存储表示- - - - -
typedef struct {
VerTexType vexs[MVNum]; //顶点表
ArcType arcs[MVNum][MVNum]; //邻接矩阵
int vexnum, arcnum; //图的当前点数和边数
} Graph;
typedef struct {
SElemType *base;//栈底指针
SElemType *top;//栈顶指针
int stacksize;//栈可用的最大容量
} SqStack;
//算法3.1 顺序栈的初始化
Status InitStack(SqStack &s)
{
//构造一个空栈S
s.base = new SElemType[MAXSIZE];//为顺序栈动态分配一个最大容量为MAXSIZE的数组空间
if(!s.base)
exit(OVERFLOW); //存储分配失败
s.top = s.base; //top初始为base，空栈
s.stacksize = MAXSIZE; //stacksize置为栈的最大容量MAXSIZE
return OK;
}
Status Push(SqStack &s, SElemType e)
{
/****在此下面完成代码***************/
if(s.top-s.base==s.stacksize)return ERROR;
*s.top=e;
s.top++;
return OK;
/***********************************/
}
//算法3.3 顺序栈的出栈
Status Pop(SqStack &s, SElemType &e)
{
/****在此下面完成代码***************/
if(s.base==s.top)return ERROR;
s.top--;
e=*s.top;
return OK;
/***********************************/
}
bool StackEmpty(SqStack S)
{
/****在此下面完成代码***************/
if(S.top==S.base)return true;
else return false;
/***********************************/
}
void CreateUDG(Graph &g)
{
//采用邻接矩阵表示法，创建无向图G
/****在此下面完成代码***************/
int i,j;
cin>>g.vexnum;
for(i=0;i<g.vexnum;i++)
{
for(j=0;j<g.vexnum;j++)
{
cin>>g.arcs[i][j];
}
}
/***********************************/
}//CreateUDN
Status TopSort(Graph g,int topo[])
{
int i,j,k,m=0,indegree[g.vexnum];
SqStack s;
InitStack(s);
for(i=0;i<g.vexnum;i++)
indegree[i]=0;
for(i=0;i<g.vexnum;i++)
{
for(j=0;j<g.vexnum;j++)
{
indegree[i]=indegree[i]+g.arcs[j][i];
}
}
for(i=0;i<g.vexnum;i++)
{
if(!indegree[i])
{
g.arcs[i][i]=1;
Push(s,i);
}
}
while(!StackEmpty(s))
{
Pop(s,i);
topo[m++]=i;
for(j=0;j<g.vexnum;j++)
{
if(g.arcs[i][j]!=0&&i!=j)
{
g.arcs[i][j]=0;indegree[j]--;
}
if(g.arcs[j][j]==0&&indegree[j]==0)
{
g.arcs[j][j]=1;
Push(s,j);
}
}
}
if(m<g.vexnum)
{
cout<<"ERROR";return 0;
}else
{
for(i=0;i<g.vexnum;i++)
{
cout<<topo[i]<<" ";
}
return 1;
}
}
int main()
{
Graph g;
CreateUDG(g);
int topo[g.vexnum];
TopSort(g,topo);
return 0;
}//mainCopia de entrada de muestra
4 0 1 0 0 0 0 1 0 0 0 0 0 0 0 1 0
Copia de salida de muestra
3 0 1 2
pista
En esta pregunta, es necesario realizar una clasificación topológica estrictamente de acuerdo con el algoritmo en la descripción del título y almacenar los vértices en secuencia durante el proceso de clasificación, y la salida no se puede realizar hasta que finalmente se determine que el gráfico dirigido no contiene un bucle.
Además, para evitar la detección repetida de vértices con cero en grado, se puede utilizar una estructura de pila para mantener los vértices con cero en grado en el proceso de procesamiento actual.