Scribd
Upload
95 views

Institute: Uie Department: Cse

This document provides information about a presentation on backtracking algorithms. It includes: - Course objectives which are to study subsets, depth-first search (DFS), and finding all possible solutions to a problem. - An overview of backtracking which involves representing solutions as a state space tree and doing a DFS while checking if nodes are promising or not. - An example problem of finding all subsets that sum to a number S. The algorithm uses a promising function to check if partial solutions can still lead to feasible solutions. - Pseudocode of the backtracking algorithm which recursively checks nodes using functions like promising() and aSolutionAt() to find and print all solutions.

Uploaded by

RITESH Chauhan
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
95 views

Institute: Uie Department: Cse

This document provides information about a presentation on backtracking algorithms. It includes: - Course objectives which are to study subsets, depth-first search (DFS), and finding all possible solutions to a problem. - An overview of backtracking which involves representing solutions as a state space tree and doing a DFS while checking if nodes are promising or not. - An example problem of finding all subsets that sum to a number S. The algorithm uses a promising function to check if partial solutions can still lead to feasible solutions. - Pseudocode of the backtracking algorithm which recursively checks nodes using functions like promising() and aSolutionAt() to find and print all solutions.

Uploaded by

RITESH Chauhan
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 21

INSTITUTE : UIE

DEPARTMENT : CSE
Bachelor of Engineering (Computer Science & Engineering)
Design and Analysis of Algorithms (CST-302)

TOPIC OF PRESENTATION: DISCOVER . LEARN . EMPOWER


Backtracking
Course Objectives

• To study about subset

• To Study about DFS.

• To study how to find out all possible


solutions of a give problem.

2
Backtracking

• Two versions of backtracking algorithms

• Solution needs only to be feasible (satisfy problem’s constraints)


• sum of subsets

• Solution needs also to be optimal


The Backtracking Method

• A given problem has a set of constraints and possibly an objective function.

• The solution optimizes an objective function, and/or is feasible.

• We can represent the solution space for the problem using a state space tree.

• The root of the tree represents 0 choices,


• Nodes at depth 1 represent first choice
• Nodes at depth 2 represent the second choice, etc.
• In this tree a path from a root to a leaf represents a candidate solution
Sum of Subsets

• Problem: Given n positive integers w1, ... wn and a positive integer S. Find all subsets of
w1, ... wn that sum to S.

• Example:
n=3, S=6, and w1=2, w2=4, w3=6

• Solutions:
{2,4} and {6}
Sum of Subsets

• We will assume a binary state space tree.

• The nodes at depth 1 are for including (yes, no) item 1, the nodes at depth 2 are for item 2, etc.

• The left branch includes wi, and the right branch excludes wi.

• The nodes contain the sum of the weights included so far


Sum of subset Problem:State SpaceTree for 3
items
w1 = 2, 0w2 = 4, w3 = 6 and S = 6
yes no

i1 2 0

yes no yes no

i2 6 2 4 0

yes no yes no yes no yes no

i3 12 6 8 2 10 4 6 0

The sum of the included integers is stored at the node.


A Depth First Search solution
• Problems can be solved using depth first search of the (implicit) state space
tree.

• Each node will save its depth and its (possibly partial) current solution.

• DFS can check whether node v is a leaf.


• If it is a leaf then check if the current solution satisfies the constraints
• Node can be added to find the optimal solution
A DFS solution

• Such a DFS algorithm will be very slow.

• It does not check for every solution state (node) whether a solution has been
reached, or whether a partial solution can lead to a feasible solution

• Is there a more efficient solution?


Backtracking

• Definition: We call a node nonpromising if it cannot lead to a feasible (or optimal)


solution, otherwise it is promising.

• Main idea: Backtracking consists of doing a DFS of the state space tree, checking whether
each node is promising and if the node is nonpromising backtracking to the node’s parent.
Backtracking

• The state space tree consisting of expanded nodes only is called the pruned
state space tree.

• The following slide shows the pruned state space tree for the sum of subsets
example.

• There are only 15 nodes in the pruned state space tree.

• The full state space tree has 31 nodes


A Pruned State Space Tree (find all solutions)
w1 = 3, w2 = 4, w3 = 5, w4 = 6; S = 13

0
3 0

3 0
4 0 4 0

7 3 4 0

5 0 5 0 5 0

12 7 8 3 9 4
6 0

13 7

Sum of subsets problem


Backtracking Algorithm

void checknode (node v) {


node u

if (promising ( v ))
if (aSolutionAt( v ))
write the solution
else //expand the node
for ( each child u of v )
checknode ( u )
Checknode
• Checknode uses the functions:

• Promising(v) which checks that the partial solution represented by v can lead
to the required solution.

• aSolutionAt(v) which checks whether the partial solution represented by node


v solves the problem.
Sum of subsets – when is a node
“promising”?

• Consider a node at depth i


• weightSoFar = weight of node, i.e., sum of numbers included in partial solution
node represents

• totalPossibleLeft = weight of the remaining items i+1 to n (for a node at depth i)


• A node at depth i is non-promising
if (weightSoFar + totalPossibleLeft < S )
or (weightSoFar + w[i+1] > S )
• To be able to use this “promising function” the wi must be sorted in non-
decreasing order
A Pruned State Space Tree
w1 = 3, w2 = 4, w3 = 5, w4 = 6; S = 13
1
0
3 0
2 3 11 0
4 0 4 0

3 7 12 4 0
8 3 15
5 0 5 0 5 0
13
4 12 5 7 9 8 10 3 9 14 4
6 0

6 13 7 7 - backtrack
Nodes numbered in “call” order
sumOfSubsets ( i, weightSoFar, totalPossibleLeft )
1) if (promising ( i )) //may lead
to solution
2)then if ( weightSoFar == S )
3) then print include[ 1 ] to include[ i ]
//found solution
4) else //expand the node when weightSoFar < S
5) include [ i + 1 ] = "yes” //try
including
6) sumOfSubsets ( i + 1,
weightSoFar + w[i + 1],
totalPossibleLeft - w[i + 1] )
n

Initial call sumOfSubsets(0, 0, 


i 1
wi )
7) include [ i + 1 ] = "no”
//try excluding
8) sumOfSubsets ( i + 1, weightSoFar ,
totalPossibleLeft - w[i + 1] )
boolean promising (i )
1) return ( weightSoFar + totalPossibleLeft  S) &&
( weightSoFar == S || weightSoFar + w[i + 1]  S )
Prints all solutions!
Assessment Pattern
• Internal Assessment: 40(MSTs, Assignments, Quiz, Surprise Test, Attendance)
• External Assessment: 60

19
REFERENCES

1. Introduction to Algorithms by Coreman, Leiserson,Rivest, Stein.


2. Fundamentals of Algorithms by Ellis Horwitz, Sartaj Sahni, Sanguthevar Rajasekaran
3. Different websites providing study material.

20
THANK YOU

You might also like