williamfiset/algorithms

This system is a comprehensive Java library implementing a wide array of fundamental algorithms and data structures, including balanced trees, heaps, graphs, and dynamic programming solutions. It provides both the core algorithmic implementations and the necessary build configurations to compile and run each component as a standalone binary. The codebase is heavily tested with JUnit 5, ensuring the correctness of each algorithmic module.

67 changes.

This period was defined by the extensive addition of new data structures, algorithms, and educational slides, significantly expanding the project's coverage of computer science topics. The work focused on implementing and testing a wide array of data structures, graph algorithms, and dynamic programming solutions, while also introducing build system support for the growing codebase.

6 changes.

This period focused on expanding the library's algorithmic and data structure implementations, introducing dynamic programming solvers for board tiling and edit distance, alongside a new K-D tree data structure. Each new feature was accompanied by comprehensive test coverage to ensure correctness and robustness.

Users can now use new Binary Search Tree and Splay Tree data structures. The Binary Search Tree supports adding, removing, and searching for elements, as well as traversals (preorder, inorder, postorder, and level-order). The Splay Tree implementation provides insertion, deletion, and search operations with splaying, along with find-min and find-max capabilities.

src/main/java/com/williamfiset/algorithms/datastructures/binarysearchtree · high confidence

Users can now use a new DoublyLinkedList class that provides standard list operations including add, remove, peek, and size checks. The implementation includes a BUILD file for the linkedlist module, enabling the library to be built and used as a public dependency.

src/main/java/com/williamfiset/algorithms/datastructures/linkedlist · high confidence

A new EditDistance class was added to the dp.examples.editdistance package, providing two ways to compute the edit distance between two strings: a recursive approach with memoization and an iterative dynamic programming approach (micahEditDistance). Users can now calculate the minimum cost to transform one string into another using configurable insertion, deletion, and substitution costs.

src/main/java/com/williamfiset/algorithms/dp/examples/editdistance · high confidence

A new Fibonacci Heap implementation has been added to the library, providing a priority queue data structure that supports efficient insertion and minimum extraction. The change includes the main \FibonacciHeap\ class, the internal \FibonacciNode\ helper class, and a \BUILD\ file to register the new module. This introduces a new algorithmic capability for users requiring a Fibonacci Heap.

src/main/java/com/williamfiset/algorithms/datastructures/fibonacciheap · high confidence

A new IntArray class has been added to provide a fast, primitive-int dynamic array that avoids the boxing overhead of ArrayList\<Integer\>. The implementation includes bounds checking for index access and removal, along with standard operations like add, remove, sort, and binary search. A corresponding BUILD file has also been added to support the new Java library and binary targets.

src/main/java/com/williamfiset/algorithms/datastructures/dynamicarray · high confidence

A new K-D tree implementation is now available in the data structures library. The \GeneralKDTree\ class provides methods for inserting, searching, finding the minimum value in a specific dimension, and deleting points in a k-dimensional space. This addition is accompanied by a BUILD file to configure the Java library target for the kdtree package.

src/main/java/com/williamfiset/algorithms/datastructures/kdtree · high confidence

A new example class, MinSparseTable, has been added to demonstrate a sparse table implementation for efficient range minimum queries. The class provides O(1) query performance for both the minimum value and its index within a specified range, utilizing a precomputed logarithm table and dynamic programming to build the sparse table structure.

src/main/java/com/williamfiset/algorithms/datastructures/sparsetable/examples · high confidence

A new dynamic programming solution for the 'Mountain Scenes' problem has been added to the algorithms library. This includes the main implementation in \Scenes.java\, which calculates the number of possible mountain scenes given ribbon length, width, and height constraints. Additionally, several input and expected output files (\.in\ and \.ans\) have been added to support testing this new feature.

src/main/java/com/williamfiset/algorithms/dp/examples/scenes · high confidence

A new dynamic programming solution for the 'Narrow Art Gallery' problem (from the 2014 ICPC North America Qualifier) has been added. This includes the main recursive implementation with memoization, along with corresponding input and expected output test files to verify correctness.

src/main/java/com/williamfiset/algorithms/dp/examples/narrowartgallery · high confidence

A new QuadTree data structure implementation is added to the library, providing a spatial indexing structure for integer coordinates. The change includes the core QuadTree.java class, which supports adding points, counting points in a region, and finding k-nearest neighbors, along with a BUILD file for Bazel and a README.md file.

src/main/java/com/williamfiset/algorithms/datastructures/quadtree · high confidence

Users can now perform fast range queries on static arrays using the Sparse Table data structure. The new implementation supports O(1) overlap-friendly operations including MIN, MAX, SUM, MULT, and GCD. It also provides index queries to retrieve the position of the minimum or maximum value in a range.

src/main/java/com/williamfiset/algorithms/datastructures/sparsetable · high confidence

A new Trie data structure has been added to the library, providing efficient storage and retrieval of strings with support for insert, delete, and prefix counting operations. The implementation includes a BUILD file for the module and the core Trie.java class, enabling use cases like autocomplete, spell-checking, and prefix-based searching.

src/main/java/com/williamfiset/algorithms/datastructures/trie · medium confidence

A new Union-Find (Disjoint Set) implementation is added to the library, providing near-constant-time union and find operations using union by size and path compression. The class supports operations to check connectivity, retrieve component sizes, and merge sets, making it suitable for use cases like Kruskal's minimum spanning tree algorithm and detecting cycles in undirected graphs.

src/main/java/com/williamfiset/algorithms/datastructures/unionfind · high confidence

Added new Java implementations for binary, interpolation, and ternary search algorithms, including both continuous and discrete variants. The binary search supports searching over continuous functions, the interpolation search targets uniformly distributed data, and the ternary search locates the minimum of unimodal functions. Build files were also added to support Bazel-based compilation and execution of these algorithms.

src/main/java/com/williamfiset/algorithms/search · high confidence

Added Bazel BUILD files and Java source files for network flow algorithm examples, including CapacityScaling, Dinic's, Edmonds-Karp, and Ford-Fulkerson implementations, along with a MiceAndOwls example, enabling users to build and run these algorithms directly via Bazel.

src/main/java/com/williamfiset/algorithms/graphtheory/networkflow/examples · high confidence

A new dynamic programming algorithm has been added to solve the Tri Tiling problem (Open Kattis). The implementation provides two approaches: a state-based DP using a 2D array to track column configurations, and an alternative 1D DP using a recurrence relation. Test data and expected outputs are included to verify correctness.

src/main/java/com/williamfiset/algorithms/dp/examples/tilingdominoes · high confidence

A new BoardTilingsSolver class has been added to the boardtilings package, providing both iterative and recursive dynamic programming solutions for counting the number of ways to tile a board of length n using a given set of tile sizes. The implementation pre-calculates tile frequencies and uses memoization in the recursive approach to optimize performance.

src/main/java/com/williamfiset/algorithms/dp/examples/boardtilings · high confidence

A new example demonstrating the eager version of Prim's algorithm for finding a minimum spanning tree (MST) has been added. The \EagerPrimsExample\ class implements the algorithm using an indexed priority queue to efficiently query the next best edge, with a time complexity of O(ElogV). A corresponding Bazel BUILD file was also added to support building and running the example.

src/main/java/com/williamfiset/algorithms/graphtheory/examples · high confidence

The queue data structure package now includes three distinct implementations. ArrayQueue provides a generic, circular-buffer-based queue using an object array. IntQueue offers a high-performance, integer-only queue backed by a fixed-size circular buffer that outperforms Java's ArrayDeque. LinkedQueue wraps Java's standard LinkedList to provide a simple, iterable queue. All three implement the new Queue interface, which defines standard queue operations (offer, poll, peek, size, isEmpty).

src/main/java/com/williamfiset/algorithms/datastructures/queue · high confidence

Users can now use three new open-addressing hash table variants—linear probing, quadratic probing, and double hashing—each extending the new HashTableOpenAddressingBase, which manages tombstone-based deletion and lazy relocation to keep probe chains short. A separate-chaining implementation is also added, featuring a private Entry class to cache hash codes and a fail-fast iterator. All implementations include BUILD files for the build system and a test helper for double hashing.

src/main/java/com/williamfiset/algorithms/datastructures/hashtable · high confidence

A new README file has been added to the references directory, providing links to external resources for competitive programming, specifically a Codeforces blog post and the Algorithm Wiki.

references · high confidence

Added new sorting algorithm implementations including Shell sort, Tim sort, QuickSort3, QuickSelect, Radix sort, and others, each implementing the InplaceSort interface. The changes also include a new BUILD file that configures the Bazel build system for the sorting algorithms package, enabling each algorithm to be built and run as a standalone binary.

src/main/java/com/williamfiset/algorithms/sorting · high confidence

Users can now construct suffix arrays using three distinct algorithms with different time complexities: a naive O(n^2 log n) approach (SuffixArraySlow), a medium-speed O(n log^2 n) prefix-doubling method (SuffixArrayMed), and a fast O(n log n) radix-sort-based construction (SuffixArrayFast). All implementations share a common abstract base class (SuffixArray) that supports lazy construction of both the suffix array and the Longest Common Prefix (LCP) array, and includes a toString() method for debugging that displays the suffix array alongside the LCP values.

src/main/java/com/williamfiset/algorithms/datastructures/suffixarray · high confidence

Users can now use a generic Bloom Filter data structure for probabilistic set operations and a Tree Isomorphism algorithm to determine if two unrooted trees are structurally identical. The Bloom Filter supports adding and checking hash values, while the Tree Isomorphism implementation finds tree centers, roots the trees, and compares canonical string encodings to verify isomorphism.

. · high confidence

Added a new dynamic programming solution for the 'Magical Cows' problem, including the main Java class and associated input/output test files. This provides a reference implementation for users to study or run against the provided test cases.

src/main/java/com/williamfiset/algorithms/dp/examples/magicalcows · high confidence

Added BUILD files to the set and utils directories, enabling the HSet implementation and utility classes (TestUtils, TreePrinter) to be built as separate Java libraries. The HSet class provides a hash-based set implementation, while the utils package introduces helper methods for generating random integer lists and printing binary tree structures.

src/main/java/com/williamfiset/algorithms/datastructures/set, src/main/java/com/williamfiset/algorithms/datastructures/utils · high confidence

New slide decks and scripts have been added to the data structures section, covering AVL trees (including insertion, removal, and tree rotations), Fenwick trees (range updates/queries), indexed priority queues, quad trees, red-black trees, sparse tables, and suffix arrays. These resources provide detailed explanations, pseudocode, and examples for each data structure.

slides/datastructures · high confidence

Users can now run two new example programs to see how to calculate the height of a binary tree and the sum of all node values in a general tree. The new TreeHeight.java class provides two implementations for finding the height of a binary tree, while TreeSum.java demonstrates how to compute the sum of values in a tree with arbitrary branching. Both examples include test cases and are configured as Bazel targets for easy execution.

src/main/java/com/williamfiset/algorithms/graphtheory/treealgorithms/examples · high confidence

Added new utility classes for graph algorithms, including a DAG generator and helper methods for creating and modifying adjacency lists. These utilities support testing and internal graph operations, with corresponding BUILD targets for the 'utils' and 'graphutils' packages.

src/main/java/com/williamfiset/algorithms/utils · high confidence

Added implementations for several linear algebra algorithms including Freivalds Algorithm, Gaussian Elimination, Linear Recurrence Solver, Matrix Determinant via Laplace Expansion, Matrix Inverse, Matrix Multiplication, Matrix Power, Modular Linear Algebra, In-Place Matrix Rotation, and the Simplex Algorithm for Linear Programming. A Bazel BUILD file was also added to define the \linearalgebra\ Java library and individual binary targets for each algorithm.

src/main/java/com/williamfiset/algorithms/linearalgebra · high confidence

New Kotlin source files were added to the slides/other/recursion directory, providing code examples for recursive algorithms. These include a flood fill algorithm, recursive multiplication, various recursion examples (counting, printing even numbers), and list summation using recursion and divide-and-conquer approaches.

slides/other · high confidence

The strings package now includes new algorithm implementations: BoothsAlgorithm for finding the lexicographically smallest string rotation, BoyerMooreStringSearch for pattern matching, KMP for substring search, LongestCommonPrefixArray and LongestCommonSubstring for advanced string analysis, LongestRepeatedSubstring, ManachersAlgorithm for palindrome detection, RabinKarp for efficient string matching, SubstringVerificationSuffixArray for fast substring verification, and ZAlgorithm for Z-array computation. A Bazel BUILD file was also added to configure the Java library and define run targets for each algorithm.

src/main/java/com/williamfiset/algorithms/strings · high confidence

A new Skip List implementation is now available, providing O(log n) average complexity for insertion, removal, and search operations. The implementation includes an additional method to determine the index of an element, also with O(log n) average complexity. A BUILD file is added to define the Java library for this data structure.

src/main/java/com/williamfiset/algorithms/datastructures/skiplist · high confidence

Added two new Fenwick Tree (Binary Indexed Tree) implementations: one supporting range updates and point queries, and another supporting range queries and point updates. These classes provide efficient O(log n) operations for interval sums, point modifications, and range updates, accompanied by usage examples in the local README.

src/main/java/com/williamfiset/algorithms/datastructures/fenwicktree · high confidence

The 'other' algorithms package now includes new implementations for bit manipulation, combinations, permutations, power sets, sliding window maximum, square root decomposition, and unique combinations. Each algorithm class includes a main method demonstrating usage. A Bazel BUILD file has been added to define the library and binary targets for these algorithms, enabling them to be built and run via Bazel.

src/main/java/com/williamfiset/algorithms/other · high confidence

Added new implementations for three self-balancing binary search trees in the \balancedtree\ package: \AVLTreeRecursive\ and \AVLTreeRecursiveOptimized\ (with and without \TreePrinter\ integration), a \RedBlackTree\ supporting insert, contains, and delete operations, and a \TreapTree\ supporting insert, remove, and contains. A \BUILD\ file was also added to configure the Java library and binary targets for these structures.

src/main/java/com/williamfiset/algorithms/datastructures/balancedtree · high confidence

Added implementations for several dynamic programming problems: CoinChange (with 2D, space-efficient 1D, and recursive variants), EditDistance (iterative and recursive), JosephusProblem, Knapsack (0/1 and unbounded), LongestCommonSubsequence, LongestIncreasingSubsequence, LongestPalindromeSubsequence, MaximumSubarray (Kadane's algorithm), MinimumWeightPerfectMatching (recursive and iterative), and DagDynamicProgramming (Kahn's algorithm for topological sorting and counting paths in DAGs). A Bazel BUILD file was also added to define Java libraries and binary targets for these algorithms.

src/main/java/com/williamfiset/algorithms/dp · high confidence

Added implementations for 2D and 3D vector angle calculations, circle-circle intersection area and points, circular segment area, closest pair of points, collinear and coplanar point checks, convex hull algorithms (Graham Scan and Monotone Chains), convex polygon area and point containment, polygon cutting, line-circle intersections, and line segment intersections. A Bazel BUILD file was also added to the geometry directory to configure the Java library and binary targets for the new algorithms.

src/main/java/com/williamfiset/algorithms/geometry, src/main/java/com/williamfiset/algorithms/math · high confidence

Added implementations for A\* (grid heuristic), articulation points, Bellman-Ford (adjacency list and edge list), Boruvkas' MST, BFS, bridge finding, Chinese Postman Problem (WIP), connected components (DFS and Union-Find), recursive DFS, and Dijkstra's shortest path. Each algorithm is accompanied by a Bazel BUILD target for standalone execution.

src/main/java/com/williamfiset/algorithms/graphtheory · high confidence

Added implementations for several graph theory algorithms: the Capacity Scaling, Dinic's, Edmonds-Karp, Ford-Fulkerson (DFS), and Min-Cost Max-Flow (Johnson's and Bellman-Ford) algorithms, as well as Maximum Cardinality Bipartite Matching and Bipartite Graph Checking. These new classes provide users with multiple options for solving max-flow and matching problems, each with different time complexity trade-offs. A shared base class and build targets were also added to support these algorithms.

src/main/java/com/williamfiset/algorithms/graphtheory/networkflow · high confidence

Added new priority queue implementations to the library: BinaryHeap, BinaryHeapQuickRemovals, MinDHeap, MinIndexedBinaryHeap, and MinIndexedDHeap. These provide various heap-based priority queue options, including indexed heaps for O(log n) removals and O(1) containment checks.

src/main/java/com/williamfiset/algorithms/datastructures/priorityqueue · high confidence

Added a Bazel BUILD file for the segment tree package, defining a library and binary targets for various segment tree implementations. Introduced new Java classes including CompactSegmentTree, GenericSegmentTree, MaxQuerySumUpdateSegmentTree, MinQueryAssignUpdateSegmentTree, MinQuerySumUpdateSegmentTree, Node, RangeQueryPointUpdateSegmentTree, SumQueryAssignUpdateSegmentTree, SumQueryMultiplicationUpdateSegmentTree, and SumQuerySumUpdateSegmentTree, each providing specific range query and update capabilities.

src/main/java/com/williamfiset/algorithms/datastructures/segmenttree · high confidence

Added new stack implementations including a generic array-based stack (ArrayStack), a primitive int stack (IntStack) optimized for performance, and a linked-list-based stack (ListStack) that supports iteration in LIFO order. The Stack interface and build configuration are also included.

src/main/java/com/williamfiset/algorithms/datastructures/stack · high confidence

Added new algorithms for finding the Lowest Common Ancestor (LCA) using an Euler tour and sparse table, identifying the center(s) of a tree via both iterative leaf-peeling and longest-path approaches, and calculating the tree diameter. These implementations are now available in the treealgorithms package with corresponding Bazel build targets for each.

src/main/java/com/williamfiset/algorithms/graphtheory/treealgorithms · high confidence

A change to existing behaviour in slides/graphtheory/other — 1 commit, 2 files.

slides/audio, slides/graphtheory/other · medium confidence · unverified

A change to existing behaviour in slides/dynamicprogramming — 131 commits (1 fix), 13 files.

slides/dynamicprogramming · medium confidence · unverified

A change to existing behaviour in slides/constructivealgorithms — 2 commits, 4 files.

slides, slides/constructivealgorithms, slides/graphtheory · medium confidence · unverified

Add HSet unit tests with JUnit 5 and Google Truth; Add JUnit 5-based tests for queue implementations; Add comprehensive JUnit 5 tests for all sorting algorithms; Add comprehensive test coverage for graph theory algorithms; Add test coverage for balanced tree and bloom filter data structures; Add tests for FibonacciHeap data structure; Add unit tests for the Trie data structure; Added JUnit 5 test suite for dynamic programming algorithms; Added JUnit 5 test suites for tree algorithms; Added JUnit 5 tests for priority queue data structures; Added JUnit 5 tests for the Union Find data structure; Added comprehensive test coverage for segment tree data structures; Added comprehensive tests and build configuration for hashtable implementations; Added test coverage for BitManipulations, PowerSet, and SlidingWindowMaximum; Added test coverage for IntArray data structure; Added test coverage for InterpolationSearch; Added test coverage for Z-Algorithm, Boyer-Moore, and Longest Common Substring; Added test coverage for network flow algorithms; Added tests for DoublyLinkedList; Added tests for Fenwick tree data structures; Added tests for Stack data structure implementations; Added tests for math algorithms; Added tests for the K-D Tree data structure; Added tests for the SkipList data structure; Added unit tests for SparseTable operations; Added unit tests for SuffixArray implementations.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 65 → 71 (+6.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 75 → 83 (+8.0)
• Architecture 100 → 100 (-0.0)
• Maturity 55 → 60 (+5.4)
• Readiness 70 → 74 (+4.3)
• Security 71 → 84 (+12.6)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — no supported dependency manifest was read
• Duplicated block (10 lines × 2) (src/main/java/com/williamfiset/algorithms/datastructures/segmenttree/MaxQuerySumUpdateSegmentTree.java)
• Duplicated block (10 lines × 2) (src/main/java/com/williamfiset/algorithms/datastructures/suffixarray/SuffixArrayMed.java)
• Duplicated block (10 lines × 2) (src/main/java/com/williamfiset/algorithms/dp/WeightedMaximumCardinalityMatchingRecursive.java)
• Duplicated block (10 lines × 2) (src/main/java/com/williamfiset/algorithms/geometry/AngleBetweenVectors2D.java)
• Duplicated block (10 lines × 2) (src/main/java/com/williamfiset/algorithms/graphtheory/Boruvkas.java)
• Duplicated block (10 lines × 2) (src/main/java/com/williamfiset/algorithms/graphtheory/EulerianPathDirectedEdgesAdjacencyList.java)
• Duplicated block (10 lines × 2) (src/main/java/com/williamfiset/algorithms/math/ChineseRemainderTheorem.java)
• Duplicated block (10 lines × 3) (src/main/java/com/williamfiset/algorithms/datastructures/hashtable/HashTableOpenAddressingBase.java)
• Duplicated block (10 lines × 3) (src/main/java/com/williamfiset/algorithms/datastructures/sparsetable/examples/MinSparseTable.java)
• Duplicated block (11 lines × 2) (src/main/java/com/williamfiset/algorithms/datastructures/priorityqueue/BinaryHeap.java)
• Duplicated block (11 lines × 2) (src/main/java/com/williamfiset/algorithms/graphtheory/networkflow/MinCostMaxFlowJohnsons.java)
• Duplicated block (11 lines × 2) (src/main/java/com/williamfiset/algorithms/graphtheory/treealgorithms/RootingTree.java)
• Duplicated block (11 lines × 2) (src/main/java/com/williamfiset/algorithms/sorting/QuickSelect.java)
• Duplicated block (12 lines × 2) (src/main/java/com/williamfiset/algorithms/dp/WeightedMaximumCardinalityMatchingIterative.java)
• Duplicated block (12 lines × 2) (src/main/java/com/williamfiset/algorithms/dp/WeightedMaximumCardinalityMatchingRecursive.java)
• Duplicated block (12 lines × 2) (src/main/java/com/williamfiset/algorithms/graphtheory/analysis/PrimsGraphRepresentationAnaylsis.java)
• Duplicated block (12 lines × 2) (src/main/java/com/williamfiset/algorithms/graphtheory/networkflow/examples/CapacityScalingExample.java)
• Duplicated block (12 lines × 2) (src/main/java/com/williamfiset/algorithms/graphtheory/networkflow/examples/FordFulkersonExample.java)
• …and 109 more

• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (src/main/java/com/williamfiset/algorithms/datastructures/queue/IntQueue.java)
• Duplicated block (10 lines × 2) (src/main/java/com/williamfiset/algorithms/dp/WeightedMaximumCardinalityMatchingRecursive.java)
• Duplicated block (10 lines × 2) (src/main/java/com/williamfiset/algorithms/math/ChineseRemainderTheorem.java)
• Duplicated block (10 lines × 2) (src/main/java/com/williamfiset/algorithms/strings/LongestCommonPrefixArray.java)
• Duplicated block (10–11 lines × 2) (src/main/java/com/williamfiset/algorithms/graphtheory/treealgorithms/RootingTree.java)
• Duplicated block (10–12 lines × 2) (src/main/java/com/williamfiset/algorithms/graphtheory/ArticulationPointsAdjacencyList.java)
• Duplicated block (11 lines × 2) (src/main/java/com/williamfiset/algorithms/datastructures/segmenttree/MaxQuerySumUpdateSegmentTree.java)
• Duplicated block (11 lines × 2) (src/main/java/com/williamfiset/algorithms/math/ChineseRemainderTheorem.java)
• Duplicated block (12 lines × 2) (src/main/java/com/williamfiset/algorithms/dp/MinimumWeightPerfectMatching.java)
• Duplicated block (12 lines × 2) (src/main/java/com/williamfiset/algorithms/geometry/AngleBetweenVectors2D.java)
• Duplicated block (12 lines × 2) (src/main/java/com/williamfiset/algorithms/graphtheory/Boruvkas.java)
• Duplicated block (12 lines × 2) (src/main/java/com/williamfiset/algorithms/graphtheory/EulerianPathDirectedEdgesAdjacencyList.java)
• Duplicated block (12 lines × 2) (src/main/java/com/williamfiset/algorithms/graphtheory/treealgorithms/RootingTree.java)
• Duplicated block (12 lines × 3) (src/main/java/com/williamfiset/algorithms/graphtheory/networkflow/examples/CapacityScalingExample.java)
• Duplicated block (12 lines × 5) (src/main/java/com/williamfiset/algorithms/datastructures/priorityqueue/MinIndexedDHeap.java)
• Duplicated block (12–13 lines × 2) (src/main/java/com/williamfiset/algorithms/graphtheory/networkflow/Dinics.java)
• Duplicated block (13 lines × 2) (src/main/java/com/williamfiset/algorithms/datastructures/segmenttree/MinQueryAssignUpdateSegmentTree.java)
• Duplicated block (13 lines × 2) (src/main/java/com/williamfiset/algorithms/datastructures/segmenttree/SumQueryMultiplicationUpdateSegmentTree.java)
• …and 215 more

• Containers 0 added · 0 removed · contexts 1 added · 1 removed · edges 0 added · 0 removed

• repository

• .

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

williamfiset/algorithms was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.