ACM经典模版之拓扑排序Word格式.docx

ACM经典模版之拓扑排序Word格式.docx

《ACM经典模版之拓扑排序Word格式.docx》由会员分享，可在线阅读，更多相关《ACM经典模版之拓扑排序Word格式.docx（41页珍藏版）》请在冰豆网上搜索。

<

"

请输入该矩阵的点的个数和边的个数：

"

endl;

cin>

>

T.points>

T.sides;

while（T.points<

=0&

&

T.sides>

0）

cout<

数据不符合规范！

请重新输入！

<

endl;

cin>

T.points;

T.sides;

}//T.ponits

//为邻接矩阵分配合适大小的空间

T.matrix=newbool*[T.points+1];

T.matrix[i]=newbool[T.points+1];

//输入

for（j=0;

j++）

cin>

T.matrix[i][j];

T.data=newinfro[T.points+1];

请输入"

T.points<

个点的信息：

T.data[i];

}//InitiGraph

//输出拓扑排序的结果

voidTopologicalSort（My_Graph&

inti;

intv;

int*indgree;

indgree=newint[T.points+1];

SqStackS;

InitStack（S）;

FindInDegree（T,indgree）;

if（indgree[i]==0）

Push（S,i）;

while（!

StackEmpty（S））

Pop（S,i）;

T.data[i]<

;

for（v=0;

v<

v++）

if（T.matrix[i][v]!

=0）

{

indgree[v]--;

if（indgree[v]==0）

Push（S,v）;

}//if

}//forv

}//while

}//TopologicalSort

图的操作：

boolStackEmpty（SqStackS）

if（S.base==S.top）

returnfalse;

else

returntrue;

}//StackEmpty

//****************************************************************************************************

//寻找第一个邻接的位置

intFirstAdjVex（My_Graph&

T,inti）

for（v=0;

if（T.matrix[i][v]==1）

returnv;

return-1;

}//FirstAdjVex

//寻找下一个邻接的位置

intNextAdjVex（My_Graph&

T,inti,intw）

for（v=w+1;

return-1;

}//NextAdjVex

//DFS递归遍历的工具

voidDFS_Recurrence（My_Graph&

T,inti,bool*visited）

intw;

visited[i]=true;

printf（"

%3c"

i+'

A'

）;

for（w=FirstAdjVex（T,i）;

w>

=0;

w=NextAdjVex（T,i,w））

//cout<

w<

if（visited[w]==false）

DFS_Recurrence（T,w,visited）;

}//forw

}//DFS_Recurrence

//DFS_非递归_工具

voidDFS_Nonrecursive（My_Graph&

T,SqStack&

S,inti,bool*visited）

intu;

if（visited[i]==false）

visited[i]=true;

printf（"

%5c"

'

+i）;

Push（S,i）;

while（StackEmpty（S））

GetTop（S,i）;

u=FirstAdjVex（T,i）;

while（u>

if（visited[u]==false）

{

printf（"

%3c"

'

+u）;

visited[u]=true;

Push（S,u）;

u=FirstAdjVex（T,u）;

}

else

GetTop（S,v）;

u=NextAdjVex（T,v,u）;

}//while

}//if

}//DFS_Nonrecursive

//DFS_递归_遍历

voidDFS_Recurrence_Traverse（My_Graph&

bool*visited;

visited=newbool[T.points+2];

visited[i]=false;

if（visited[i]==false）

DFS_Recurrence（T,i,visited）;

}//fori

}//DFS_Recurrence_Traverse

//DFS_非递归_遍历

voidDFS_Nonrecursive_Traverse（My_Graph&

InitiStack（S）;

visited=newbool[T.points+2];

i++）

DFS_Nonrecursive（T,S,i,visited）;

}//DFS_Nonrecursive_Traverse

//BFS_遍历

voidBFS_Traverse（My_Graph&

sqQueueQ;

IninQueue（Q）;

T.points+1;

intw,u;

for（i=0;

printf（"

visited[i]=true;

EnQueue（Q,i）;

while（QueueEmpty（Q））

DeQueue（Q,u）;

for（w=FirstAdjVex（T,u）;

=0;

w=NextAdjVex（T,u,w））

if（visited[w]==false）

{

printf（"

+w）;

visited[w]=true;

EnQueue（Q,w）;

}

}//forw

}//whilenotnull

}//ifvisited

}//BFS_Traverse

//关键路径求VE的函数，并且保存VE点，返回一个拓扑序列，保存在T中

intTopologicalOder（My_Graph&

G,SqStack&

T,int*ve）

intcout=0;

inti,j,k,v;

int*indegree;

indegree=newint[G.points+1];

i<

G.points;

i++）//对VE和INDEGREE数组进行初始化

indegree[i]=ve[i]=0;

FindInDegree（G,indegree）;

i++）//把入度为0的点，压入栈中

if（indegree[i]==0）

while（!

StackEmpty（S））//栈不为空，表示栈中还存在的有入度为0的点

Pop（S,j）;

Push（T,j）;

//压入一个拓扑序列中

cout++;

if（G.matrix[j][v]!

indegree[v]--;

if（indegree[v]==0）

if（ve[j]+G.matrix[j][v]>

ve[v]）//动态转移，找到（最大）最早发生时间

ve[v]=ve[j]+G.matrix[j][v];

}//ifG.matrix[j][v]!

=0

if（cout<

G.points）

return0;

return1;

}//TopologicalOder

//求关键路径的主函数

voidGriticalPath（My_GraphM）

int*ve,*vl,e,l;

ve=newint[M.points+1];

vl=newint[M.points+1];

SqStackT;

InitStack（T）;

if（!

TopologicalOder（M,T,ve））

图中有环！

exit（0）;

}

M.points;

i++）//初始化赋值为：

最大的值，即是出度为0点

vl[i]=ve[M.points-1];

StackEmpty（T））

for（Pop（T,j）,v=0;

if（M.matrix[j][v]!

if（vl[v]-M.matrix[j][v]<

vl[j]）//动态转移，寻找最迟发生的点（即是逆序求值最小的点）

vl[j]=vl[v]-M.matrix[j][v];

}//if

if（M.matrix[i][v]!

=0）//寻找最短路径（当活动发生时间和开始时间相当即为最短路径的点）

e=ve[i];

l=vl[v]-M.matrix[i][v];

if（e==l）

cout<

点"

M.data[i]<

到点"

M.data[v]<

是关键路径，长度为"

M.matrix[i][v]<

}

}//for

}//GriticalPath

//用于将字符加入到字符串中

voidadd（charp[],inti,int&

len,intstart）

if（len==0）//设置起点为，预订的点（A）

p[len++]='

+start;

p[len]=char（'

//记录

p[len+1]='

\0'

//设置结束符

len++;

//长度加1

}//add

//将字符串清理

voidempty（charp[]）//将字符清理，消除乱码

memset（p,0,sizeof（p））;

}//empty

//复制路径函数

voidcopy（chara[],charb[]）

strcpy（a,b）;

}//copy

public:

T.matrix=newint*[T.points+1];

T.matrix[i]=newint[T.points+1];

T.data=newinfor[T.points+1];

//老师所讲的方法，利用字符串保存路径

voidShorterstPath1_DIJ（constMy_GraphM,intstart,Elem*D,char*p[]）

constintMAX=999999;

inti,j,k;

intmin;

bool*S;

S=newbool[M.points+1];

int*len;

len=newint[M.points];

//初始化

len[i]=0;

//将每一个点的路径初始为空

S[i]=false;

//每一个点为设置没有加入到集合S中

D[i]=M.matrix[start][i];

//保存初始的路径长度

if（D[i]<

MAX）

p[i][0]='

len[i]++;

add（p[i],i,len[i],start）;

}

else

empty（p[i]）;

S[start]=1;

//将起点加入到集合S中

intpos;

//最短路径的位置

for（i=1;

min=MAX;

pos=0;

j++）//找到起点到各个点的的最小路径长度

if（S[j]!

=true&

min>

D[j]）

min=D[j];

pos=j;

S[pos]=true;

//加入到S集合中

for（k=0;

k<

k++）

if（S[k]!

D[k]>

M.matrix[pos][k]+min）

D[k]=M.matrix[pos][k]+min;

//更新路径长度

copy（p[k],p[pos]）;

//保存和设置路径

len[k]=strlen（p[pos]）;

add（p[k],k,len[k],start）;

}//fork

}//ShorterstPath1_DIJ

//******************************************************************************

格雷码模拟（九连环模拟）

//给一串01序列，按九连环方法（1为环）取下所有环，求最少步数（POJ1090）

#include<

iostream>

usingnamespacestd;

inta[1001],b[1001];

intans[200],flag[200];

intmain（）

intn;

cin>

n;

//freopen（"

car.in"

"

r"

stdin）;

car.out"

w"

stdout）;

memset（a,0,sizeof（a））;

memset（b,0,sizeof（b））;

memset（ans,0,sizeof（ans））;

memset（flag,0,sizeof（flag））;

inti,j;

for（i=0;

i<

++i）

a[i];

if（a[i]）j=i;

}

=j;

++i）b[i]=a[j-i];

for（i=1;

++i）b[i]=b[i-1]^b[i];

intlen1,len2,t;

flag[