Candidate Reg Number

THE UNIVERSITY OF DODOMA

OFFICE OF THE DEPUTY VICE CHANCELLOR
ACADEMIC, RESEARCH AND CONSULTANCY

COLLEGE OF INFORMATICS AND VIRTUAL

EDUCATION
Department of Computer Science and Engineering
End of Semester TWO University Test for the 2022/2023 Academic
Year

Course Name: CP 422: Artificial Intelligence

Duration: 1.5Hour
Question one
a) Consider a grid-based navigation problem where an agent needs to find the shortest path
from the initial state S to the goal state G. The grid consists of cells, and the agent can
move horizontally or vertically between adjacent cells. There are no obstacles in the grid,
and the agent can move in any direction.
i. Define the problem in terms of states, actions, initial state, goal state, and the path
cost function (5 Marks)
Suggested answer

In the grid-based navigation problem, we can define the following components:

1
 1. States: Each state represents the position of the agent in the grid. It can be
represented by the coordinates (x, y) of the cell in which the agent is located.
Therefore, a state S can be defined as S = (x, y).
2. Actions: The agent can move horizontally or vertically between adjacent cells
in the grid. Therefore, the actions available to the agent are moving up,
down, left, or right. These actions can be represented as A = {Up, Down,
Left, Right}.
3. Initial State: The initial state (S0) represents the starting position of the agent
in the grid. It is the state from which the agent begins its navigation. The
initial state can be denoted as S0 = (x0, y0).
4. Goal State: The goal state (G) represents the destination that the agent needs
to reach in the grid. Once the agent reaches the goal state, the navigation is
considered complete. The goal state can be denoted as G = (xg, yg).
5. Path Cost Function: The path cost function determines the cost associated
with transitioning from one state to another. In this problem, we can assume
a uniform path cost, where each movement from one cell to an adjacent cell
has a constant cost of 1. Therefore, the path cost function can be defined as
c(S, A, S') = 1, where S is the current state, A is the action taken, and S' is the
resulting state after taking the action.
To find the shortest path from the initial state to the goal state, we can employ
search algorithms such as Breadth-First Search (BFS), Depth-First Search
(DFS), or A* Search. These algorithms explore the grid by expanding states and
selecting actions that lead to the goal state while minimizing the path cost.
By representing the problem in terms of states, actions, initial state, goal state,
and the path cost function, we can effectively solve the grid-based navigation
problem and determine the shortest path for the agent to reach the goal state from
the initial state
ii. Explain the breadth-first search (BFS) algorithm for solving this problem.
(5
Marks)
Suggested answer

2
The breadth-first search (BFS) algorithm is a graph traversal algorithm that
explores all the vertices of a graph in breadth-first order. In the context of the
grid-based navigation problem, we can apply BFS to find the shortest path from
the initial state to the goal state. Here's how the BFS algorithm works:
1. Initialize the queue and visited set:
o Create an empty queue to store the states that need to be explored.
o Create an empty set to keep track of the visited states.
2. Enqueue the initial state:
o Add the initial state to the queue.
3. Mark the initial state as visited:
o Add the initial state to the visited set.
4. Start the BFS loop:
o While the queue is not empty, repeat steps 5 to 8.
5. Dequeue a state from the front of the queue:
o Remove the first state from the queue.
6. Check if the dequeued state is the goal state:
o If the dequeued state is the goal state, the search is complete. We have
found the shortest path from the initial state to the goal state. Exit the
algorithm.
7. Generate valid neighboring states:
o Generate all valid neighboring states by applying each possible action (up,
down, left, right) to the dequeued state.
o Check if each neighboring state is within the bounds of the grid.
8. Process the neighboring states:
o For each valid neighboring state:
 If the neighboring state has not been visited:
 Mark the neighboring state as visited by adding it to the visited set.
 Enqueue the neighboring state to the back of the queue.
9. Repeat steps 4 to 8 until the queue is empty or the goal state is found.
Once the BFS algorithm terminates, we have either found the shortest path from
the initial state to the goal state or determined that there is no path between them.

3
 BFS guarantees that the shortest path is found because it explores the vertices in
the order of their distance from the initial state. Since each action has a uniform
path cost of 1, the first time the goal state is reached, it will be via the shortest
path. BFS explores all possible paths from the initial state, ensuring that the
shortest path is found before exploring longer paths
b) Explain the Depth-first search (DFS) algorithm for solving this problem. Describe the
general steps of DFS and discuss its properties, including completeness, optimality, time
complexity, and space complexity (5 Marks)
Suggested answer

The Depth-First Search (DFS) algorithm is a graph traversal algorithm that

explores as far as possible along each branch before backtracking. In the context
of the grid-based navigation problem, DFS can be used to find a path from the
initial state to the goal state. Here's how the DFS algorithm works:

1. Initialize the stack and visited set:

o Create an empty stack to store the states that need to be explored.
o Create an empty set to keep track of the visited states.
2. Push the initial state onto the stack:

o Add the initial state to the top of the stack.

3. Mark the initial state as visited:

o Add the initial state to the visited set.

4. Start the DFS loop:

o While the stack is not empty, repeat steps 5 to 8.

5. Pop a state from the top of the stack:

o Remove the top state from the stack.

6. Check if the popped state is the goal state:

4
 o If the popped state is the goal state, the search is complete. We have
found a path from the initial state to the goal state. Exit the algorithm.
7. Generate valid neighboring states:

o Generate all valid neighboring states by applying each possible action

(up, down, left, right) to the popped state.
o Check if each neighboring state is within the bounds of the grid.
8. Process the neighboring states:

o For each valid neighboring state:

 If the neighboring state has not been visited:
 Mark the neighboring state as visited by adding it to the visited
set.
 Push the neighboring state onto the stack.
9. Repeat steps 4 to 8 until the stack is empty or the goal state is found.

Once the DFS algorithm terminates, we have either found a path from the initial
state to the goal state or determined that there is no path between them.
Question two
a) In a two-player, zero-sum game, the Minimax algorithm determines the best move by
considering the actions that maximize the advantage for one player while minimizing the
advantage for the other player. Explain how the algorithm work (5 Marks)
Suggested answer
The Minimax algorithm is a decision-making algorithm used in two-player, zero-sum
games, where the goal is to determine the best move for a player by considering the
actions that maximize their advantage while minimizing the opponent's advantage. Here's
an explanation of how the Minimax algorithm works:
1. Evaluation Function: Before diving into the algorithm, it is essential to have an
evaluation function. The evaluation function assigns a value to each game state,
representing the desirability of that state for the current player. The evaluation
function can be customized based on the specific game and its rules. It helps
determine the score or utility of a game state.

5
 2. Recursive Search: The Minimax algorithm uses a recursive search approach to
explore the game tree. It simulates all possible moves and builds a search tree,
where each node represents a game state and the edges represent possible moves.
The tree is explored in a depth-first manner.
3. Maximizer and Minimizer: The algorithm differentiates between two players: the
maximizer and the minimizer. The maximizer tries to maximize its score, while the
minimizer aims to minimize the maximizer's score. In the initial call to the
algorithm, the maximizer is the player for whom the best move is being
determined.
4. Minimax Value: The Minimax algorithm assigns a value to each node in the
search tree. The value represents the desirability of that state for the maximizer.
For leaf nodes (terminal states), the value is determined by the evaluation
function. For non-leaf nodes, the value is calculated based on the values of its
child nodes.
5. Minimax Algorithm Steps:
o At each level of the search tree, if it is the maximizer's turn, the algorithm
selects the child node with the maximum value.
o If it is the minimizer's turn, the algorithm selects the child node with the
minimum value.
o The selected value is propagated up the tree, and the process continues until
the root node is reached.
6. Best Move Determination: Once the search tree has been explored, the algorithm
returns the best move for the maximizer, which is the child node with the
maximum value at the root level.
7. Pruning: To optimize the algorithm, a technique called alpha-beta pruning can be
used. Alpha-beta pruning allows the algorithm to avoid evaluating certain
branches of the search tree that are guaranteed to be worse than previously
examined branches. This technique significantly reduces the number of nodes that
need to be evaluated.
The Minimax algorithm continues to search and evaluate the game tree until a certain
depth or time limit is reached. By assigning values to each node and considering the best

6
 move for the maximizer while minimizing the opponent's advantage, the Minimax
algorithm provides a strategic decision-making process in two-player, zero-sum games
b) How does the alpha-beta pruning technique improve the efficiency of the Minimax
algorithm in determining the best move in two-player, zero-sum games? (3 Marks)
Suggested answer
The alpha-beta pruning technique significantly improves the efficiency of the Minimax
algorithm in determining the best move in two-player, zero-sum games. It achieves this by
eliminating the need to evaluate certain branches of the game tree that are guaranteed to
be worse than previously examined branches. This reduction in unnecessary evaluations
saves computational resources and speeds up the search process.
During the Minimax algorithm's recursive search, it maintains two values: alpha and
beta. The alpha value represents the best choice for the maximizer found so far, while the
beta value represents the best choice for the minimizer found so far. These values are
updated as the algorithm progresses through the game tree.

Question Three
a) What are informed search algorithms in problem-solving, and how do they utilize
heuristic functions to guide the search process? Provide examples of popular informed
search algorithms and their applications. (4 Marks)
Suggested answer
Informed search algorithms, also known as heuristic search algorithms, are problem-
solving techniques that use heuristic functions to guide the search process towards the
most promising paths. These algorithms leverage heuristic information, typically in the
form of estimated costs or values, to make informed decisions about which states to
explore next. This allows them to focus on more promising solutions and efficiently
navigate through large search spaces.
Heuristic functions provide estimates of how close a given state is to the goal state. By
evaluating the heuristic value of different states, informed search algorithms can
prioritize the exploration of states that are more likely to lead to the goal. The heuristic
function acts as a guide, guiding the search towards potentially optimal solutions while
minimizing the number of unnecessary explorations.

7
 Examples of popular informed search algorithms include:
1. A* Search:
o A* Search is a widely-used informed search algorithm that combines the
advantages of uniform cost search and best-first search. It uses a heuristic
function, denoted as h(n), along with the actual cost from the start state to a
given state, denoted as g(n), to estimate the total cost of reaching the goal
from that state. The algorithm explores the state with the lowest estimated
total cost (f(n) = g(n) + h(n)) first, gradually expanding the search space
towards the goal state.
2. Greedy Best-First Search:
o Greedy Best-First Search is an informed search algorithm that selects the
most promising state based solely on the heuristic value. It prioritizes the
state that is estimated to be closest to the goal, without considering the
actual cost to reach that state. While it can quickly find solutions, it may not
guarantee optimality as it may get trapped in local optima.
3. Iterative Deepening A* (IDA*):
o IDA* is a memory-efficient variation of A* Search. It performs a depth-first
search using an increasing threshold, which is determined by the heuristic
value. The algorithm expands nodes within the threshold limit and updates
the threshold based on the minimum value that exceeds the previous
threshold. IDA* continues until a solution is found. It is useful when the
entire search space cannot be stored in memory.
b) What is the basic idea behind local search algorithms, and what are some common
strategies used to escape local optima in these algorithms? (4 Marks)
Suggested answer
The basic idea behind local search algorithms is to iteratively improve a solution by
exploring a neighborhood of candidate solutions. These algorithms start with an initial
solution and continuously move to better neighboring solutions until a satisfactory
solution is found or a termination condition is met. Local search algorithms focus on
optimizing a single solution rather than exploring the entire search space.
To escape local optima in local search algorithms, several strategies can be employed:

8
 1. Random Restart:
The algorithm is restarted multiple times with different random initial solutions.
By exploring different regions of the search space, the chances of escaping local
optima increase.
2. Simulated Annealing:
Simulated Annealing introduces a temperature parameter that controls the
willingness to accept worse solutions initially. The temperature decreases over
time, reducing the acceptance of worse solutions and allowing the algorithm to
converge towards a better solution.
These some of strategies aim to balance the exploitation of promising regions and
the exploration of new areas in the search space. By incorporating randomness,
memory, and adaptive mechanisms, local search algorithms can effectively escape
local optima and find better solutions in optimization problems.
c) How does the Hill Climbing algorithm work as a local search algorithm, and what are its
advantages and limitations in solving optimization problems? (5 Marks)
Suggested answer
The Hill Climbing algorithm is a local search algorithm used to solve optimization
problems. It starts with an initial solution and iteratively moves towards a better solution
by making incremental changes. Here's how the Hill Climbing algorithm works:
1. Initialization:
o Begin with an initial solution or state.
2. Evaluation:

o Evaluate the quality or objective value of the current solution.

3. Neighbor Generation:

o Generate neighboring solutions by making small modifications to the current

solution. These modifications can involve changing a single element or a
subset of elements.
4. Selection:

9
 o Choose the best neighboring solution based on its evaluation or objective
value. If the objective is to maximize, select the solution with the highest value.
If the objective is to minimize, select the solution with the lowest value.
5. Termination:

o If the selected neighboring solution is better than the current solution, replace
the current solution with the selected solution and repeat steps 2 to 5.
o If no better solution is found, terminate the algorithm and return the current
solution as the best solution found so far.

Advantages of Hill Climbing:

 Simplicity: Hill Climbing is a simple and intuitive algorithm to understand and
implement.
 Local Optima: It is effective in finding local optima or near-optimal solutions
in optimization problems.
 Memory Efficiency: Hill Climbing does not require extensive memory to store a
large search space, making it memory-efficient.

Limitations of Hill Climbing:

 Local Optima: Hill Climbing can get trapped in local optima, where it fails to
reach the global optimum due to its greedy nature of always selecting the best
neighbor. It does not consider exploring other areas of the search space.
 Plateaus and Ridges: Hill Climbing struggles with plateau and ridge
situations, where the landscape of the objective function is relatively flat,
making it difficult to find uphill movements towards better solutions.
 Search Direction: Hill Climbing only explores solutions that improve the
objective value. It does not consider exploring solutions that may initially have
a worse objective value but can potentially lead to better solutions in the long
run.
 Sensitivity to Initial Solution: The quality of the solution found by Hill
Climbing heavily depends on the initial solution. It may converge to suboptimal
solutions if the initial solution is far from the global optimum.

10
 In summary, Hill Climbing is a straightforward and memory-efficient local search
algorithm. While it can find local optima efficiently, it has limitations in exploring the
entire search space, overcoming plateaus and ridges, and getting trapped in suboptimal
solutions. To overcome these limitations, variations of Hill Climbing, such as Simulated
Annealing and Genetic Algorithms, have been developed
d) In the context of problem-solving, what is a Constraint Satisfaction Problem (CSP), and
what are the key components used to solve CSPs effectively? (4 Marks)
A Constraint Satisfaction Problem (CSP) is a computational problem defined by a set of
variables, a domain of possible values for each variable, and a set of constraints that
restrict the combinations of values the variables can take. The goal is to find a consistent
assignment of values to the variables that satisfies all the given constraints.
Key Components of CSPs:

1. Variables: The entities that need to be assigned values. Each variable has a domain of
possible values.
2. Domains: The set of possible values that can be assigned to variables. Domains can be
discrete, continuous, finite, or infinite.

3. Constraints: The rules or conditions that limit the combinations of values the variables
can take. Constraints define relationships or dependencies among variables.

11