Fractional Knapsack and Graph Fundamentals

Lecture 27 of CS502 Fundamentals of Algorithms analyzes the Fractional Knapsack problem and introduces fundamental graph theory concepts. In the fractional knapsack model, items are divisible (such as liquids or grain), allowing the thief to take arbitrary fractions x_i in [0, 1] of any item. The optimal greedy strategy computes the value-to-weight ratio v_i / w_i for each item (its 'price per pound'), sorts items in descending order of this ratio, and takes as much of the highest-density item as possible until the knapsack is filled. The lecture proves that this greedy strategy is strictly optimal for fractional knapsack, yet fails on the 0/1 knapsack where indivisibility requires dynamic programming. Transitioning into graph theory, Dr. Sohail Aslam formalizes graphs as mathematical structures G = (V, E) comprising a set of vertices V and edges E. Foundational definitions including directed and undirected graphs, self-loops, multi-edges, paths, cycles, degrees, and connected components are rigorously established. Consistent evaluation of state space trees, dynamic programming matrices, and graph adjacency structures ensures robust preparation for academic assessments. Students investigate the trade-offs between divide-and-conquer strategies, greedy choice properties, and dynamic programming formulations. The discussion highlights how mathematical induction and structural invariants provide formal verification of algorithmic termination and correctness. Key concepts such as optimal substructure, overlapping subproblems, and memoization tables are thoroughly demystified. The lecture details classical algorithmic design techniques demonstrated across standard benchmark problems in computer science. Structured recurrence solving methodologies are demonstrated using the substitution method, recursion tree analysis, and the Master theorem. Algorithmic decision boundaries and lower-bound complexity proofs are evaluated alongside practical runtime performance characteristics. Graph representations are explored through adjacency matrices, adjacency lists, and memory footprint considerations in sparse and dense topologies. Breadth-first and depth-first search mechanics, discovery and finishing timestamps, and edge classifications are systematically analyzed. Greedy strategies including Huffman prefix tree generation and activity scheduling are rigorously proven using exchange arguments. Scholars examine shortest path optimality conditions, edge relaxation properties, and negative cycle detection algorithms.