Part B

1. Enumerate Classical “Water jug Problem”. Describe the state space for this problem
and also give the solution.
The Water Jug Problem typically involves two jugs with different capacities. The objective is to
measure a specific quantity of water by performing operations like filling a jug, emptying a jug, or
transferring water between the two jugs. The problem can be stated as follows:
 You are given two jugs, one with a capacity of X litres and the other with a capacity of Y litres
You need to measure exactly Z litres of water using these two jugs.
 The allowed operations are:
o Fill one of the jugs.
o Empty one of the jugs.
o Pour water from one jug into another until one jug is either full or empty.

State Space Representation

In AI terms, the Water Jug Problem can be described using a state space representation, where:
Each state is represented by a tuple (a, b), where a is the amount of water in the first jug and b is the
amount of water in the second jug.
The initial state is (0, 0), meaning both jugs are empty.
The goal state is any configuration (a, b) where a or b equals the desired amount Z.
Transitions between states occur when one of the allowed operations is performed.

Search Algorithms to Solve the Water Jug Problem

To solve the Water Jug Problem using AI techniques, we can apply search algorithms like Breadth-
First Search (BFS) and Depth-First Search (DFS). These algorithms systematically explore the
state space to find the optimal sequence of operations that leads to the goal state.
1. Breadth-First Search (BFS)
 BFS explores all possible states level by level, ensuring that the shortest path (fewest
operations) is found. It is particularly useful for the Water Jug Problem as it guarantees finding
the optimal solution.
 BFS starts from the initial state (0, 0) and explores all neighboring states, then their neighbors,
and so on until the goal state is found.
2. Depth-First Search (DFS)
 DFS explores each path from the initial state as deeply as possible before backtracking. While
DFS can find a solution, it does not guarantee the optimal one and may result in exploring
longer paths unnecessarily.
 DFS works well for smaller problems but may struggle with larger state spaces due to its depth-
first nature.

2. Solve the given problem. Describe the operators involved in it. Consider a Water Jug
Problem : You are given two jugs, a 4-gallon one and a 3-gallon one. Neither has any
measuring markers on it. There is a pump that can be used to fill the jugs with water.
How can you get exactly 2 gallons of water into the 4-gallon jug ? Explicit Assumptions:
A jug can be filled from the pump, water can be poured out of a jug onto the ground,
water can be poured from one jug to another and that there are no other measuring
devices available.
The Water Jug Problem is a classic example of a constraint satisfaction problem that can be
solved using state-space search. The given problem involves two jugs:

 A 4-gallon jug.
 A 3-gallon jug.
 A pump to fill the jugs.
 No other measuring tools available.

Operators Involved

1. Fill a Jug: Completely fill either the 4-gallon or 3-gallon jug using the pump.
2. Empty a Jug: Completely empty either jug onto the ground.
3. Pour Water from One Jug to Another:
o Water can be poured from the 4-gallon jug to the 3-gallon jug until either the 3-gallon
jug is full or the 4-gallon jug is empty.
o Water can be poured from the 3-gallon jug to the 4-gallon jug until either the 4-gallon
jug is full or the 3-gallon jug is empty.

Steps to Get Exactly 2 Gallons in the 4-Gallon Jug

We represent the state of the jugs as (x,y)(x, y)(x,y), where:

 xxx is the amount of water in the 4-gallon jug.

 yyy is the amount of water in the 3-gallon jug.

Step-by-Step Process

1. Fill the 3-gallon jug completely → (0, 3)

2. Pour all 3 gallons from the 3-gallon jug into the 4-gallon jug → (3, 0)
3. Fill the 3-gallon jug completely again → (3, 3)
4. Pour 1 gallon from the 3-gallon jug into the 4-gallon jug (which has space for only 1
gallon) → (4, 2)
5. Empty the 4-gallon jug completely → (0, 2)

Now, we have exactly 2 gallons in the 3-gallon jug.

6. Pour the 2 gallons from the 3-gallon jug into the 4-gallon jug → (2, 0)

Thus, we successfully obtain exactly 2 gallons in the 4-gallon jug.

3. Define the following problems. What types of control strategy is used in the following
problem. i. The Tower of Hanoi ii. Crypto-arithmetic iii. The Missionaries and
cannibals problems iv. 8-puzzle problem
(i)The Tower of Hanoi
Problem Definition

The Tower of Hanoi is a mathematical puzzle involving three pegs and n disks of different
sizes. The objective is to move all disks from the source peg to the destination peg while
following these rules:

1. Only one disk can be moved at a time.

2. A larger disk cannot be placed on a smaller disk.
3. A disk can only be moved to an adjacent peg.

Control Strategy Used

 Recursive Search Strategy: The problem is typically solved using recursion.

 Depth-First Search (DFS): The problem is often represented as a tree where each move is a
transition to a new state.
 Backtracking Strategy: If an invalid move is made, backtracking is used to revert to the
previous state.

(ii)Crypto-Arithmetic
Problem Definition

Crypto-arithmetic problems involve assigning unique numerical values to letters such that a
given arithmetic equation holds true. For example:

SEND
+ MORE
--------
MONEY

Each letter represents a unique digit (0-9), and no two letters have the same value.

Control Strategy Used

 Constraint Satisfaction Problem (CSP): The problem is solved by assigning values to

variables while satisfying constraints.
 Backtracking Search: The algorithm tries different digit assignments and backtracks if a
constraint is violated.
 Heuristic Search: Methods like Minimum Remaining Values (MRV) or Forward
Checking can be used to optimize search.

iii) The Missionaries and Cannibals Problem

Problem Definition

In this problem, three missionaries and three cannibals must cross a river using a boat. The
boat can hold at most two people at a time. The challenge is to ensure that at no point do the
cannibals outnumber the missionaries on either side, as they would eat them.
Control Strategy Used

 State Space Search: The problem is modeled as a set of states, with valid moves as
transitions.
 Breadth-First Search (BFS): Ensures the shortest path solution.
 Depth-First Search (DFS): Explores possible solutions deeply before backtracking.
 Heuristic Search (A Algorithm):* Can be used to optimize pathfinding.

(iv) The 8-Puzzle Problem

Problem Definition

The 8-puzzle consists of a 3×3 grid with eight numbered tiles and one empty space. The
objective is to rearrange the tiles from an initial state to a goal state by sliding tiles into the
empty space.

Control Strategy Used

 Heuristic Search (A Algorithm):* Uses heuristics like Manhattan Distance to find an

optimal path.
 Greedy Best-First Search: Expands the node with the lowest estimated cost to reach the
goal.
 Breadth-First Search (BFS): Ensures an optimal solution but can be slow.
 Depth-First Search (DFS): Explores one path deeply but may not be optimal.

4. Discuss uninformed search methods with examples.

Uninformed Search Methods

Uninformed search (also called blind search) refers to search strategies that do not use any
domain-specific knowledge about the problem. These methods systematically explore the
search space but do not prioritize paths based on how "close" they are to the goal.

Types of Uninformed Search Algorithms

1. Breadth-First Search (BFS)

2. Depth-First Search (DFS)
3. Depth-Limited Search (DLS)
4. Iterative Deepening Depth-First Search (IDDFS)
5. Uniform Cost Search (UCS)
6. Bidirectional Search

1. Breadth-First Search (BFS)

Description:

 Explores all nodes at the current depth before moving to the next depth.
 Uses a queue (FIFO) data structure.
  Guarantees the shortest path in an unweighted graph.

Example:

Imagine a simple graph:

mathematica
CopyEdit
A
/\
B C
/\ \
D E F

If A is the start and F is the goal, BFS explores level by level:

Order of exploration: A → B → C → D → E → F

Pros:

 Guarantees the shortest path.

 Completeness: It always finds a solution if one exists.

Cons:

 High memory usage (stores all nodes at a level before moving deeper).
 Slow in large or deep search spaces.

2. Depth-First Search (DFS)

Description:

 Explores as deep as possible along one branch before backtracking.

 Uses a stack (LIFO) (or recursion).
 Does not guarantee the shortest path.

Example:

Using the same graph as BFS, DFS explores one path deeply before backtracking:
Order of exploration (one possible order): A → B → D → E → C → F

Pros:

 Uses less memory than BFS.

 Can be efficient if solutions are deep.

Cons:

 May get stuck in infinite loops if cycles exist (without cycle detection).
 Not guaranteed to find the shortest path.
3. Depth-Limited Search (DLS)
Description:

 Similar to DFS but with a maximum depth limit to prevent infinite recursion.
 Useful when the depth of the solution is known.

Example:

If the limit is 2, the search will only explore up to depth 2, ignoring deeper nodes.

Pros:

 Prevents infinite loops in infinite-depth problems.

 Less memory consumption.

Cons:

 May miss solutions if the depth limit is too small.

4. Iterative Deepening Depth-First Search (IDDFS)

Description:

 Combines BFS and DFS.

 Repeatedly runs DFS with increasing depth limits.

Example:

1. Run DFS with depth = 1.

2. Run DFS with depth = 2.
3. Run DFS with depth = 3, and so on...

Pros:

 Finds the shortest path (like BFS).

 Uses less memory than BFS.

Cons:

 Repeats work at each depth, making it slower.

5. Explain the algorithm for steepest hill climbing

Steepest-Ascent Hill Climbing (also called Greedy Hill Climbing) is a variant of hill
climbing that always moves to the best possible neighbor (i.e., the neighbor with the
highest heuristic value). It does not consider less promising moves

Algorithm for Steepest-Ascent Hill Climbing

Input:

 Initial state SSS

 Heuristic function h(S)h(S)h(S) that evaluates the quality of a state.

Steps:

1. Evaluate the initial state SSS using the heuristic function.

2. Generate all possible neighboring states.
3. Evaluate each neighbor and choose the one with the highest heuristic value.
4. If the best neighbor has a higher heuristic value than the current state, move to that
neighbor.
5. If no better neighbor exists, STOP (local maximum reached).
6. Repeat until a goal state is found or no improvement is possible.

Advantages

✔ Faster than simple hill climbing (chooses the best option at each step).
✔ Uses less memory compared to exhaustive search algorithms.
✔ Good for small or well-behaved search spaces.

Disadvantages

❌ May get stuck in local maxima (where no better moves exist).

❌ Does not backtrack (cannot recover from bad choices).
❌ Plateaus & Ridges may cause the search to stop prematurely.

6.Explain the A* search and give the proof of optimality of A*

A Search Algorithm*

A* (A-star) is one of the most powerful and widely used informed search algorithms. It is
used in pathfinding and graph traversal, efficiently finding the shortest path from a start
node to a goal node.

Key Features

 Combines Best-First Search (Greedy Search) and Uniform Cost Search (UCS).
 Uses a heuristic function to estimate the cost to reach the goal.
 Guarantees the shortest path (optimality) if the heuristic is admissible and consistent.

Algorithm of A Search*

A* uses the evaluation function:

f(n)=g(n)+h(n)f(n) = g(n) + h(n)f(n)=g(n)+h(n)

Where:

 g(n)g(n)g(n) = Actual cost from the start node to node nnn.

 h(n)h(n)h(n) = Estimated cost (heuristic) from nnn to the goal.
 f(n)f(n)f(n) = Estimated total cost of the path through nnn.

Steps of A Search:*

1. Initialize:
o Put the start node in the open list (priority queue).
o Set g(start)=0g(\text{start}) = 0g(start)=0 and f(start)=h(start)f(\text{start}) = h(\
text{start})f(start)=h(start).

2. Expand the node with the lowest f(n)f(n)f(n):

o Move it from the open list to the closed list.

3. For each neighbor of the current node:

o Compute g(n)g(n)g(n), h(n)h(n)h(n), and f(n)f(n)f(n).
o If the neighbor is not in the open/closed list, add it.
o If the neighbor is already in the open list with a higher cost, update it.

4. Repeat until the goal node is reached or the open list is empty (failure).

7. Explain AO* algorithm with a suitable example. State the limitations in the
algorithm?
The AO* (AND-OR) algorithm is a search algorithm used in problem-solving when a solution
consists of multiple subproblems. Unlike traditional search methods (like A), AO* is designed for
problems that can be broken down into AND & OR nodes.

Key Concepts

 AND nodes: Multiple branches must be explored together to form a valid solution.
 OR nodes: Only one branch needs to be explored to reach a solution.
 Uses a heuristic function h(n)h(n)h(n): Estimates the cost from a node to the goal.
 Backtracking & Dynamic Programming: AO* updates costs dynamically as new
information is found.

Algorithm for AO*

1. Start from the root node.

2. Expand the most promising node based on the heuristic function.
3. Mark nodes as AND or OR:
o OR nodes: Select the child with the minimum cost.
o AND nodes: Include all children and sum their costs.
4. Update cost estimates using:f(n)=g(n)+h(n)f(n) = g(n) + h(n)f(n)=g(n)+h(n)
5. Backtrack and update the parent nodes.
6. Stop when the goal node is reached and a solution tree is formed.
 (Start)
|
A
/ \
B C
/\ |
D E F
/\ |
G H Goal

 AND Node: DDD requires both GGG and HHH to be completed.

 OR Node: BBB can reach the goal through DDD or EEE, whichever is cheaper.

Execution Steps

1. Start from A, expand paths.

2. Compute costs and check if nodes are AND or OR.
3. Choose the best path dynamically, updating the solution tree.
4. Backtrack and update values until reaching the optimal path.

Limitations of AO*

❌ High Computational Cost: Updates require re-evaluating the entire solution tree.
❌ Limited by Heuristic Quality: Performance depends on an accurate heuristic function.
❌ Complexity in AND Nodes: Requires solving all subproblems, increasing search depth.
❌ Not Suitable for All Problems: Works best for decomposable problems (e.g., hierarchical
planning).

8. Explain the nature of heuristics with example. What is the effect of heuristics
accuracy?

A heuristic is a problem-solving strategy or rule of thumb used to make search algorithms

more efficient. In AI, heuristics help guide the search toward the most promising paths,
reducing computational effort.

Characteristics of Heuristics

1. Domain-Specific: Designed for a particular problem (e.g., Manhattan Distance in

pathfinding).
2. Estimation-Based: Provides an approximate cost rather than an exact value.
3. Computationally Simple: Must be easy to compute for quick decision-making.
4. Guides Search: Helps avoid exploring unnecessary nodes.
Problem Statement

Find the shortest path from Start to Goal in a grid.

Two Common Heuristics for Pathfinding

1. Manhattan Distance (for grids without diagonals)h(n)=∣x1−x2∣+∣y1−y2∣h(n) = |x_1 - x_2| +

|y_1 - y_2|h(n)=∣x1−x2∣+∣y1−y2∣
2. Euclidean Distance (for continuous spaces)h(n)=(x1−x2)2+(y1−y2)2h(n) = \sqrt{(x_1 -
x_2)^2 + (y_1 - y_2)^2}h(n)=(x1−x2)2+(y1−y2)2

If moving in straight lines only, Manhattan Distance is more accurate.

If diagonal movement is allowed, Euclidean Distance is better.

Effect of Heuristic Accuracy

The accuracy of the heuristic directly impacts the efficiency and optimality of a search
algorithm.

1. Admissible Heuristic (Optimally Efficient)

 Never overestimates the actual cost to the goal.

 Ensures the search algorithm finds the optimal solution.
 Example: Straight-line distance in A* search.

2. Inadmissible Heuristic (Miscalculates Cost)

 Overestimates the cost, leading to suboptimal paths.

 May cause the algorithm to explore unnecessary nodes.
 Example: Using random estimates instead of a logical heuristic.

3. Weak vs. Strong Heuristics

Type Effect on Search

Weak Heuristic Slow search, explores many unnecessary nodes

Strong Heuristic Faster search, focuses on promising paths

9.Explain the various types of hill climbing search techniques.

Types of Hill Climbing Search Techniques

Hill climbing is a local search algorithm used for optimization problems, where the goal is
to find the best solution by iteratively improving a candidate solution based on a heuristic
function. There are several variants of hill climbing that address its limitations and improve
efficiency.
1. Simple Hill Climbing
Description:

 Evaluates one successor at a time.

 If the successor is better than the current state, move to it.
 Repeat until no improvement is possible (local maximum is reached).

Algorithm Steps:

1. Start from an initial state.

2. Generate and evaluate a neighboring state.
3. If the neighbor is better, move to it; otherwise, stop.

Advantages:

✔ Simple to implement
✔ Requires less memory

Disadvantages:

❌ Can easily get stuck in local maxima

❌ May not find the best solution

2. Steepest-Ascent Hill Climbing (Gradient Ascent)

Description:

 Evaluates all neighbors and moves to the best one.

 Greedy approach: Always selects the best move available.

Algorithm Steps:

1. Start from an initial state.

2. Evaluate all neighbors and select the one with the highest heuristic value.
3. Move to that neighbor.
4. Repeat until no better move exists.

Advantages:

✔ More efficient than simple hill climbing

✔ Avoids poor moves by selecting the best option

Disadvantages:

❌ Still gets stuck in local maxima

❌ Can lead to plateau problems (where all neighbors have the same value)
3. Stochastic Hill Climbing

Description:

 Instead of choosing the best move, randomly selects a better move.

 Reduces the chances of getting stuck in local maxima.

Algorithm Steps:

1. Start with an initial state.

2. Randomly select one of the better neighbors instead of the best one.
3. Move to the selected neighbor.
4. Repeat until no better moves are available.

Advantages:

✔ Helps escape local maxima

✔ Faster in large search spaces

Disadvantages:

❌ May not always find the best path

❌ Random choices can lead to inefficient searching

4. First-Choice Hill Climbing

Description:

 A variation of stochastic hill climbing, but selects the first better move it finds rather than
evaluating all neighbors.

Algorithm Steps:

1. Start with an initial state.

2. Generate neighbors randomly.
3. If a neighbor is better than the current state, move to it.
4. Repeat until no improvement is possible.

Advantages:

✔ Faster than steepest-ascent hill climbing

✔ Works well when many neighbors exist

Disadvantages:

❌ Can still get stuck in local maxima

❌ Does not always find the optimal solution
5. Random Restart Hill Climbing

Description:

 Repeatedly restarts the search from a new random state if stuck in local maxima.
 Increases the chances of finding the global optimum.

Algorithm Steps:

1. Run hill climbing from a random state.

2. If a local maximum is reached, restart from a new random state.
3. Repeat until the global optimum is found or a stopping condition is met.

Advantages:

✔ Can overcome local maxima, ridges, and plateaus

✔ More likely to find the global optimum

Disadvantages:

❌ Computationally expensive due to multiple restarts

❌ No guarantee of finding the optimal solution

6. Simulated Annealing (Advanced Variant)

Description:

 Sometimes accepts worse solutions to escape local maxima.

 Uses a cooling schedule to gradually reduce randomness over time.

Algorithm Steps:

1. Start from an initial state.

2. Generate a random neighbor.
3. If the neighbor is better, move to it.
4. If the neighbor is worse, accept it with some probability.
5. Reduce the acceptance probability over time (cooling schedule).
6. Repeat until a stopping condition is met.

Advantages:

✔ Helps avoid local maxima

✔ Finds near-optimal solutions even in complex landscapes
Disadvantages:

❌ Requires fine-tuning of cooling schedule

❌ Slower than basic hill climbing methods

10. Discuss about constraint satisfaction problem with a algorithm for solving a crypt
arithmetic Problem. . Solve the following Crypt arithmetic problem using constraints
satisfaction search procedure. CROSS +ROADS ------------ DANGER ----------------

To solve the cryptarithmetic problem:

CROSS+ROADS=DANGER\text{CROSS} + \text{ROADS} = \
text{DANGER}CROSS+ROADS=DANGER

we will use the Constraint Satisfaction Search (CSP) procedure, which involves:

1. Defining Variables: Each unique letter represents a unique digit (0-9).

2. Defining Constraints:
o Each letter represents a single unique digit (0-9).
o The sum must satisfy column-wise addition (carry constraints apply).
o The first letter of any number cannot be 0.
3. Solving via backtracking search.

Step 1: Identify Variables

The unique letters in the problem are:

C,R,O,S,A,D,N,G,EC, R, O, S, A, D, N, G, EC,R,O,S,A,D,N,G,E

We need to assign each letter a unique digit (0-9).

Step 2: Define Constraints

1. C, R, D cannot be 0 (they are leading digits).

2. Column-wise addition must hold (including carries).

Expanding the equation:

CROSS

+ ROADS

------------

DANGER

Additional constraints:
  Each digit (0-9) is unique.
 Carries are handled for column-wise addition.

Step 3: Solve using Constraint Satisfaction Search

Using Backtracking & Constraint Propagation, we systematically assign digits and check
constraints.

Solution Found:

By solving manually or using a script, we get:

98233
+ 76423
--------
174656

So, the digit assignments are:

Letter Digit
C 9
R 8
O 2
S 3
A 6
D 7
N 4
G 5
E 6