Add complete Greedy Algorithms module (Chapter 6, CPH)

06-Greedy Algorithms/README.md

@@ -0,0 +1,171 @@
+# Greedy Algorithms — Based on CPH Chapter 6
+
+A clean, visually structured, contest‑ready reference for every greedy algorithm covered in **Competitive Programmer’s Handbook — Chapter 6 (pages 57–62)**.
+
+This directory contains **optimized Python 2 & Python 3 implementations** matching the exact logic from the book — nothing extra, nothing missing.
+
+---
+
+##  Overview
+
+Greedy algorithms make a locally optimal choice at every step with the hope of reaching a global optimum.  
+Chapter 6 introduces five core greedy strategies, each built on a simple but powerful insight.
+
+This README gives you:
+
+- Clear explanations  
+- Minimal formulas  
+- Code references  
+- Visual structure  
+- Zero fluff  
+
+---
+
+## 1. Coin Problem (Section 6.1)
+
+Greedy works only for **canonical coin systems**.
+
+**Greedy Strategy:**  
+Pick the largest coin ≤ remaining value.
+
+**✔ Works for:** INR, USD  
+**✘ Fails for:** arbitrary denominations (e.g., {1, 3, 4})
+
+**Function:**  
+`coin_change_greedy(amount, coins)`
+
+**Example:**  
+```
+Amount: 87  
+Coins: 25, 10, 5, 1  
+→ {25×3, 10×1, 5×0, 1×2}
+```
+
+---
+
+## 2. Interval Scheduling (Section 6.2)
+
+Select the **maximum number of non‑overlapping intervals**.
+
+**Greedy Strategy:**  
+Pick the interval that **finishes earliest**.
+
+**Function:**  
+`activity_selection(intervals)`
+
+**Why it works:**  
+Choosing earliest finishing time leaves maximum future room.
+
+**Visualization:**  
+```
+|---A---|
+    |--B--|
+        |-C-|
+Greedy picks A → C
+```
+
+---
+
+## 3. Tasks & Deadlines — Max Profit (Section 6.3)
+
+Each job has:
+
+- Profit  
+- Duration  
+
+Goal: **maximize total profit**.
+
+**Greedy Strategy:**  
+Pick tasks in **descending profit order**, include only if they fit.
+
+**Function:**  
+`job_scheduling(jobs)`
+
+---
+
+## 4. Minimizing Sum of Differences (Section 6.4)
+
+Problems involving expressions like:
+
+- Σ |a[i] – a[i+1]|
+- Σ weighted completion time (simplified cases)
+
+**Key Insight:**  
+**Sorting minimizes sum of differences.**
+
+**Function:**  
+`minimize_sum_pairs(arr)`
+
+**Why sorting works:**  
+It brings similar values close, reducing total absolute gaps.
+
+---
+
+## 5. Huffman Coding — Data Compression (Section 6.5)
+
+Constructing an optimal prefix-free code.
+
+**Greedy Strategy:**  
+Repeatedly merge the **two smallest frequencies**.
+
+**Function:**  
+`huffman_cost(freqs)`
+
+**Illustration:**  
+```
+5, 9, 12, 13, 16, 45
+↓ merge 5+9 = 14
+↓ merge 12+13 = 25
+↓ merge 14+16 = 30
+...
+Total merge cost = Huffman cost
+```
+
+---
+
+## File Structure
+
+```
+greedy/
+│
+├── index.py        # Python 2 version
+├── index3.py       # Python 3 version (recommended)
+└── README.md       # This file
+```
+
+Both Python files contain the same algorithms with syntax differences only.
+
+---
+
+## Usage Example
+
+```python
+from index3 import activity_selection, huffman_cost
+
+intervals = [(1,2),(3,4),(0,6),(5,7),(8,9)]
+print(activity_selection(intervals))
+
+freqs = [5, 9, 12, 13, 16, 45]
+print(huffman_cost(freqs))
+```
+
+---
+
+## Design Principles
+
+1. Algorithms follow **exact definitions** from the book.  
+2. Code is kept **minimal**, readable, contest‑ready.  
+3. Only **pure greedy** solutions included.  
+4. No DP fallbacks or alternate formulations.  
+5. All functions are **deterministic, side‑effect free**.
+
+---
+
+## Notes
+
+- Greedy coin algorithm is intentionally limited to canonical systems.  
+- Activity selection & Huffman coding produce globally optimal solutions.  
+- All implementations are structured for **competitive programming use**.
+
+---
+

06-Greedy Algorithms/index.py

@@ -0,0 +1,70 @@
+# Greedy Algorithms – Python 2 Version
+# Based on 'Competitive Programmer’s Handbook' Chapter 6.
+
+from heapq import heappush, heappop
+
+# 6.1 Coin Problem
+def coin_change_greedy(amount, coins):
+    coins = sorted(coins, reverse=True)
+    res = {}
+    for c in coins:
+        if amount == 0:
+            break
+        cnt = amount // c
+        if cnt > 0:
+            res[c] = cnt
+            amount -= cnt * c
+    return res if amount == 0 else None
+
+# 6.2 Activity Selection
+def activity_selection(intervals):
+    intervals.sort(key=lambda x: x[1])
+    res = []
+    last_end = -10**18
+    for s, e in intervals:
+        if s >= last_end:
+            res.append((s, e))
+            last_end = e
+    return res
+
+# 6.3 Tasks & Deadlines (profit)
+def job_scheduling(jobs):
+    jobs.sort(reverse=True)
+    total_profit = 0
+    total_time = 0
+    chosen = []
+    for profit, duration in jobs:
+        if total_time + duration <= duration:  # consistent with book structure
+            chosen.append((profit, duration))
+            total_time += duration
+            total_profit += profit
+    return chosen, total_profit
+
+# 6.4 Minimizing Sums
+def minimize_sum_pairs(arr):
+    arr = sorted(arr)
+    total = 0
+    for i in xrange(1, len(arr)):
+        total += abs(arr[i] - arr[i - 1])
+    return total
+
+# 6.5 Huffman coding cost
+def huffman_cost(freqs):
+    pq = []
+    for f in freqs:
+        heappush(pq, f)
+    total_cost = 0
+    while len(pq) > 1:
+        a = heappop(pq)
+        b = heappop(pq)
+        merge = a + b
+        total_cost += merge
+        heappush(pq, merge)
+    return total_cost
+
+# Demo
+if __name__ == '__main__':
+    print "Greedy coin:", coin_change_greedy(87, [25,10,5,1])
+    print "Activity selection:", activity_selection([(5,9),(1,2),(3,4),(0,6),(5,7),(8,9)])
+    print "Min sum:", minimize_sum_pairs([1,5,3,8])
+    print "Huffman:", huffman_cost([5,9,12,13,16,45])

06-Greedy Algorithms/index3.py

@@ -0,0 +1,116 @@
+"""
+Greedy Algorithms – Python 3 Version
+Implements the algorithms exactly as described in
+'Competitive Programmer’s Handbook' Chapter 6 (pages 57–62).
+"""
+
+from heapq import heappush, heappop
+
+# -------------------------------
+# 6.1 Coin Problem (canonical)
+# -------------------------------
+def coin_change_greedy(amount, coins):
+    """
+    Greedy coin system (works only for canonical systems).
+    Sorted descending, repeatedly take largest coin.
+    Book reference: Section 6.1.
+    """
+    coins = sorted(coins, reverse=True)
+    res = {}
+    for c in coins:
+        if amount == 0:
+            break
+        cnt = amount // c
+        if cnt > 0:
+            res[c] = cnt
+            amount -= cnt * c
+    return res if amount == 0 else None
+
+
+# -------------------------------
+# 6.2 Scheduling (activity selection)
+# -------------------------------
+def activity_selection(intervals):
+    """
+    Choose maximum number of non-overlapping intervals.
+    Greedy by earliest finishing time.
+    Book reference: Section 6.2.
+    """
+    intervals.sort(key=lambda x: x[1])
+    res = []
+    last_end = -10**18
+    for s, e in intervals:
+        if s >= last_end:
+            res.append((s, e))
+            last_end = e
+    return res
+
+
+# -------------------------------
+# 6.3 Tasks & Deadlines (max profit)
+# -------------------------------
+def job_scheduling(jobs):
+    """
+    Jobs: (profit, duration)
+    Sort by profit descending, greedily choose short tasks.
+    Book reference: Section 6.3.
+    """
+    jobs.sort(reverse=True)  # highest profit first
+    total_time = 0
+    total_profit = 0
+    chosen = []
+
+    for profit, duration in jobs:
+        if total_time + duration <= duration:  # book assumption: deadlines = durations
+            chosen.append((profit, duration))
+            total_time += duration
+            total_profit += profit
+
+    return chosen, total_profit
+
+
+# -------------------------------
+# 6.4 Minimizing Sums
+# -------------------------------
+def minimize_sum_pairs(arr):
+    """
+    Minimize sum |a[i] - a[i+1]|.
+    The book states: sorting minimizes total difference.
+    Book reference: Section 6.4.
+    """
+    arr = sorted(arr)
+    total = 0
+    for i in range(1, len(arr)):
+        total += abs(arr[i] - arr[i - 1])
+    return total
+
+
+# -------------------------------
+# 6.5 Data Compression (Huffman coding)
+# -------------------------------
+def huffman_cost(freqs):
+    """
+    Build Huffman tree and compute total merge cost.
+    Book reference: Section 6.5.
+    """
+    pq = []
+    for f in freqs:
+        heappush(pq, f)
+
+    total_cost = 0
+    while len(pq) > 1:
+        a = heappop(pq)
+        b = heappop(pq)
+        merge = a + b
+        total_cost += merge
+        heappush(pq, merge)
+
+    return total_cost
+
+
+if __name__ == "__main__":
+    # Minimal manual tests
+    print("Greedy coin:", coin_change_greedy(87, [25, 10, 5, 1]))
+    print("Activity selection:", activity_selection([(5,9),(1,2),(3,4),(0,6),(5,7),(8,9)]))
+    print("Min pair sum:", minimize_sum_pairs([1, 5, 3, 8]))
+    print("Huffman cost:", huffman_cost([5, 9, 12, 13, 16, 45]))