Theory of Breadth First Search and Uninformed Search

Breadth First Search (BFS):

Breadth-first search enlarges the shallowest node in the search tree first. This is complete, optimal for unit-cost operators, and consists of time and space complexity of O(b^d). The space complexity forms it impractical in many cases.

By using BFS strategy, the root node is expanded initially, and then all the nodes produced by the root node are expanded next, and their successors, and so forth. In common, all the nodes at depth d in the search tree are expanded prior to the nodes at depth d+1.

Algorithmically:

BFS(G,s) {
  initialize vertices;
  Q = {s];
  while (Q not empty) {
    u = Dequeue(Q);
    for each v adjacent to u do {
      if (color[v] == WHITE) {
        color[v] = GRAY;
        d[v] = d[u]+1; // compute d[]
        p[v] = u;  // build BFS tree
        Enqueue(Q,v);
    }
  }
  color[u] = BLACK;
}

BFS runs in O(V+E)

Note: BFS can calculate d[v] = shortest-path distance from s to v, in terms of minimum number of edges from s to v (un-weighted graph). Its breadth-first tree can be employed to symbolize the shortest-path.

BFS Solution to Popular JAR Problem:

#include<stdio.h>
#include<conio.h>
#include<values.h>
 
#define N 105
#define MAX MAXINT
 
int act[N][N], Q[N*20][3], cost[N][N];
int a, p, b, m, n, fin, na, nb, front, rear;
 
void init()
{
 front = -1, rear = -1;
 for(int i=0; i<N; i++)
  for(int j=0; j<N; j++)
   cost[i][j] = MAX;
 cost[0][0] = 0;
}
 
void nQ(int r, int c, int p)
{
 Q[++rear][0] = r, Q[rear][1] = c, Q[rear][2] = p;
}
 
void dQ(int *r, int *c, int *p)
{
 *r = Q[++front][0], *c = Q[front][1], *p = front;
}
 
void op(int i)
{
 int currCapA, currCapB;
 if(i==0)
  na = 0, nb = b;
 else if(i==1)
  nb = 0, na = a;
 else if(i==2)
  na = m, nb = b;
 else if(i==3)
  nb = n, na = a;
 else if(i==4)
 {
  if(!a && !b)
return;
  currCapB = n - b;
  if(currCapB <= 0)
   return;
  if(a >= currCapB)
   nb = n, na = a, na -= currCapB;
  else
   nb = b, nb += a, na = 0;
 }
 else
 {
  if(!a && !b)
   return;
  currCapA = m - a;
  if(currCapA <= 0)
   return;
  if(b >= currCapA)
   na = m, nb = b, nb -= currCapA;
  else
   nb = 0, na = a, na += b;
 }
}
 
void bfs()
{
 nQ(0, 0, -1);
 do{
 
  dQ(&a, &b, &p);
  if(a==fin)
   break;
  for(int i=0; i<6; i++)
  {
   op(i); /* na, nb will b changed for this func
      according to values of a, b
    */
   if(cost[na][nb]>cost[a][b]+1)
   {
    cost[na][nb]=cost[a][b]+1;
    act[na][nb] = i;
    nQ(na, nb, p);
   }
  }
 } while (rear!=front);
}
 
void dfs(int p)
{
 int i = act[na][nb];
 if(p==-1)
  return;
 na = Q[p][0], nb = Q[p][1];
 dfs(Q[p][2]);
 if(i==0)
printf("Empty A\n");
 else if(i==1)
  printf("Empty B\n");
 else if(i==2)
  printf("Fill A\n");
 else if(i==3)
  printf("Fill B\n");
 else if(i==4)
  printf("Pour A to B\n");
 else
  printf("Pout B to A\n");
}
 
void main()
{
 clrscr();
 while(scanf("%d%d%d", &m, &n, &fin)!=EOF)
 {
  printf("\n");
  init();
  bfs();
  dfs(Q[p][2]);
  printf("\n");
 }
}


Uninformed Search:

Searching is a procedure of considering possible series of actions, at first you have to formulate a goal and then employ the goal to formulate the problem.

A problem comprises of four parts: the initial state, a set of operators, a goal test function, and the path cost function. The environment of problem is symbolized by a state space. A path via the state space from initial state to a goal state is the solution.

In actual life most of the problems are ill-defined, however with some analysis; most of the problems can fit into the state space model. A single general search algorithm can be employed to solve any problem; specific variants of algorithm embody various strategies. Search algorithms are judged on the basis of optimality, completeness, time complexity, and space complexity. The complexity depends on b, the branching factor in state space, and d the depth of shallowest solution.

There are six search type which are categorized as uninformed search, this signifies that the search contain no information regarding the number of steps or the path cost from the present state  to the goal - all they can do is differentiate a goal state from a non-goal state. Uninformed search is as well sometimes termed blind search.

Latest technology based Programming Languages Online Tutoring Assistance

Tutors, at the www.tutorsglobe.com, take pledge to provide full satisfaction and assurance in Programming Languages help via online tutoring. Students are getting 100% satisfaction by online tutors across the globe. Here you can get homework help for Programming Languages, project ideas and tutorials. We provide email based Programming Languages help. You can join us to ask queries 24x7 with live, experienced and qualified online tutors specialized in Programming Languages. Through Online Tutoring, you would be able to complete your homework or assignments at your home. Tutors at the TutorsGlobe are committed to provide the best quality online tutoring assistance for Programming Languages Homework help and assignment help services. They use their experience, as they have solved thousands of the Programming Languages assignments, which may help you to solve your complex issues of Programming Languages. TutorsGlobe assure for the best quality compliance to your homework. Compromise with quality is not in our dictionary. If we feel that we are not able to provide the homework help as per the deadline or given instruction by the student, we refund the money of the student without any delay.

2015 ┬ęTutorsGlobe All rights reserved. TutorsGlobe Rated 4.8/5 based on 34139 reviews.