/**
* @function BuildManifold
*/
void HP2D::BuildManifold( Vertice _v0 ) {
Vertice* va;
Vertice vt;
Vertice* vb;
std::vector<Vertice> S;
std::vector<Vertice*> B;
InsertQueue( _v0 );
do{
va = PopQueue();
S = Successors( va );
for( int i = 0; i < S.size(); i++ ) {
vt = S[i];
InsertVertice( vt );
InsertEdge( &vt, va );
if( vt.GetDist() < mDIST_MAX ) {
InsertQueue( vt );
}
B = GetAdjacent( va->Adjacent() );
for( unsigned j = 0; j < B.size(); j++ ) {
vb = B[j];
if( InSet( vb->GetPos(), vt.Neighbors() ) ) {
InsertEdge( &vt, vb );
}
}
}
} while( GetSizeQueue() > 0 );
}
void main()
{
GraphMtx gm;
InitGraph(&gm);
InsertVertex(&gm,'A');
InsertVertex(&gm,'B');
InsertVertex(&gm,'C');
InsertVertex(&gm,'D');
InsertVertex(&gm,'E');
InsertVertex(&gm,'F');
InsertEdge(&gm,'A','B',6);
InsertEdge(&gm,'A','C',1);
InsertEdge(&gm,'A','D',5);
InsertEdge(&gm,'B','C',5);
InsertEdge(&gm,'B','E',3);
InsertEdge(&gm,'C','D',5);
InsertEdge(&gm,'C','E',6);
InsertEdge(&gm,'C','F',4);
InsertEdge(&gm,'D','F',2);
InsertEdge(&gm,'E','F',6);
ShowGraph(&gm);
//MinSpanTree_Prim(&gm,'E');
MinSpanTree_Kruskal(&gm);
}
//----------------------------------------------------------------------------
bool MTMesh::Insert (int label0, int label1, int label2)
{
// Insert the triangle.
int t = InsertTriangle(label0, label1, label2);
if (t == -1)
{
// The triangle already exists.
return true;
}
// Insert the vertices of the triangle.
int v0 = InsertVertex(label0);
int v1 = InsertVertex(label1);
int v2 = InsertVertex(label2);
// Insert the edges of the triangle.
int e0 = InsertEdge(label0, label1);
int e1 = InsertEdge(label1, label2);
int e2 = InsertEdge(label2, label0);
// Set the connections among the components.
MTTriangle& triangle = mTriangles[t];
MTVertex& vertex0 = mVertices[v0];
MTVertex& vertex1 = mVertices[v1];
MTVertex& vertex2 = mVertices[v2];
MTEdge& edge0 = mEdges[e0];
MTEdge& edge1 = mEdges[e1];
MTEdge& edge2 = mEdges[e2];
// Attach edges to vertices.
vertex0.InsertEdge(e2);
vertex0.InsertEdge(e0);
vertex1.InsertEdge(e0);
vertex1.InsertEdge(e1);
vertex2.InsertEdge(e1);
vertex2.InsertEdge(e2);
edge0.Vertex(0) = v0;
edge0.Vertex(1) = v1;
edge1.Vertex(0) = v1;
edge1.Vertex(1) = v2;
edge2.Vertex(0) = v2;
edge2.Vertex(1) = v0;
// Attach triangles to vertices.
vertex0.InsertTriangle(t);
vertex1.InsertTriangle(t);
vertex2.InsertTriangle(t);
triangle.Vertex(0) = v0;
triangle.Vertex(1) = v1;
triangle.Vertex(2) = v2;
// Attach triangle to edges.
AttachTriangleToEdge(t, triangle, 0, e0, edge0);
AttachTriangleToEdge(t, triangle, 1, e1, edge1);
AttachTriangleToEdge(t, triangle, 2, e2, edge2);
return true;
}
main()
{
int i,src,dst,nd[20],ttr=0;;
clrscr();
freopen("topo.in","r",stdin);
scanf("%d%d",&n,&e);
for(i=0;i<=n;i++)
{
d[i]=f[i]=NIL;
nd[i]=i;
}
EdgeInit(n);
for(i=1;i<=e;i++)
{
scanf("%d%d",&src,&dst);
InsertEdge(src,dst,NIL,i);
}
t=0;
for(i=1;i<=n;i++)
{
if(d[i]==0) {ttr+=1;printf("\nTree-%d :: ",ttr);Topo(i);}
}
/* qsort((void *) (nd+1),n,sizeof(nd[0]),SortFunction);
for(i=1;i<=n;i++)
{
printf("%d\n",*(nd+i));
}*/
fclose(stdin);
printf("\nTotal tree=%d",ttr);
printf("\nOK");
}
LGraph BuildGraph()
{
LGraph Graph;
Edge E;
Vertex V;
int Nv, i;
scanf("%d", &Nv); /* 读入顶点个数 */
Graph = CreateGraph(Nv); /* 初始化有Nv个顶点但没有边的图 */
scanf("%d", &(Graph->Ne)); /* 读入边数 */
if ( Graph->Ne != 0 ) { /* 如果有边 */
E = (Edge)malloc( sizeof(struct ENode) ); /* 建立边结点 */
/* 读入边，格式为"起点 终点 权重"，插入邻接矩阵 */
for (i=0; i<Graph->Ne; i++) {
scanf("%d %d %d", &E->V1, &E->V2, &E->Weight);
/* 注意：如果权重不是整型，Weight的读入格式要改 */
InsertEdge( Graph, E );
}
}
/* 如果顶点有数据的话，读入数据 */
for (V=0; V<Graph->Nv; V++)
scanf(" %c", &(Graph->G[V].Data));
return Graph;
}
bool GraphAdjList::InitByEdges(FILE* stream)
{
if(stream == NULL)
{
printf("null input stream\n");
return false;
}
int i, m, n, ret;
int x, y, cost;
char c;
ret = fscanf(stream, "%d %d", &m, &n);
if(ret != 2)
{
printf("invalid format: vertex num or edge num invalid\n");
return false;
}
fscanf(stream, "%c", &c);
Vertex vertex;
for(i = 0; i < m; i++)
{
vertex.index = i;
PutVertex(&vertex);
}
for(i = 0; i < n; i++)
{
ret = fscanf(stream, "%d %d %d", &x, &y, &cost);
if(ret != 3)
{
printf("invalid format: %d edge invalid\n", i);
return false;
}
fscanf(stream, "%c", &c);
InsertEdge(x, y, cost);
InsertEdge(y, x, cost);
}
//optional: reverse the list to make sure the adjacent list has the same order with input data
ReverseAdjList();
return true;
}
bool GraphAdjList::InsertEdge(int from, int to, int cost)
{
Edge edge;
edge.from = from;
edge.to = to;
edge.cost = cost;
return InsertEdge(&edge);
}
// テキストからノードとエッジを追加
void FieldGraph::LoadNode(char* fileName)
{
std::ifstream in(fileName);
int nodeMAX = 0;
in >> nodeMAX;
// ノードフェイズ
for (int i = 0; i < nodeMAX; i++)
{
int id = i; // For文順にIndex追加
Vector3 nodePos = VECTOR_ZERO;
in >> nodePos.x;
in >> nodePos.y;
in >> nodePos.z;
FieldNode* node;
node = new FieldNode();
node->m_pos = nodePos;
AddNode(node);
}
// エッジフェイズ
for (int i = 0; i < nodeMAX; i++)
{
// エッジ最大所有数
int edgeMax = 0;
in >> edgeMax ;
for (int e = 0; e < edgeMax; e++)
{
FieldEdge* insert;
insert = new FieldEdge();
int myID = i;
int toID = 0;
in >> toID;
int state;
in >> (int)state;// 追加
insert->m_from = m_nodeList[myID];
insert->m_to = m_nodeList[toID];
insert->m_defaultCost = 0;
insert->m_fieldState = (FIELD_STATE)state;// 追加
InsertEdge(m_nodeList[myID], insert);
}
}
}
///
/// MakeEdgeRec()
VOID MakeEdgeRec( Point lower, Point upper, int yComp, EdgePtr *edges, EdgePtr edge )
{
edge->dxPerScan = (upper.x - lower.x) / (upper.y - lower.y);
edge->xIntersect = lower.x;
if( upper.y < yComp )
edge->yUpper = upper.y - 1;
else
edge->yUpper = upper.y;
InsertEdge( edges[lower.y], edge );
}
void BuildActiveList(ILint scan, Edge *active, Edge *edges[])
{
Edge *p, *q;
p = edges[scan]->next;
while (p) {
q = p->next;
InsertEdge(active, p);
p = q;
}
}
void ResortActiveList(Edge *active)
{
Edge *q, *p = active->next;
active->next = NULL;
while (p) {
q = p->next;
InsertEdge(active, p);
p = q;
}
}
// Store lower-y coordinate and inverse slope for each edge. Adjust
// and store upper-y coordinate for edges that are the lower member
// of a monotonically increasing or decreasing pair of edges
void MakeEdgeRec(ILpointi lower, ILpointi upper, ILint yComp, Edge *edge, Edge *edges[])
{
edge->dxPerScan = (ILfloat)(upper.x - lower.x) / (upper.y - lower.y);
edge->xIntersect = (ILfloat)lower.x;
if (upper.y < yComp)
edge->yUpper = upper.y - 1;
else
edge->yUpper = upper.y;
InsertEdge(edges[lower.y], edge);
}
///
/// BuildActiveList()
VOID BuildActiveList( int scan, EdgePtr *edges, EdgePtr active )
{
EdgePtr p, q;
p = edges[scan]->next;
while( p ) {
q = p->next;
InsertEdge( active, p );
p = q;
}
}
bool GraphAdjList::InitByMatrix(FILE* stream)
{
if(stream == NULL)
{
printf("null input stream\n");
return false;
}
int ret, m, i, j, cost;
char c;
ret = fscanf(stream, "%d%c", &m, &c);
if(ret != 2)
{
printf("invalid format: vertex num invalid\n");
return false;
}
Vertex vertex;
for(i = 0; i < m; i++)
{
vertex.index = i;
PutVertex(&vertex);
for(j = 0; j < m; j++)
{
ret = fscanf(stream, "%d", &cost);
if(ret != 1)
{
printf("invalid format: cell(%d, %d) invalid\n");
return false;
}
ret = fscanf(stream, "%c", &c);
if(ret != 1)
{
printf("invalid format: no trailing char after cell(%d, %d)\n", i, j);
return false;
}
if(cost == 0)
{
continue;
}
InsertEdge(i, j, cost);
}
}
vexnum = m;
//optional: reverse the list to make sure the adjacent list has the same order with input data
ReverseAdjList();
return true;
}
void main()
{
GraphLnk gl;
InitGraph(&gl);
InsertVertex(&gl,'A');
InsertVertex(&gl,'B');
InsertVertex(&gl,'C');
InsertVertex(&gl,'D');
InsertVertex(&gl,'E');
InsertEdge(&gl,'A','B');
InsertEdge(&gl,'A','D');
InsertEdge(&gl,'B','C');
InsertEdge(&gl,'B','E');
InsertEdge(&gl,'C','D');
InsertEdge(&gl,'C','E');
ShowGraph(&gl);
//RemoveEdge(&gl,'A','C');
//RemoveVertex(&gl,'C');
ShowGraph(&gl);
//int v = GetFirstNeighbor(&gl,'A');
int v = GetNextNeighbor(&gl,'B','A');
DestroyGraph(&gl);
}
void ReadTri(char *infile)
{
FILE *fp;
if((fp=fopen(infile,"r"))==NULL)
{
//文本只读方式重新打开文件
printf("cannot open file:%s\n",infile);
return ;
}
int64_t key,node1,node2, pre=-1;
int pos = 0,count = 0, flag = -1;
int64_t *Graph = (int64_t *)malloc(sizeof(int64_t)*NUM);
memset(Graph,0,sizeof(int64_t)*NUM);
while(fscanf(fp,"%lld%lld%lld",&key,&node1,&node2) != EOF)
{
// printf("%lld,%lld,%lld,%lld\n",key,node1,node2,pre);
if(key == pre|| -1==pre)
{
InsertEdge(Graph, node1,node2);
InsertEdge(Graph, node2,node1);
pre = key;
USER = pre;
}
else
{
// Traverse(Graph);
BK_algo(Graph);
Count = 0;
int i;
for(i=0;i<LINE;++i)LEN[i]=0;
for(i=0;i<NUM;++i)Graph[i]=0;
pre = key;
InsertEdge(Graph, node1,node2);
InsertEdge(Graph, node2,node1);
}
}
// Traverse(Graph);
if(-1 != pre)
BK_algo(Graph);
}
///
/// ResortActiveList()
VOID ResortActiveList( EdgePtr active )
{
EdgePtr p, q;
p = active->next;
active->next = NULL;
while( p ) {
q = p->next;
InsertEdge( active, p );
p = q;
}
}
calcir()
{
int a,b;
for(a=1;a<=n;a++)
for(b=1;b<=n;b++)
}
main()
{
int i,src,dst,nd[20];
clrscr();
freopen("dfs.in","r",stdin);
scanf("%d%d",&n,&e);
for(i=0;i<=n;i++)
{
d[i]=f[i]=NIL;
nd[i]=i;
}
EdgeInit(n);
for(i=1;i<=2*e;i+=2)
{
scanf("%d%d",&src,&dst);
InsertEdge(src,dst,NIL,i);
InsertEdge(dst,src,NIL,i+1);
}
t=0;
for(i=1;i<=n;i++)
{
if(d[i]==0) Topo(i);calcir();
}
qsort((void *) (nd+1),n,sizeof(nd[0]),SortFunction);
for(i=1;i<=n;i++)
{
printf("%d\n",*(nd+i));
}
fclose(stdin);
printf("\nOK");
}
void buildGraph_test(LGraph newgra)
{
/* test version of buildGraph, the original graph is on page180 */
int row[8] = {0,0,1,1,2,3,3,4};
int col[8] = {1,5,2,6,3,4,6,5};
for (int i = 0; i < 8; i++)
{
Edge newedge = (Edge)malloc(sizeof(struct edge));
newedge->vr = row[i];
newedge->vc = col[i];
newedge->wt = 1;
InsertEdge(newgra, newedge);
}
printf("Test graph created.\n");
}
void buildGraph(LGraph newgra)
{
/* This function builds an directed graph adjacency lists by taking
pairs of connections */
int row, col, weight;
printf("Please input a pair of connected nodes(vr-vc:w)"
" to the %d nodes graph:\n", newgra->vertex_num);
while (scanf("%d-%d:%d", &row, &col, &weight) == 3)
{
Edge newedge = (Edge)malloc(sizeof(struct edge));
newedge->vr = row; newedge->vc = col; newedge->wt = weight;
InsertEdge(newgra, newedge);
printf("New edge inserted to the graph.\n");
}
}
/*------------------------------------------------------------------
* Create a BinaryGraphLoader reading from a binary istream.
* NOTE: the input stream must be open with the
* ios::binary | ios::in mode.
-----------------------------------------------------------------*/
BinaryGraphLoader::BinaryGraphLoader(istream &in)
{ unsigned n, ne, dest;
unsigned i,j;
n = readWord(in);
for(i=0; i<n; i++)
InsertNode(NULL);
for(i=0; i<n; i++)
{ ne = readWord(in);
for(j=0; j<ne; j++)
{ dest=readWord(in);
InsertEdge(i, dest, NULL);
}
}
}
bool GraphAdjArray::InitByMatrix(FILE* stream)
{
if(stream == NULL)
{
printf("null input stream\n");
return false;
}
int ret, m, i, j, cost;
char c;
ret = fscanf(stream, "%d%c", &m, &c);
if(ret != 2)
{
printf("invalid format: vertex num invalid\n");
return false;
}
Vertex vertex;
for(i = 0; i < m; i++)
{
vertex.index = i;
PutVertex(&vertex);
for(j = 0; j < m; j++)
{
ret = fscanf(stream, "%d", &cost);
if(ret != 1)
{
printf("invalid format: cell(%d, %d) invalid\n");
return false;
}
//insert one edge
InsertEdge(i, j, cost);
ret = fscanf(stream, "%c", &c);
if(ret != 1)
{
printf("invalid format: no trailing char after cell(%d, %d)\n", i, j);
return false;
}
}
}
vexnum = m;
return true;
}
LGraph BuildGraph()
{
int i;
int nv,ne;
LGraph newGraph;
Edge newEdge;
printf("input Nv,Ne:");
scanf("%d %d",&nv,&ne);
newGraph = CreateGraph(nv);
newGraph->ne = ne;
for(i = 0; i< ne; i++){
newEdge = (Edge)malloc(sizeof(struct ENode));
printf("input <v1,v2>");
scanf("%d %d %d",&newEdge->v1,&newEdge->v2,&newEdge->weight);/*有权重就读权重呗*/
InsertEdge(newGraph,newEdge);
}
return newGraph;
}
void read(void)
{
int i,src,dst,nd[20],ttr=0;;
clrscr();
freopen("topo.in","r",stdin);
scanf("%d%d",&n,&e);
for(i=0;i<=n;i++)
{
discover[i]=finish[i]=NIL;
nd[i]=i;
}
EdgeInit(n);
for(i=1;i<=e;i++)
{
scanf("%d%d",&src,&dst);
InsertEdge(src,dst,NIL,i);
}
}
// ConstructGraph
//
// Time complexity: O(n^2)
void
Graph::ConstructGraph( const Graph & resourceAllocation, const Graph & resourceRequest )
{
MaxVertices = resourceRequest.MaxVertices;
EdgeNode *requestPtr, *allocationPtr;
int process, resource, i;
// Traverse all adjacency lists
for ( i = 0; i < resourceRequest.NumVertices; i++ )
{
// Save pointer to the first node in the ith list of resource request graph
requestPtr = resourceRequest.Edge[i];
// Traverse ith adjacency list and look for requested processes, if any
while ( requestPtr != NULL )
{
// Save resource name
resource = requestPtr->Vertex;
// Save pointer to the first node in the "mysterious" list of resource
// allocation graph
allocationPtr = resourceAllocation.Edge[resourceAllocation.Position( resource )];
// See if the resource is allocated
if ( allocationPtr != NULL )
{
// Save process name
process = allocationPtr->Vertex;
// Insert edge
InsertEdge( resourceRequest.Vlist[i], process );
} // end of if statement
// Advance to the next node, if any
requestPtr = requestPtr->Next;
} // end of while loop
} // end of for loop
}
/*----------------------------------------------------------
* Constructor
---------------------------------------------------------*/
ARGEdit:: ARGEdit(ARGLoader &g)
{ count=0;
nodes=NULL;
lastNode=NULL;
lastEdge=NULL;
node_id n;
for (n=0; n<g.NodeCount(); n++)
InsertNode(g.GetNodeAttr(n));
int i;
for (n=0; n<g.NodeCount(); n++)
{
for (i=0; i<g.OutEdgeCount(n); i++)
{
void *attr;
node_id n2=g.GetOutEdge(n, i, &attr);
InsertEdge(n, n2, attr);
}
}
}
int main(int argc, char *argv[]){
if (argc < 2){
puts("Usage: rp [FILE]");
return -1;
}
char *filename = argv[1];
// createLists(filename);
char buffer[128];
FILE *buschart = fopen(filename, "r");
Stop Stops=NULL;
Edge Edges =NULL;
char newstartname[128], newstopname[128];
printf("Loading database: %s\n",filename);
while(!(feof(buschart))){
readline(buffer, 128, buschart);
if(strcmp(buffer,"")!=0){
Stop newStop=malloc(sizeof(struct stop));
Edge newEdge=malloc(sizeof(struct edge));
char *copy = malloc(strlen(buffer)+1);
char *loc;
//line
strcpy(copy,buffer);
strtok (buffer,",");
char *line = malloc(strlen(buffer)+1);
strcpy(line,buffer);
loc = strchr(copy,',');
strcpy(copy,loc+2);
newEdge->line=malloc(strlen(buffer)+1);
strcpy(newEdge->line,line);
//start
strcpy(buffer,copy);
strtok (buffer,",");
char *start = malloc(strlen(buffer)+1);
strcpy(start,buffer);
loc = strchr(copy,',');
strcpy(copy,loc+2);
newStop->name = malloc(strlen(buffer)+1);
newEdge->start = malloc(strlen(buffer)+1);
strcpy(newstartname, start);
newEdge->start->name=newstartname;
//stop
strcpy(buffer,copy);
strtok (buffer,",");
char *stop = malloc(strlen(buffer)+1);
strcpy(stop,buffer);
loc = strchr(copy,',');
strcpy(copy,loc+2);
strcpy(newStop->name, buffer);
newEdge->stop = malloc(strlen(buffer)+1);
strcpy(newstopname, stop);
newEdge->stop->name=newstopname;
//time
char *time = malloc(strlen(buffer)+1);
strcpy(time,copy);
newEdge->time=malloc(strlen(buffer)+1);
strcpy(newEdge->time,time);
strcpy(buffer,"");
newEdge->next=NULL;
newEdge->start->route=NULL;
newEdge->start->next=NULL;
newEdge->stop->route=NULL;
newEdge->stop->next=NULL;
newStop->next=NULL;
newStop->route=NULL;
InsertStop(&Stops, &newStop);
InsertEdge(&Edges, &newEdge);
}
}
puts("Database loaded!\n-----------");
int choice = -1;
while(choice != 0){
puts("1. Print Stations");
puts("2. Get shortest route\n");
puts("---Travel---");
puts("3. Arrival time ");
puts("4. Depature time");
puts("-----------");
puts("0. Exit MENU\n");
puts("Please choose an option!\n");
printf("? ");
scanf("%d", &choice);
while(getchar() != '\n'); // Clear stdin
switch(choice){
case 1:
printStops(Stops);
break;
case 2:
puts("TO BE IMPLEMENTED\n");
break;
case 3:
puts("TO BE IMPLEMENTED\n");
break;
case 4:
puts("TO BE IMPLEMENTED\n");
break;
case 0:
puts("BYE!\n");
break;
default:
puts("Invalid option, please try again!\n");
break;
}
}
return 0;
}
bool GraphAdjArray::InitByEdges(FILE* stream)
{
if(stream == NULL)
{
printf("null input stream\n");
return false;
}
int i, j, m, n, ret;
int x, y, cost;
char c;
ret = fscanf(stream, "%d %d", &m, &n);
if(ret != 2)
{
printf("invalid format: vertex num or edge num invalid\n");
return false;
}
fscanf(stream, "%c", &c);
Vertex vertex;
for(i = 0; i < m; i++)
{
vertex.index = i;
PutVertex(&vertex);
}
memset(arcs, 0, sizeof(arcs));
for(i = 0; i < n; i++)
{
ret = fscanf(stream, "%d %d %d", &x, &y, &cost);
if(ret != 3)
{
printf("invalid format: %d edge invalid\n", i);
return false;
}
fscanf(stream, "%c", &c);
InsertEdge(x, y, cost);
InsertEdge(y, x, cost);
}
//set the cost to infinity when the graph is network
if(kind == UDN || kind == DN)
{
for(i = 0; i < m; i++)
{
for(j = 0; j < m; j++)
{
if(arcs[i][j].cost == 0)
{
arcs[i][j].cost = INFINITY;
}
}
}
}
vexnum = m;
arcnum = n * 2;
return true;
}
