Tagged articles
Divide and Conquer
30 articles · Page 1 of 1
This article explains the core principles of quick sort, why its divide‑and‑conquer strategy relies on a good pivot choice, how deterministic pivots can degrade performance on nearly sorted data, and provides a complete randomized Python implementation suitable for interview coding sessions.
Divide and ConquerPythonQuick Sort
0 likes · 6 min read

This article explains the Fork/Join model and Java's ForkJoinPool, covering divide‑and‑conquer theory, task splitting, core APIs, code examples, common pitfalls, performance testing, and best‑practice recommendations for high‑concurrency computing.
Divide and ConquerForkJoinPoolJava Concurrency
0 likes · 25 min read

This article compares end‑to‑end and divide‑and‑conquer algorithmic approaches, outlining their definitions, strengths, weaknesses, and ideal use‑cases, and illustrates the differences with concrete examples in image classification and sorting, helping developers choose the most suitable method for performance and reliability.
AlgorithmDivide and ConquerEnd-to-End
0 likes · 7 min read

This article explains the QuickSort algorithm’s divide-and-conquer principle, walks through its step-by-step process, provides a complete Go implementation with code, discusses practical applications, performance considerations, and future optimization directions, offering readers a solid grasp of sorting fundamentals.
Divide and ConquerGo ProgrammingSorting Algorithm
0 likes · 5 min read

This article explains the limitations of ThreadPoolExecutor, introduces the Fork/Join model and its divide‑and‑conquer algorithm, demonstrates custom RecursiveTask implementations with full source code, analyzes ForkJoinPool construction, task submission, work‑stealing, monitoring APIs, commonPool pitfalls, and performance evaluation, providing practical guidance for Java developers.
ConcurrencyDivide and ConquerForkJoinPool
0 likes · 24 min read


ArchitectJan 12, 2024 · Artificial Intelligence
The article reviews the arXiv paper “Divide and Conquer: Towards Better Embedding‑based Retrieval for Recommender Systems from a Multi‑task Perspective”, explaining how grouping candidates, balancing easy and hard negatives, and using multi‑interest user vectors can improve recall performance in large‑scale recommendation pipelines.
Divide and Conquerembedding retrievalindustry insights
0 likes · 7 min read

This paper identifies the trade‑off between simple and hard negatives in embedding‑based retrieval for recommendation, proposes a clustering‑based divide‑and‑conquer framework combined with prompt‑driven multi‑task learning to improve relevance, diversity, and fairness, and validates the approach through offline metrics, online A/B tests, and comparative experiments.
Approximate Nearest NeighborDivide and ConquerPrompt Tuning
0 likes · 9 min read

This article provides a comprehensive overview of fourteen algorithmic strategies—including greedy, recurrence, recursion, enumeration, backtracking, divide‑and‑conquer, and dynamic programming—explaining their characteristics, typical use cases, inter‑relationships, and the types of problems each approach best addresses.
AlgorithmsDivide and ConquerDynamic Programming
0 likes · 9 min read

The article explains that dynamic programming boils down to two core ideas—treating problems as a set of independent sub‑problems via divide‑and‑conquer and using memoization to avoid redundant calculations—illustrated with analogies to business management and contrasted with plain recursion.
Divide and ConquerDynamic Programmingalgorithm fundamentals
0 likes · 6 min read

This article explains the classic maximum subarray problem, presents a brute‑force O(n³) method, an improved O(n²) version, a divide‑and‑conquer O(N log N) algorithm, and a linear‑time O(N) dynamic‑programming solution, each with full C++ code and complexity analysis.
C++ComplexityDivide and Conquer
0 likes · 8 min read

This article walks through a classic interview problem of locating common URLs in two massive files, explains why a naïve O(m·n) approach fails, and presents a scalable solution using hash‑based divide‑and‑conquer and file partitioning techniques.
Divide and ConquerURL deduplicationbig data
0 likes · 6 min read

This article explains how to handle the massive‑data problem of intersecting two files containing billions of URLs by using hash‑based divide‑and‑conquer techniques, file partitioning, and in‑memory hash lookups to achieve scalable performance beyond naive O(m·n) approaches.
AlgorithmDivide and ConquerHash
0 likes · 8 min read

This article explains the merge sort algorithm in detail, covering its divide‑and‑conquer principle, step‑by‑step process with illustrative examples, a complete C implementation, and an analysis of its time and space complexities and suitable use cases.
Algorithm AnalysisDivide and ConquerSorting Algorithm
0 likes · 7 min read

This article explains the merge sort algorithm’s divide‑and‑conquer principle, analyzes its O(n log n) time complexity, and provides two complete C# code examples—one for a generic merge sort and another for merging two already sorted arrays—along with visual illustrations of the merging process.
AlgorithmC++Divide and Conquer
0 likes · 6 min read

This article explains a memory‑efficient, divide‑and‑conquer approach using hash partitioning and HashSet intersection to identify shared URLs between two massive 5‑billion‑record files while limited to just 4 GB of RAM.
Divide and Conquerhashingmemory optimization
0 likes · 3 min read

This comprehensive guide explores core algorithmic strategies for finding optimal solutions—including recursion, greedy methods, divide-and-conquer, dynamic programming, backtracking, and branch-and-bound—explaining their principles, use-cases, and providing concrete Java and C++ code examples to illustrate implementation details.
AlgorithmsDivide and Conquerbacktracking
0 likes · 54 min read

This article introduces recursion, explains its core principles, presents a general problem‑solving approach, and walks through multiple practical examples—from factorial and climbing stairs to binary tree inversion and the Tower of Hanoi—while analyzing time and space complexities and offering optimization techniques.
AlgorithmDivide and ConquerDynamic Programming
0 likes · 23 min read

The article describes how a Ctrip senior Android engineer uses divide‑and‑conquer, MVP with Clean Architecture, and Jetpack components such as LiveData and ViewModel to break down a highly coupled payment module into reusable view components, improve data flow, and simplify testing and maintenance.
AndroidDivide and ConquerLiveData
0 likes · 10 min read

This article explains the Delaunay triangulation concept, its geometric properties such as empty circumcircles and maximal minimum angles, and presents a detailed divide‑and‑conquer algorithm with step‑by‑step merging logic and a complete TypeScript code implementation.
AlgorithmDelaunay triangulationDivide and Conquer
0 likes · 10 min read

This article explains the quick sort algorithm, covering its basic divide‑and‑conquer principle, a naïve C implementation, improvements such as two‑way partitioning, random and median‑of‑three pivot selection, and a non‑recursive version using an explicit stack, with full source code examples.
Algorithm OptimizationC languageDivide and Conquer
0 likes · 9 min read

This article explains the divide‑and‑conquer principle behind quick sort, walks through a concise Python version and a more classic C‑style implementation, analyzes their inefficiencies, and offers practical optimization tips such as better pivot selection, space reduction, and hybrid sorting strategies.
AlgorithmDivide and ConquerQuick Sort
0 likes · 9 min read

This article explains the quicksort algorithm—its history, divide‑and‑conquer principle, detailed Python implementations, performance analysis, and practical optimizations for small data sets—providing clear examples and interview‑ready code for developers.
Algorithm AnalysisCode ExampleDivide and Conquer
0 likes · 9 min read


21CTOMay 20, 2019 · Fundamentals
This article explains how abstract, layered, divide‑and‑conquer, and evolutionary thinking form the four essential mental tools that enable software architects to manage complexity, design scalable systems, and continuously evolve architectures in response to changing requirements.
Divide and Conquerabstractionarchitectural mindset
0 likes · 17 min read

Quick sort improves on bubble sort by using a divide‑and‑conquer partitioning strategy, selecting a pivot to recursively sort sub‑arrays, achieving an average time complexity of O(n log n) and a worst case of O(n²), with a vivid “hole‑filling” analogy to illustrate the process.
Algorithm ComplexityDivide and ConquerPivot
0 likes · 4 min read

The article explains how abstraction, layered design, divide‑and‑conquer, and evolutionary thinking form the four essential mental tools for architects to manage complexity, illustrating each concept with real‑world examples, diagrams, and practical advice for cultivating these skills.
Divide and Conquerabstractionarchitectural thinking
0 likes · 14 min read


21CTOJul 16, 2018 · Fundamentals
The article explains how mastering abstraction, layering, divide‑and‑conquer, and evolutionary thinking equips software architects to manage complexity, design modular systems, and continuously evolve architectures—from simple modules to large‑scale platforms—highlighting practical examples, interview questions, and learning pathways.
Divide and Conquerabstractionevolutionary design
0 likes · 14 min read

This article explains how abstraction, layered thinking, divide‑and‑conquer, and evolutionary design serve as the four fundamental mental tools that architects use to manage complexity in software systems, illustrated with everyday analogies, diagrams, and practical interview examples.
Divide and Conquerabstractionevolutionary design
0 likes · 15 min read

This article revisits fundamental algorithmic strategies—divide‑and‑conquer, dynamic programming, greedy methods, backtracking, and branch‑and‑bound—detailing their core ideas, applicable problem characteristics, key considerations, procedural steps, and illustrative examples such as merge sort, coin change, Huffman coding, and shortest‑path problems.
AlgorithmsDivide and ConquerDynamic Programming
0 likes · 7 min read

The article revisits fundamental algorithmic strategies—including divide‑and‑conquer, dynamic programming, greedy methods, backtracking, and branch‑and‑bound—detailing their core ideas, applicable problem characteristics, key considerations, procedural steps, and illustrative examples such as merge sort, coin change, Huffman coding, minimum spanning trees, and shortest‑path problems.
AlgorithmsDivide and ConquerDynamic Programming
0 likes · 7 min read

This article explains the divide-and-conquer algorithmic technique, covering its basic concepts, design strategy, three-step recursive process, complexity analysis, and a list of classic problems that can be efficiently solved using this method.
Complexity AnalysisDivide and Conqueralgorithm design
0 likes · 7 min read
