Scribd
Upload
0 views3 pages

Complete Algorithm Notes

The document provides comprehensive notes on the analysis and design of algorithms, covering key concepts such as algorithm basics, greedy strategies, dynamic programming, backtracking, and advanced topics. It includes detailed discussions on various algorithms, their complexities, and pseudocode examples for practical understanding. Each unit focuses on different algorithmic strategies and their applications in solving complex problems.

Uploaded by

Kishan
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0 views3 pages

Complete Algorithm Notes

The document provides comprehensive notes on the analysis and design of algorithms, covering key concepts such as algorithm basics, greedy strategies, dynamic programming, backtracking, and advanced topics. It includes detailed discussions on various algorithms, their complexities, and pseudocode examples for practical understanding. Each unit focuses on different algorithmic strategies and their applications in solving complex problems.

Uploaded by

Kishan
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

Complete Notes on Analysis and Design of Algorithms

Unit I: Algorithm Basics and Divide & Conquer

Summary: Covers algorithm definitions, time & space complexity, tradeoffs, asymptotic notations

(Big-O, Omega, Theta), recurrence relations and their solutions, and the Divide and Conquer

approach. Includes code tuning techniques like loop, data, and logic optimization.

Topics Covered: Time and Space Complexity, Time-Space Tradeoff, Asymptotic Notation (Big-O,

Theta, Omega), Recurrence Relations and Solving Techniques, Divide and Conquer Strategy,

Examples: Binary Search, Merge Sort, Quick Sort, Heap Sort, Strassens Matrix Multiplication, Code

Tuning Techniques: Loop Optimization, Data Transfer Optimization, Logic Optimization


Pseudocode:
MergeSort(arr):
if length of arr > 1:
mid = len(arr) // 2
left = arr[:mid]
right = arr[mid:]
MergeSort(left)
MergeSort(right)
merge left and right into arr

Unit II: Greedy Strategy

Summary: Explores greedy method algorithms that make locally optimal choices. Includes problems

like optimal merge patterns, Huffman coding, MSTs using Kruskal/Prim, job sequencing, knapsack,

and shortest path algorithms. Also includes correctness proof.

Topics Covered: Greedy Strategy, Optimal Merge Pattern, Huffman Coding, Minimum Spanning

Tree (Kruskal & Prim), Knapsack Problem, Job Sequencing with Deadlines, Single Source Shortest

Path (Dijkstra), Correctness Proof of Greedy Algorithms


Pseudocode:
HuffmanCoding(char_freq):
create min-heap of nodes
while heap has more than one node:
extract two min nodes
merge them and insert back to heap
return root of Huffman Tree

Unit III: Dynamic Programming

Summary: Dynamic programming solves overlapping subproblems and stores results to avoid

recomputation. Used for 0/1 Knapsack, multistage graphs, reliability design, and all-pairs shortest

paths (Floyd-Warshall).

Topics Covered: Dynamic Programming Concept, 0/1 Knapsack Problem, Multistage Graph

Problem, System Reliability Design, Floyd-Warshall Algorithm (All-Pairs Shortest Path)


Pseudocode:
FloydWarshall(dist):
for k from 0 to n:
for i from 0 to n:
for j from 0 to n:
if dist[i][k] + dist[k][j] < dist[i][j]:
dist[i][j] = dist[i][k] + dist[k][j]

Unit IV: Backtracking, Branch & Bound

Summary: Backtracking explores all possible solutions by building candidates and abandoning

invalid ones. Branch & Bound improves it by pruning paths using bounds. Also covers lower bound

theory and introduction to parallel algorithms.

Topics Covered: Backtracking Concepts, 8 Queens Problem, Hamiltonian Cycle, Graph Coloring,

Branch and Bound, Travelling Salesman Problem, Lower Bound Theory, Parallel Algorithms

Introduction
Pseudocode:
GraphColoring(graph, m):
color[] = array of 0s
if solve(graph, m, color, 0):
print color
else:
print "No solution"

solve(graph, m, color, v):


if v == len(graph):
return True
for c in 1 to m:
if isSafe(graph, color, v, c):
color[v] = c
if solve(graph, m, color, v+1):
return True
color[v] = 0
return False

Unit V: Advanced Topics

Summary: Focuses on advanced algorithms including NP-Hard and NP-Complete problems,

Approximation Algorithms, Data Stream Algorithms, and design/complexity of Parallel Algorithms.

Topics Covered: Advanced Tree and Graph Algorithms, NP-Hard and NP-Complete Problems,

Approximation Algorithms, Data Stream Algorithms, Parallel Algorithm Design and Complexity
Pseudocode:
ApproxTSP(graph):
MST = Prim(graph)
PreorderTraversal(MST) to get tour
return tour with approximate cost

You might also like