コード例 #1
0
ファイル: DFS.cpp プロジェクト: GingerNg/DSAD
void xDigraph::DFS(size_t v)
{
	// 所有顶点标记为未访问
	for (size_t i = 0; i < marked.size(); i++)
		marked[i] = false;
	DepthFirstSearch(v);
}
コード例 #2
0
ファイル: DFS.cpp プロジェクト: GingerNg/DSAD
void xDigraph::DepthFirstSearch(size_t v)
{
	visit(v);			// 访问顶点v
	marked[v] = true;	// 置该顶点为已访问
	for (auto c_iter = AL[v].cbegin(); c_iter != AL[v].cend(); ++c_iter)
		if (!marked[*c_iter])
			DepthFirstSearch(*c_iter);
}
コード例 #3
0
ファイル: Graph.cpp プロジェクト: Dragollla/ITMO
bool Graph::haveCycle(Edge edge) {
    bool marked[vertices.capacity()];
    for (size_t i = 0; i < vertices.capacity(); ++i)
        marked[i] = false;

    DepthFirstSearch(marked, edge.destination->id);

    return marked[edge.source->id];
}
コード例 #4
0
ファイル: Graph.cpp プロジェクト: Dragollla/ITMO
void Graph::DepthFirstSearch(bool marked[], size_t currentIndex) {
    marked[currentIndex] = true;

    if (vertices[currentIndex] != nullptr) {
        for (list<Edge *>::iterator eIt = vertices[currentIndex]->neighborhood.begin(); eIt != vertices[currentIndex]->neighborhood.end(); eIt++) {
            if (!marked[(*eIt)->destination->id]) {
                DepthFirstSearch(marked, (*eIt)->destination->id);
            }
        }
    }
}
コード例 #5
0
unsigned short MinMaxAlgorithm::GetNextPlay() {
	
	// if Graph is initiated, delete it
	if (this->aGraph)
		delete this->aGraph;
	
	// allocate a new graph
	this->aGraph = new Graph<u_int8_t>;
	
	
	// call DepthFirstSearch function
	return DepthFirstSearch();
}
コード例 #6
0
static inline void DepthFirstSearch(int x, int y, int current_label, int NrPixels, int **BoolImage, int **ConnectedComponents,int **Positions, int *PositionTrackers)
{
	if (x < 0 || x == NrPixels) return;
	if (y < 0 || y == NrPixels) return;
	if ((ConnectedComponents[x][y]!=0)||(BoolImage[x][y]==0)) return;
	
	ConnectedComponents[x][y] = current_label;
	Positions[current_label][PositionTrackers[current_label]] = (x*NrPixels) + y;
	PositionTrackers[current_label] += 1;
	int direction;
	for (direction=0;direction<8;++direction){
		DepthFirstSearch(x + dx[direction], y + dy[direction], current_label, NrPixels, BoolImage, ConnectedComponents,Positions,PositionTrackers);
		
	}
}
コード例 #7
0
static inline int FindConnectedComponents(int **BoolImage, int NrPixels, int **ConnectedComponents, int **Positions, int *PositionTrackers){
	int i,j;
	for (i=0;i<NrPixels;i++){
		for (j=0;j<NrPixels;j++){
			ConnectedComponents[i][j] = 0;
		}
	}
	int component = 0;
	for (i=0;i<NrPixels;++i) {
		for (j=0;j<NrPixels;++j) {
			if ((ConnectedComponents[i][j]==0) && (BoolImage[i][j] == 1)){
				DepthFirstSearch(i,j,++component,NrPixels,BoolImage,ConnectedComponents,Positions,PositionTrackers);
			}
		}
	}
	return component;
}
コード例 #8
0
ファイル: driver.c プロジェクト: kanishk7/Code_
int main()
{
    id_no = 0;
    int i,j;
    AdjList al;
    for(i=0; i<GRAPH_SIZE; i++)
    {
        al.list[i] = newVertex();
        //printf("(%d).\n",al.list[i]->v->id_no);
    }
    AdjMatrix am;
    for(i=0; i<GRAPH_SIZE; i++)
        for(j=0; j<GRAPH_SIZE; j++)
            am.matrix[i][j] = INFINITE;

    edgepopulator(al,am,GRAPH_DENSITY);

    printf("No. of vertices = %d. No. of edges = %d.\n",GRAPH_SIZE,no_of_edges);
    fillAdjMatrix(al,am.matrix);
    //printAdjMatrix(am.matrix);
    clock_t start = clock();
    visited_nodes;
    int question = 3;
	int answer = DepthFirstSearch(al,am,3,"ijlc",&visited_nodes);
	int dfs_count = visited_nodes;
	visited_nodes = 0;
	printf("%d.\n",BreadthFirstSearch(al,am,3,"ijlc",&visited_nodes));
	int bfs_count = visited_nodes;
	
	int g_size = GRAPH_SIZE;
	float g_density = GRAPH_DENSITY;
	
	printf("Under the following conditions..\n");
	printf("GRAPH_SIZE = %d.\n",g_size);
	printf("GRAPH_DENSITY = %f.\n", g_density);
	printf("Initial Distance = %d.\n", abs(answer-question));
	
	
	
	printf("Results DFS(%d) vs BFS(%d).\n",dfs_count, bfs_count);
	

    return 0;
}
//returns true if a directed path exists from start to target
//true is of course 1, 0 is false
int DepthFirstSearch(Node *start, Node *target, int colorVisit)
  {
  //fprintf(stderr, "%d %d %d\n", start->x, start->y, start->z);
  if (start == target)
    {
    return 1;
    }
  Edge *tempNext = start->edge;
  if (tempNext == NULL || start->color == colorVisit || start->dead == 1)
    {
    return 0;
    }
  else
    {
    start->color = colorVisit;
    int tempVal = 0;
    while (0 == tempVal && tempNext != NULL)
      {
      tempVal = DepthFirstSearch(tempNext->node, target, colorVisit);
      tempNext = tempNext->edge;
      }
    return tempVal;
    }
  }
void buildCycles(double *dist, int *segs, int sizeHeap, 
                 Parent *sets, Node *nodes, FILE *outputFile, int maxComponents)
  {
  //note: heap should already be built.
  int curHeapLength = sizeHeap;
  int unions= 0;  //counters, useful for debugging
  int nons= 0;
  int continueFinding = 0; //increments when componentfound
  for (int i = sizeHeap - 1; i > -1 && maxComponents > continueFinding ; i--)
    {
    double minDist = GetAlphaDist(dist, 0);
    int fx = GetAlphaSeg(segs, 0, 0, 0);
    int fy = GetAlphaSeg(segs, 0, 1, 0);
    int fz = GetAlphaSeg(segs, 0, 2, 0);
    int tx = GetAlphaSeg(segs, 0, 0, 1);
    int ty = GetAlphaSeg(segs, 0, 1, 1);
    int tz = GetAlphaSeg(segs, 0, 2, 1);
    SwitchAlphas(dist, segs, 0, i);    
    curHeapLength--;
    minHeapify(dist, segs, 0, curHeapLength);
    //fprintf(stderr, "%f\n", minDist);
    //fprintf(stderr, "%f (%d %d %d) (%d %d %d)\n", minDist, fx, fy, fz, tx, ty, tz);
    //now we process the two points.
    //fprintf(stderr, "%d %d\n", calcIndexN(fx, fy, fz), calcIndexN(tx, ty, tz));
    //we need these several places
    int fromIndex = calcIndexN(fx,fy,fz);
    int toIndex = calcIndexN(tx,ty,tz);
    if (Value(sets[fromIndex]) != Value(sets[toIndex]))
      {
      Union(&sets[fromIndex], &sets[toIndex]);
      //and add edge to new graph from fx,y,z to tx,y,z
      Edge *newEdge = (Edge *)malloc(sizeof(Edge));
      newEdge->node = &nodes[toIndex];
      newEdge->edge = NULL;
      newEdge->dist = minDist;
      if (nodes[fromIndex].edge == NULL)
        {
        nodes[fromIndex].edge = newEdge;
        }
      else
        {
        Edge *temp = nodes[fromIndex].edge;
        while (temp->edge != NULL)
          {
          temp = temp->edge;
          }
        temp->edge = newEdge;
        }
      unions++;
      }
    else
      {
      //fprintf(stderr, "%d %d\n"  ,Value(sets[calcIndexN(fx, fy, fz)]) ,Value(sets[calcIndexN(tx, ty, tz)]));
      //search, find and output! (or discard)
      int success = DepthFirstSearch(&nodes[toIndex], &nodes[fromIndex], nons);
      if (1 == success)
        {
        //fprintf(stderr, "cycle from %d %d %d to %d %d %d\n", tx, ty, tz, fx, fy, fz);
        nons++;
        continueFinding++; //stop processing if goes above maxComponents
        fprintf(outputFile, "Component %d of %d:\n", continueFinding, maxComponents);
        PrintCycle(&nodes[toIndex], &nodes[fromIndex], nons, outputFile);
        fprintf(outputFile, "\n");
        }
      //do the following steps in this case no matter what, i.e. add the edge to the graph
      Edge *newEdge = (Edge *)malloc(sizeof(Edge));
      newEdge->node = &nodes[toIndex];
      newEdge->edge = NULL;
      newEdge->dist = minDist;
      if (nodes[fromIndex].edge == NULL)
        {
        nodes[fromIndex].edge = newEdge;
        }
      else
        {
        Edge *temp = nodes[fromIndex].edge;
        while (temp->edge != NULL)
          {
          temp = temp->edge;
          }
        temp->edge = newEdge;
        }
      nons++;
      }
    }  
  //fprintf(stderr, "%d %d\n", unions, nons);
  }
コード例 #11
0
ファイル: main.cpp プロジェクト: jamespascoe/C11-Work
int main(int argc, char *argv[])
{
  MyBtree<std::string> mbt;
  MyBtree<std::string> mbt2 { "hello","this","is","james" };

  std::ifstream infile(argv[1]);
  if (!infile.good()) 
  {
    std::cerr << "Could not open " << argv[1] << " for input!" << std::endl;
    std::exit(1);
  }

  std::string temp;
  while (infile >> temp)
    mbt.insert(temp);

  std::cout << "Created a binary tree of size: " << mbt.get_size() 
            << " (" << mbt.get_left_depth() << "," << mbt.get_right_depth() << ")" 
            << std::endl;

  std::cout << "Enter words that you want to check (ctrl-c to exit)" <<std::endl;
  while (std::cin >> temp)
  {
    std::cout << " Result of depth first search for: " << temp << " in: " << argv[1] << " is: " << std::boolalpha << DepthFirstSearch(mbt,temp) << std::endl;
    std::cout << " Result of breadth first search for: " << temp << " in: " << argv[1] << " is: " << std::boolalpha << BreadthFirstSearch(mbt2,temp) << std::endl;
  }
}
コード例 #12
0
ファイル: prover.c プロジェクト: ombt/ombt
// use a best-first search theorem prover
int
runbfsprover(List<Clause> &clist)
{
	int status;

	// dump data info
	if (reportmemoryusage)
	{
		SETFINALEDATA();
		DUMPDATA(cout);
	}

	// copy clauses to a tree for better performance
	BinaryTree_AVL<Clause> ctree;
	ListIterator<Clause> clIter(clist);
	for (nextClause=1; !clIter.done(); clIter++)
	{
		// insert clauses at current deph
		Clause clause(clIter());
		clause.setDepth(1);
		clause.setNumber(nextClause++);
		if (ctree.insert(clause) != OK)
		{
			ERROR("insert failed.", errno);
			return(NOTOK);
		}
	}

	// dump data info
	if (reportmemoryusage)
	{
		SETFINALEDATA();
		DUMPDATA(cout);
	}

	// list clauses
	cout << endl;
	cout << "===============================================" << endl;
	cout << "initial list of clauses: " << endl;
	BinaryTree_AVL_Iterator_InOrder<Clause> ctreeIter(ctree);
	for ( ; !ctreeIter.done(); ctreeIter++)
	{
		cout << ctreeIter() << endl;
	}
	cout << "===============================================" << endl;

	// dump data info
	if (reportmemoryusage)
	{
		SETFINALEDATA();
		DUMPDATA(cout);
	}

	// filter clauses
	if (removeTautologies(ctree) != OK)
	{
		ERROR("removeTautologies failed.", errno);
		return(NOTOK);
	}
	if (initialRemoveSubsumed(ctree) != OK)
	{
		ERROR("removeSubsumed failed.", errno);
		return(NOTOK);
	}

	// dump data info
	if (reportmemoryusage)
	{
		SETFINALEDATA();
		DUMPDATA(cout);
	}

	// separate clauses into SOS and axioms
	BinaryTree_AVL<Clause> soslist;
	BinaryTree_AVL<Clause> axiomlist;
	for (ctreeIter.reset(); !ctreeIter.done(); ctreeIter++)
	{
		if (ctreeIter().getSOS())
		{
			if ((status = soslist.insert(ctreeIter())) != OK)
			{
				ERROR("insert failed.", errno);
				return(status);
			}
		}
		else
		{
			if ((status = axiomlist.insert(ctreeIter())) != OK)
			{
				ERROR("insert failed.", errno);
				return(status);
			}
		}
	}

	// dump data info
	if (reportmemoryusage)
	{
		SETFINALEDATA();
		DUMPDATA(cout);
	}

	// generate a list of possible resolution states
	List<BFSNode> bfsnodelist;
	BinaryTree_AVL_Iterator_InOrder<Clause> sosIter1(soslist);
	for ( ; !sosIter1.done(); sosIter1++)
	{
		if (sosIter1().getTotalMembers() > maxliterals)
			continue;
		Literal maxlit1;
		if (sosIter1().getMaximalLiteral(maxlit1) != OK)
		{
			ERROR("get maximal literal failed.", errno);
			return(NOTOK);
		}
		BinaryTree_AVL_Iterator_InOrder<Clause> sosIter2(sosIter1);
		for (sosIter2++ ; !sosIter2.done(); sosIter2++)
		{
			// generate possible resolution states
			Literal maxlit2;
			if (sosIter2().getMaximalLiteral(maxlit2) != OK)
			{
				ERROR("get maximal literal failed.", errno);
				return(NOTOK);
			}
			if (sosIter2().getTotalMembers() > maxliterals)
			{
				statistics[MaximumLiteralsClausesRejected] += 1;
				totalstatistics[TotalMaximumLiteralsClausesRejected] += 1;
				continue;
			}
			if (maxlit1.unify_ne(~maxlit2))
				continue;
			BFSNode bfsnode(maxlit1, maxlit2, 
					sosIter1(), sosIter2());
			if (bfsnodelist.insertAtEnd(bfsnode) != OK)
			{
				ERROR("insert failed.", errno);
				return(status);
			}
		}
		BinaryTree_AVL_Iterator_InOrder<Clause> axiomIter(axiomlist);
		for ( ; !axiomIter.done(); axiomIter++)
		{
			// generate possible resolution states
			Literal maxlit2;
			if (axiomIter().getMaximalLiteral(maxlit2) != OK)
			{
				ERROR("get maximal literal failed.", errno);
				return(NOTOK);
			}
			if (axiomIter().getTotalMembers() > maxliterals)
			{
				statistics[MaximumLiteralsClausesRejected] += 1;
				totalstatistics[TotalMaximumLiteralsClausesRejected] += 1;
				continue;
			}
			if (maxlit1.unify_ne(~maxlit2))
				continue;
			BFSNode bfsnode(maxlit1, maxlit2, 
					sosIter1(), axiomIter());
			if (bfsnodelist.insertAtEnd(bfsnode) != OK)
			{
				ERROR("insert failed.", errno);
				return(status);
			}
		}
	}

	// dump data info
	if (reportmemoryusage)
	{
		SETFINALEDATA();
		DUMPDATA(cout);
	}

	// call search routines 
	switch (searchtype)
	{
	case BestFirst:
		status = BestFirstSearch(bfsnodelist, soslist, axiomlist);
		break;
	case DepthFirstHillClimb:
		status = DepthFirstHillClimbSearch(bfsnodelist, soslist, axiomlist);
		break;
	case DepthFirst:
		status = DepthFirstSearch(bfsnodelist, soslist, axiomlist);
		break;
	case BreadthFirst:
		status = BreadthFirstSearch(bfsnodelist, soslist, axiomlist);
		break;
	case IterativeDeepening:
		status = IterativeDeepeningSearch(bfsnodelist, soslist, axiomlist);
		break;
	default:
		ERRORD("unknown search type", searchtype, EINVAL);
		return(NOTOK);
	}

	// dump data info
	if (reportmemoryusage)
	{
		SETFINALEDATA();
		DUMPDATA(cout);
	}

	// report results of provers
	switch (status)
	{
	case OK:
	case VALID:
		// valid program
		programstatistics[TotalValidPrograms] += 1;
		cout << endl;
		cout << "Run Time Statistics ..." << endl;
		cout << statistics << endl;
		cout << endl;
		cout << "VALID program." << endl;

		// dump data info
		if (reportmemoryusage)
		{
			SETFINALEDATA();
			DUMPDATA(cout);
		}
		return(VALID);
	case NOTPROVEN:
		if (nextClause > maxclause)
		{
			programstatistics[TotalMaximumClauseExceededPrograms] += 1;
			ERROR("maxclause exceeded !!!", EINVAL);
		}
		else if (currentBFSDepth > maxdepth)
		{
			programstatistics[TotalMaximumDepthExceededPrograms] += 1;
			ERROR("maxdepth exceeded !!!", EINVAL);
		}
		programstatistics[TotalNotProvenPrograms] += 1;
		cout << endl;
		cout << "Run Time Statistics ..." << endl;
		cout << statistics << endl;
		cout << endl;
		cout << "NOTPROVEN program." << endl;

		// dump data info
		if (reportmemoryusage)
		{
			SETFINALEDATA();
			DUMPDATA(cout);
		}
		return(NOTPROVEN);
	default:
		// some type of error
		ERRORD("unexpected return from best first search !!!", 
			status, EINVAL);

		// dump data info
		if (reportmemoryusage)
		{
			SETFINALEDATA();
			DUMPDATA(cout);
		}
		return(status);
	}
}