Scribd
Upload
89 views

COMP2230 Introduction To Algorithmics: A/Prof Ljiljana Brankovic

The document summarizes two algorithms: 1) Topological sort, which orders a set of items based on prerequisites, is demonstrated on a course prerequisite example. It works by starting with items having no prerequisites and building the order. 2) Backtracking is used to solve the n-queens problem of placing queens on a chessboard without conflicts. It tries placements recursively and backtracks when it finds conflicts.

Uploaded by

MrZaggy
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PDF, TXT or read online on Scribd
89 views

COMP2230 Introduction To Algorithmics: A/Prof Ljiljana Brankovic

The document summarizes two algorithms: 1) Topological sort, which orders a set of items based on prerequisites, is demonstrated on a course prerequisite example. It works by starting with items having no prerequisites and building the order. 2) Backtracking is used to solve the n-queens problem of placing queens on a chessboard without conflicts. It tries placements recursively and backtracks when it finds conflicts.

Uploaded by

MrZaggy
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 18

COMP2230 Introduction to Algorithmics Lecture 6

A/Prof Ljiljana Brankovic

Lecture Overview
Searching Algorithms: Topological Sort text, Section 4.4 Backtracking text , Section 4.5

Searching

Topological Sort
Example: Given a list of courses and prerequisits, give a topological sort, that is a list of courses in order in which they can be taken to satisfy the prerequisites.

Topological Sort
Course 1 2 3 4 5 6 7 8 9 10 MATH130 MATH140 MATH200 MATH120 COMPSCI150 PHYS130 COMPSCI100 COMPSCI200 COMPSCI240 ENG110 Prerequisite MATH120 MATH130 MATH140, PHYS130 None MATH140 None MATH120 COMPSCI100, COMPSCI150, ENG110 COMPSCI200, PHYS130 none

Topological Sort
In order for topological sort to exist, there must not be a cycle in the prerequisites! We can model this problem as a directed graph it must not have any directed cycle directed acyclic graph (dag)

Topological Sort

1 4

2 5

10

Topological Sort

1 4

2 5

10

Topological Sort

1 4

2 5

10

Topological Sort
3
1 4 2 5 3

10

Topological Sort
3
1 4 2 5 3

10

Topological Sort
3
1 4 2 5 3

10

Topological Sort
9 3
1 4 2 5 3

10

Topological Sort
8 9 3
1 4 2 5 3

10

Topological Sort
5 8 9 3
1 4 2 5 3

10

Topological Sort
2 5 8 9 3
1 4 2 5 3

10

Topological Sort
1
1 4 2 5

2 5 8 9 3
3

10

Topological Sort
1
1 4 2 5

2 5 8 9 3
3

10

Topological Sort
7 1
1 4 2 5

2 5 8 9 3
3

10

Topological Sort
4 7 1
1 4 2 5

2 5 8 9 3
3

10

Topological Sort
6 4 7 1
1 4 2 5

2 5 8 9 3
3

10

Topological Sort
10 6 4 7 1
1 4 2 5

2 5 8 9 3
3

10

Algorithm 4.4.1 Topological Sort


This algorithm computes a topological sort of a directed acyclic graph with vertices 1, ... , n. The vertices in the topological sort are stored in the array ts. The graph is represented using adjacency lists; adj[i ] is a reference to the first node in a linked list of nodes representing the vertices adjacent to vertex i . Each node has members ver , the vertex adjacent to i , and next, the next node in the linked list or null, for the last node in the linked list. To track visited vertices, the algorithm uses an array visit; visit[i ] is set to true if vertex i has been visited or to false if vertex i has not been visited.

Input Parameters: adj Output Parameters: ts top_sort( adj, ts) { n = adj.last // k is the index in ts where the next vertex is to be // stored in topological sort. k is assumed to be global. k = n for i = 1 to n visit [i] = false for i = 1 to n if (! visit[v]) top_sort_recurs(adj,i ,ts) } top_sort_recurs(adj,start ,ts) { visit [start] = true trav = adj[start] while (trav != null) { v = trav. ver if (! visit[v]) top_sort_recurs(adj,v ,ts) trav = trav.next } ts[k] = start k = k - 1 }

Complexity of Topological Sort


Suppose the graph has m edges and n vertices. for loop in top_sort top_sort_recurs Total (n) (m) (m + n)

Backtracking
Backtracking is basically a depth-first search applied to a dynamically generated tree. Example: The n-queens problem is to place n queens on an n n board so that no two queens are in the same row, column, or diagonal.
8 x 8 board

Algorithm n-Queens, Initial Version


Using backtracking, this algorithm outputs all solutions to this problem. We place queens successively in the columns beginning in the left column and working from top to bottom. When it is impossible to place a queen in a column, we return to the previous column and move its queen down.

Example
x

x x

x x

x x

x x x x x

x x x x

Algorithm n-Queens, Initial Version


The value of row [k] is the row where the queen in column k is placed. The algorithm begins when n_queens calls rn_queens(1,n). When rn_queens(k, n) is called, queens have been properly placed in columns 1 through k - 1, and rn_queens(k, n) tries to place a queen in column k. If it is successful and k equals n, it prints a solution. If it is successful and k does not equal n, it calls rn_queens(k + 1,n). If it is not successful, it backtracks by returning to its caller rn_queens(k - 1 ,n).

n_queens( n) { rn_queens (1,n ) } rn_queens (k,n ) { for row[k ] = 1 to n if (position_ok(k ,n)) if (k == n) { for i = 1 to n print (row [i] + ) println() } else rn_queens (k + 1,n ) } position_ok(k ,n) for i = 1 to k - 1 // abs is absolute value if (row[k ] == row [i] || abs(row[k ] - row[ i]) == k - i ) return false return true }

Algorithm 4.5.2 Solving the n-Queens Problem Using Backtracking


The value of row_used[r] is true if a queen occupies row r and false otherwise. The value of ddiag_used[d] is true if a queen occupies ddiag diagonal d and false otherwise. According to the numbering system used, the queen in column k, row r, is in ddiag diagonal n - k + r. The value of udiag_used[d] is true if a queen occupies udiag diagonal d and false otherwise. According to the numbering system used, the queen in column k, row r, is in udiag k + r - 1. The function position_ok(k, n) assumes that queens have been placed in columns 1 through k - 1. It returns true if the queen in column k does not conflict with the queens in columns 1 through k - 1 or false if it does conflict.

Input Parameter: n Output Parameters: None n_queens( n) { for i = 1 to n row_used[ i] = false for i = 1 to 2 * n - 1 ddiag_used[i] = udiag_used[i] = false rn_queens (1,n ) } ...

... // When rn_queens (k,n ) is called, queens have been // properly placed in columns 1 through k - 1. rn_queens (k,n ) { for row[k ] = 1 to n if (position_ok(k ,n)) row_used[ row[ k]] = true ddiag_used[n - k + row[k]] = true udiag_used[k + row[k] - 1] = true if (k == n) { // Output a solution. Stop if only one // solution is desired. for i = 1 to n print (row [i] + ) println() } else rn_queens (k + 1,n ) row_used[ row[ k]] = false ddiag_used[n - k + row[k]] = false udiag_used[k + row[k] - 1] = false } ...

... // position_ok(k, n) returns true if the queen in column k // does not conflict with the queens in columns 1 // through k - 1 or false if it does conflict. position_ok(k ,n) return !( row_used [row [k]] || ddiag_used [n - k + row [k]] || udiag_used [k + row [k] - 1 ]) }

Complexity of Backtracking for n-queens


Suppose we have n x n board. for loops in n_queens rn_queens (n) n(1 + n + n(n-1) + n(n-1)(n-2) + + n(n-1)(n-2)2) = nn!(1/1!+1/2! + + 1/n!) = O(nn!) O(nn!)

Total

You might also like