Competitive Programming in Python 128 Algorithms to Develop your Coding Skills (Christoph Dürr, Jill-Jênn Vie)（Z-Library）

# Competitive Programming in Python: 128 Algorithms to Develop Your Coding Skills ## 【One-Line Pitch】 A practical, problem-driven handbook that teaches 128 classic algorithms and data structures in clean Python, aimed at competitive programmers and tech-interview candidates who want to move from knowing theory to implementing efficient solutions quickly. ## 【Book Arc】 - **Opening (~0%–10%)**: Introduces the competitive programming landscape, Python's suitability for contests, and the essential mechanics of input/output, complexity analysis (Landau notation), and core data structures like queues, heaps, and union-find. - **Early (~10%–32%)**: Covers fundamental techniques—list/dictionary comprehensions, bit manipulation, binary search, and the "Frosting on the Cake" worked example that demonstrates how to reduce a problem's complexity by observing symmetries. - **Middle (~32%–48%)**: Dives into string algorithms (Knuth–Morris–Pratt, Rabin–Karp, Manacher) and sequence problems (Levenshtein distance, longest common subsequence, longest increasing subsequence), introducing dynamic programming as a unifying method. - **Late (~48%–75%)**: Extends to arrays (merge of sorted lists, range queries, maximum subarray sum) and graph algorithms, including Dijkstra's shortest path and other classic problems. - **Ending (~75%–100%)**: Covers advanced data structures like Fenwick trees and dancing links, plus specialized techniques for contest problems; the book closes with a framework for approaching any algorithmic problem systematically. ## 【Key Takeaways】 - **Python is a legitimate contest language** (Early): Despite C++/Java dominance, Python's clarity lets you express algorithms without boilerplate; judges often adjust time limits, though acceptance isn't guaranteed—so optimize carefully. - **Complexity analysis is the first step** (Early): Before writing any code, determine the required time complexity from input size limits; this rules out naive solutions and guides your choice of algorithm. - **Master the core data structures** (Early): Heaps (for priority queues), union-find (for partitions), and queues implemented with two stacks are building blocks for dozens of algorithms; understanding their internals makes you faster at applying them. - **Dynamic programming is a mindset** (Middle): Break problems into subproblems, compute solutions in sweep order, and memoize—this technique powers shortest paths in grids, edit distance, and subsequence problems. - **String algorithms reward cleverness** (Middle): Knuth–Morris–Pratt uses maximal boundaries to achieve linear-time pattern matching; Rabin–Karp trades some correctness risk for simplicity via hashing; both beat naive O(nm) approaches. - **Bit manipulation is a hidden superpower** (Early): Encoding sets as integers and using bitwise operations (e.g., extracting the minimum element) enables exponential-time algorithms for small inputs, like the three-partition problem. - **Observation beats brute force** (Early): The "Frosting on the Cake" example shows how permuting rows/columns preserves the answer, reducing an O(n²) problem to O(n)—always look for symmetries before coding. ## 【Reading Tips】 - **Skim the Preface and Chapter 1** if you're already comfortable with Python basics; focus instead on the complexity section and the "Frosting on the Cake" example, which teaches the problem-solving mindset. - **Deep-read the string and sequence chapters** (Chapters 2–3): These are the heart of the book and introduce the most reusable techniques (boundaries, hashing, dynamic programming). Work through the KMP example by hand. - **Treat code as reference, not gospel**: The authors deliberately avoid numpy for portability; adapt their implementations to your style, but keep the algorithmic core intact. - **Use the companion website (tryalgo.org)** to test implementations against online judges—this is where the real learning happens. - **Skip the advanced data structures** (Fenwick trees, dancing links) on first read; return when you encounter problems that specifically need them. ## 【Coverage Limits】 This guide synthesizes the first ~48% of the book (intro, strings, sequences, arrays); later chapters on graphs, advanced data structures, and specialized techniques are not covered in detail here. ##