├── .gitignore ├── .gitmodules ├── README.md ├── assets └── slides.sass ├── config.yaml ├── content ├── english │ ├── _index.md │ └── hpc │ │ ├── _index.md │ │ ├── algorithms │ │ ├── _index.md │ │ ├── argmin.md │ │ ├── factorization.md │ │ ├── gcd.md │ │ ├── img │ │ │ ├── column-major.jpg │ │ │ ├── euclid.svg │ │ │ ├── gcd-dependency1.png │ │ │ ├── gcd-dependency2.png │ │ │ ├── mm-blas.svg │ │ │ ├── mm-blocked-barplot.svg │ │ │ ├── mm-blocked-plot.svg │ │ │ ├── mm-kernel-barplot.svg │ │ │ ├── mm-kernel-plot.svg │ │ │ ├── mm-noalloc.svg │ │ │ ├── mm-vectorized-barplot.svg │ │ │ ├── mm-vectorized-plot.svg │ │ │ ├── prefix-blocked.svg │ │ │ ├── prefix-interleaved-prefetch.svg │ │ │ ├── prefix-interleaved.svg │ │ │ ├── prefix-nontemporal.svg │ │ │ ├── prefix-outline.png │ │ │ ├── prefix-prefetch.svg │ │ │ ├── prefix-scalar.svg │ │ │ ├── prefix-simd.svg │ │ │ └── rho.jpg │ │ ├── logistic.md │ │ ├── matmul.md │ │ ├── prefix.md │ │ ├── reading-integers.md │ │ └── sorting.md │ │ ├── architecture │ │ ├── _index.md │ │ ├── assembly.md │ │ ├── functions.md │ │ ├── img │ │ │ ├── birthday.png │ │ │ ├── clt.png │ │ │ ├── monte-carlo.gif │ │ │ └── pdf.png │ │ ├── indirect.md │ │ ├── interaction.md │ │ ├── isa.md │ │ ├── layout.md │ │ └── loops.md │ │ ├── arithmetic │ │ ├── _index.md │ │ ├── bit-hacks.md │ │ ├── compression.md │ │ ├── division.md │ │ ├── errors.md │ │ ├── float.md │ │ ├── ieee-754.md │ │ ├── img │ │ │ ├── aes.png │ │ │ ├── approx.svg │ │ │ ├── clock.gif │ │ │ ├── complex-circle.png │ │ │ ├── complex-plane.png │ │ │ ├── float.svg │ │ │ ├── iq.jpg │ │ │ ├── iq.svg │ │ │ ├── mnist.png │ │ │ ├── newton.png │ │ │ ├── norm.svg │ │ │ ├── permutation.png │ │ │ └── roots.png │ │ ├── integer.md │ │ ├── newton.md │ │ └── rsqrt.md │ │ ├── compilation │ │ ├── _index.md │ │ ├── abstractions.md │ │ ├── arithmetic.md │ │ ├── contracts.md │ │ ├── flags.md │ │ ├── limitations.md │ │ ├── precalc.md │ │ ├── situational.md │ │ └── stages.md │ │ ├── complexity │ │ ├── _index.md │ │ ├── hardware.md │ │ ├── img │ │ │ ├── bug.jpg │ │ │ ├── complexity.jpg │ │ │ ├── cpu.png │ │ │ ├── dennard.ppm │ │ │ ├── die-shot.jpg │ │ │ ├── lithography.png │ │ │ └── mos-6502.jpg │ │ ├── languages.md │ │ ├── levels.md │ │ └── models.md │ │ ├── cpu-cache │ │ ├── _index.md │ │ ├── alignment.md │ │ ├── aos-soa.md │ │ ├── associativity.md │ │ ├── bandwidth.md │ │ ├── cache-lines.md │ │ ├── img │ │ │ ├── address.png │ │ │ ├── affinity.svg │ │ │ ├── aos-soa-padded-n.svg │ │ │ ├── aos-soa-padded.svg │ │ │ ├── aos-soa.svg │ │ │ ├── boost.svg │ │ │ ├── cache1-full.png │ │ │ ├── cache1.png │ │ │ ├── cache2-full.png │ │ │ ├── cache2.png │ │ │ ├── cache3-full.png │ │ │ ├── cache3.png │ │ │ ├── directional.svg │ │ │ ├── inc.svg │ │ │ ├── latency-bandwidth.svg │ │ │ ├── latency-throughput.svg │ │ │ ├── lstopo.png │ │ │ ├── non-temporal.svg │ │ │ ├── parallel-bandwidth.svg │ │ │ ├── parallel.svg │ │ │ ├── permutation-bf-custom.svg │ │ │ ├── permutation-boost-speedup.svg │ │ │ ├── permutation-boost.svg │ │ │ ├── permutation-hugepages.svg │ │ │ ├── permutation-latency.svg │ │ │ ├── permutation-mlp.svg │ │ │ ├── permutation-p32.svg │ │ │ ├── permutation-p64.svg │ │ │ ├── permutation-padded.svg │ │ │ ├── permutation-throughput.svg │ │ │ ├── ram.png │ │ │ ├── soa-hugepages.svg │ │ │ ├── strided.svg │ │ │ ├── strided2.svg │ │ │ ├── strides-hugepages.svg │ │ │ ├── strides-small.svg │ │ │ ├── strides.svg │ │ │ ├── sw-prefetch-others.svg │ │ │ └── sw-prefetch.svg │ │ ├── latency.md │ │ ├── mlp.md │ │ ├── paging.md │ │ ├── pointers.md │ │ ├── prefetching.md │ │ └── sharing.md │ │ ├── data-structures │ │ ├── _index.md │ │ ├── b-tree.md │ │ ├── binary-search.md │ │ ├── bitset.md │ │ ├── filters.md │ │ ├── hash-tables.md │ │ ├── img │ │ │ ├── b-tree.jpg │ │ │ ├── b-tree.png │ │ │ ├── binary-heat.png │ │ │ ├── binary-search.png │ │ │ ├── bplus.png │ │ │ ├── btree-absl.svg │ │ │ ├── btree-absolute.svg │ │ │ ├── btree-relative.svg │ │ │ ├── eytzinger-heat.png │ │ │ ├── eytzinger-search.png │ │ │ ├── eytzinger.png │ │ │ ├── eytzinger_old.png │ │ │ ├── fenwick-sum.png │ │ │ ├── fenwick-update.png │ │ │ ├── search-all.svg │ │ │ ├── search-bplus-other.svg │ │ │ ├── search-bplus.svg │ │ │ ├── search-branchless-prefetch.svg │ │ │ ├── search-branchless.svg │ │ │ ├── search-btree-hugepages.svg │ │ │ ├── search-btree-optimized.svg │ │ │ ├── search-btree.svg │ │ │ ├── search-eytzinger-branchless.svg │ │ │ ├── search-eytzinger-prefetch.svg │ │ │ ├── search-eytzinger-small.svg │ │ │ ├── search-eytzinger.svg │ │ │ ├── search-latency-bplus.svg │ │ │ ├── search-random-relative.svg │ │ │ ├── search-random.svg │ │ │ ├── search-relative-latency.svg │ │ │ ├── search-relative.svg │ │ │ ├── search-set-relative-all.svg │ │ │ ├── search-set-relative.svg │ │ │ ├── search-std.svg │ │ │ ├── segtree-bottomup.svg │ │ │ ├── segtree-branchless.svg │ │ │ ├── segtree-fenwick-holes.svg │ │ │ ├── segtree-fenwick.svg │ │ │ ├── segtree-iterative.svg │ │ │ ├── segtree-layout.png │ │ │ ├── segtree-path.png │ │ │ ├── segtree-permuted.png │ │ │ ├── segtree-pointers.svg │ │ │ ├── segtree-popular-relative.svg │ │ │ ├── segtree-popular.svg │ │ │ ├── segtree-simd-others.svg │ │ │ ├── segtree-simd.svg │ │ │ ├── segtree-succinct.png │ │ │ ├── segtree-topdown.svg │ │ │ ├── segtree-wide.png │ │ │ └── src │ │ │ │ ├── eytzinger.svg │ │ │ │ ├── fenwick-sum.svg │ │ │ │ ├── fenwick-update.svg │ │ │ │ ├── segtree-layout.svg │ │ │ │ ├── segtree-path.svg │ │ │ │ ├── segtree-permuted.svg │ │ │ │ ├── segtree-succinct.svg │ │ │ │ └── segtree-wide.svg │ │ ├── s-tree.md │ │ └── segment-trees.md │ │ ├── distributed │ │ ├── _index.md │ │ ├── actor.md │ │ ├── algorithms │ │ │ └── _index.md │ │ ├── cloud.md │ │ ├── mapreduce │ │ │ └── _index.md │ │ └── mpi │ │ │ └── _index.md │ │ ├── external-memory │ │ ├── _index.md │ │ ├── hierarchy.md │ │ ├── img │ │ │ ├── hierarchy.png │ │ │ ├── k-way.png │ │ │ ├── list-ranking.png │ │ │ ├── memory-vs-compute.png │ │ │ ├── mergesort.png │ │ │ ├── opt.png │ │ │ ├── sparse-table.png │ │ │ └── virtual-memory.jpg │ │ ├── list-ranking.md │ │ ├── locality.md │ │ ├── management.md │ │ ├── model.md │ │ ├── oblivious.md │ │ ├── policies.md │ │ ├── sorting.md │ │ ├── sublinear.md │ │ └── virtual.md │ │ ├── number-theory │ │ ├── _index.md │ │ ├── cryptography.md │ │ ├── error-correction.md │ │ ├── euclid-extended.md │ │ ├── exponentiation.md │ │ ├── finite.md │ │ ├── hashing.md │ │ ├── img │ │ │ └── clock.gif │ │ ├── modular.md │ │ ├── montgomery.md │ │ └── rng.md │ │ ├── parallel │ │ ├── _index.md │ │ ├── algorithms │ │ │ ├── _index.md │ │ │ └── openmp.md │ │ ├── concurrency │ │ │ ├── _index.md │ │ │ ├── event-driven.md │ │ │ ├── fibers.md │ │ │ ├── processes.md │ │ │ └── threads.md │ │ ├── gpu │ │ │ ├── _index.en.md │ │ │ └── cuda.md │ │ ├── img │ │ │ └── moores-law.jpg │ │ ├── runtimes.md │ │ └── synchronization │ │ │ ├── _index.md │ │ │ └── mutex.md │ │ ├── pipelining │ │ ├── _index.md │ │ ├── branching.md │ │ ├── branchless.md │ │ ├── hazards.md │ │ ├── img │ │ │ ├── branchy-vs-branchless.svg │ │ │ ├── bubble.png │ │ │ ├── pipeline.png │ │ │ ├── probabilities.svg │ │ │ └── superscalar.png │ │ ├── limits.md │ │ ├── scheduling.md │ │ ├── tables.md │ │ └── throughput.md │ │ ├── preface.md │ │ ├── profiling │ │ ├── _index.md │ │ ├── benchmarking.md │ │ ├── events.md │ │ ├── instrumentation.md │ │ ├── mca.md │ │ ├── noise.md │ │ └── simulation.md │ │ ├── simd │ │ ├── _index.md │ │ ├── auto-vectorization.md │ │ ├── img │ │ │ ├── filter.svg │ │ │ ├── gather-scatter.png │ │ │ ├── gather.svg │ │ │ ├── hsum.png │ │ │ ├── intel-extensions.webp │ │ │ └── simd.png │ │ ├── intrinsics.md │ │ ├── masking.md │ │ ├── moving.md │ │ ├── reduction.md │ │ └── shuffling.md │ │ ├── slides │ │ ├── 01-intro │ │ │ └── _index.md │ │ └── _index.md │ │ ├── stats.md │ │ └── summary.md └── russian │ ├── _index.md │ ├── contributing.md │ ├── cs │ ├── _index.md │ ├── algebra │ │ ├── _index.md │ │ ├── binpow.md │ │ ├── fft.md │ │ ├── gauss.md │ │ ├── hadamard.md │ │ ├── img │ │ │ ├── convolution.gif │ │ │ ├── dogs.jpg │ │ │ ├── extrapolation.png │ │ │ ├── fft-shuffle.png │ │ │ ├── lagrange.gif │ │ │ ├── linear.png │ │ │ ├── matmul.png │ │ │ └── roots-unity.png │ │ ├── interpolation.md │ │ ├── karatsuba.md │ │ ├── matmul.md │ │ ├── matrix.md │ │ └── polynomials.md │ ├── arithmetic │ │ ├── _index.md │ │ ├── big-integer.md │ │ ├── bit-representation.md │ │ ├── floating-point.md │ │ ├── img │ │ │ ├── intel-isa.png │ │ │ ├── simd-vs-scalar.gif │ │ │ └── simd.png │ │ ├── simd-old.md │ │ └── simd.md │ ├── basic-structures │ │ ├── _index.md │ │ ├── array.md │ │ ├── deque.md │ │ ├── heap.md │ │ ├── img │ │ │ ├── linked.png │ │ │ └── memory-layout.png │ │ ├── iterators.md │ │ ├── list.md │ │ ├── queue.md │ │ ├── stack-minima.md │ │ ├── stack.md │ │ └── vector.md │ ├── combinatorial-objects │ │ ├── _index.md │ │ ├── bracket-sequences.md │ │ ├── encode-decode.md │ │ ├── generation.md │ │ ├── numbers.md │ │ ├── permutations.md │ │ └── prufer.md │ ├── combinatorial-optimization │ │ ├── _index.md │ │ ├── annealing.md │ │ ├── greedy.md │ │ ├── huffman.md │ │ ├── img │ │ │ ├── annealing.gif │ │ │ └── tsp.gif │ │ ├── knapsack.md │ │ ├── linear-programming.md │ │ ├── matroid.md │ │ └── tsp.md │ ├── complexity │ │ ├── _index.md │ │ ├── amortization.md │ │ ├── asymptotic.md │ │ ├── img │ │ │ └── divide-and-conquer.png │ │ ├── master-theorem.md │ │ ├── models.md │ │ └── randomized.md │ ├── convex-hulls │ │ ├── _index.md │ │ ├── chan.md │ │ ├── envelope.md │ │ ├── graham.md │ │ ├── half-plane.md │ │ ├── hull-applications.md │ │ ├── img │ │ │ ├── chan.gif │ │ │ ├── convex-hull.png │ │ │ ├── graham.gif │ │ │ ├── jarvis.jpg │ │ │ └── jarvis.png │ │ ├── jarvis.md │ │ └── li-chao.md │ ├── decomposition │ │ ├── _index.md │ │ ├── divide-and-conquer.md │ │ ├── img │ │ │ ├── 2d-scanline.jpg │ │ │ ├── 2d-sum.jpg │ │ │ └── cliques.png │ │ ├── mitm.md │ │ ├── mo.md │ │ ├── recursion.md │ │ ├── rollback.md │ │ ├── scanline.md │ │ └── sqrt-heuristics.md │ ├── dynamic-subsets │ │ ├── _index.md │ │ ├── masks.md │ │ ├── parameter-answer.md │ │ ├── profile-dynamics.md │ │ └── submasks.md │ ├── factorization │ │ ├── _index.md │ │ ├── eratosthenes.md │ │ ├── factorization-applications.md │ │ ├── img │ │ │ └── rho.jpg │ │ ├── pollard.md │ │ ├── primality-testing.md │ │ ├── primes.md │ │ └── sqrt-factorization.md │ ├── flows │ │ ├── _index.md │ │ ├── blocking.md │ │ ├── dinic.md │ │ ├── edmonds-karp.md │ │ ├── ford-fulkerson.md │ │ ├── img │ │ │ └── network.svg │ │ ├── min-cut.md │ │ └── mincost-maxflow.md │ ├── games │ │ ├── _index.md │ │ ├── cyclic-games.md │ │ ├── games-on-graphs.md │ │ ├── img │ │ │ ├── nim.jpg │ │ │ ├── zugzwang.png │ │ │ └── Введение_в_теорию_комбинаторных_игр.pdf │ │ ├── incomplete-information.md │ │ ├── minimax.md │ │ ├── nim-reductions.md │ │ ├── nim.md │ │ ├── pruning.md │ │ └── sprague-grundy.md │ ├── general-dynamic │ │ ├── 2d.md │ │ ├── _index.md │ │ ├── memoization.md │ │ ├── restoring.md │ │ ├── segments.md │ │ └── sequences.md │ ├── geometry-advanced │ │ ├── _index.md │ │ ├── area.md │ │ ├── planar-graphs.md │ │ └── two-closest.md │ ├── geometry-basic │ │ ├── _index.md │ │ ├── circles.md │ │ ├── img │ │ │ ├── area.jpg │ │ │ ├── cross.jpg │ │ │ ├── dodecahedron.gif │ │ │ ├── dot.jpg │ │ │ ├── findx.jpg │ │ │ ├── polygons.svg │ │ │ ├── ray.gif │ │ │ ├── ray.png │ │ │ ├── segments.png │ │ │ ├── trapeze.jpg │ │ │ ├── trapeze.png │ │ │ ├── triangles.png │ │ │ ├── trig.svg │ │ │ ├── vector.jpg │ │ │ └── voronoi.png │ │ ├── polygons.md │ │ ├── products.md │ │ ├── segments.md │ │ └── vectors.md │ ├── graph-traversals │ │ ├── 2-sat.md │ │ ├── _index.md │ │ ├── bipartite.md │ │ ├── bridges.md │ │ ├── connectivity.md │ │ ├── cycle.md │ │ ├── dfs.md │ │ ├── dominators.md │ │ ├── euler-cycle.md │ │ ├── img │ │ │ ├── bridges.png │ │ │ ├── components.jpg │ │ │ ├── disconnected.png │ │ │ ├── euler-small.png │ │ │ ├── euler.png │ │ │ ├── graph.png │ │ │ ├── graphs.gif │ │ │ ├── russia.png │ │ │ ├── scc.png │ │ │ └── sorting.png │ │ ├── scc.md │ │ ├── storing-graphs.md │ │ └── topological-sorting.md │ ├── hashing │ │ ├── _index.md │ │ ├── collision.md │ │ ├── img │ │ │ ├── chess-game-tree.jpg │ │ │ ├── chess.png │ │ │ ├── hash-table.png │ │ │ └── sicilian.png │ │ ├── isomorphism.md │ │ ├── polynomial.md │ │ └── rope.md │ ├── heuristic │ │ ├── _index.md │ │ ├── bandits.md │ │ ├── genetic.md │ │ └── img │ │ │ ├── annealing.gif │ │ │ └── tsp.gif │ ├── interactive │ │ ├── _index.md │ │ ├── answer-search.md │ │ ├── binary-search.md │ │ ├── convex-functions.md │ │ ├── interactive.md │ │ ├── parallel-search.md │ │ └── ternary-search.md │ ├── layer-optimizations │ │ ├── _index.md │ │ ├── convex-hull-trick.md │ │ ├── divide-and-conquer.md │ │ ├── img │ │ │ └── scooby-doo.jpg │ │ ├── knuth.md │ │ └── lagrange.md │ ├── matching │ │ ├── _index.md │ │ ├── berge.md │ │ ├── hall.md │ │ ├── img │ │ │ ├── alternating.jpg │ │ │ ├── cubes.jpg │ │ │ ├── cubes.png │ │ │ ├── hall.gif │ │ │ └── matching.png │ │ ├── kuhn.md │ │ ├── matching-problems.md │ │ └── stable-marriage.md │ ├── modular │ │ ├── _index.md │ │ ├── discrete-log.md │ │ ├── discrete-root.md │ │ ├── euclid.md │ │ ├── extended-euclid.md │ │ ├── img │ │ │ ├── clock.gif │ │ │ └── euclidean.png │ │ ├── modulo-optimization.md │ │ ├── primitive-root.md │ │ └── reciprocal.md │ ├── numerical │ │ ├── _index.md │ │ ├── gradient-descent.md │ │ ├── img │ │ │ ├── monte-carlo.gif │ │ │ └── newton.png │ │ ├── monte-carlo.md │ │ └── newton.md │ ├── persistent │ │ ├── _index.md │ │ ├── img │ │ │ └── path-copy.png │ │ ├── path-copying.md │ │ ├── persistent-array.md │ │ ├── persistent-segtree.md │ │ └── persistent-treap.md │ ├── programming │ │ ├── _index.md │ │ ├── bayans.md │ │ ├── cpp.md │ │ ├── links.md │ │ ├── no-deallocation.md │ │ ├── optimizing-solutions.md │ │ ├── python.md │ │ └── stress-test.md │ ├── range-queries │ │ ├── 2d.md │ │ ├── _index.md │ │ ├── disjoint-sparse-table.md │ │ ├── fenwick.md │ │ ├── img │ │ │ ├── fenwick-ranges.png │ │ │ ├── prefix-sum.png │ │ │ └── sparse-table.png │ │ ├── prefix-sum.md │ │ ├── rmq.md │ │ ├── sparse-table.md │ │ ├── sqrt-structures.md │ │ └── veb.md │ ├── segment-tree │ │ ├── _index.md │ │ ├── array.md │ │ ├── bottom-up.md │ │ ├── img │ │ │ ├── segtree-example.jpg │ │ │ ├── segtree-example.png │ │ │ ├── segtree-ranges.png │ │ │ ├── segtree-ranges2.png │ │ │ └── segtree-ranges3.png │ │ ├── lazy-initialization.md │ │ ├── lazy-propagation.md │ │ ├── li-chao.md │ │ ├── mergesort-tree.md │ │ └── pointers.md │ ├── sequences │ │ ├── _index.md │ │ ├── compression.md │ │ ├── inversions.md │ │ ├── max-avg-segment.md │ │ ├── memory-bound.md │ │ └── quickselect.md │ ├── set-structures │ │ ├── _index.md │ │ ├── bitset.md │ │ ├── dsu.md │ │ ├── hash-table.md │ │ └── img │ │ │ ├── dsu.png │ │ │ └── path-compression.png │ ├── shortest-paths │ │ ├── _index.md │ │ ├── acyclic-paths.md │ │ ├── bfs.md │ │ ├── diameter.md │ │ ├── dijkstra.md │ │ ├── floyd.md │ │ ├── ford-bellman.md │ │ ├── img │ │ │ ├── ShortestPaths2015.ppt │ │ │ ├── bfs.svg │ │ │ ├── dijkstra-proof.png │ │ │ ├── dijkstra.gif │ │ │ ├── maze.gif │ │ │ ├── shortest-unweighted.png │ │ │ ├── shortest-unweighted.svg │ │ │ ├── shortest-weighted.png │ │ │ └── shortest-weighted.svg │ │ └── negative-cycle.md │ ├── sorting │ │ ├── _index.md │ │ ├── bubble.md │ │ ├── counting.md │ │ ├── distribution.md │ │ ├── heapsort.md │ │ ├── insertion.md │ │ ├── lower-bound.md │ │ ├── mergesort.md │ │ ├── quicksort.md │ │ ├── radix.md │ │ ├── selection.md │ │ ├── sorting-networks.md │ │ └── stability.md │ ├── spanning-trees │ │ ├── _index.md │ │ ├── boruvka.md │ │ ├── bridges-online.md │ │ ├── chinese.md │ │ ├── dcp.md │ │ ├── img │ │ │ └── safe-edge.png │ │ ├── kirchoff.md │ │ ├── kruskal.md │ │ ├── link-cut.md │ │ ├── prim.md │ │ ├── safe-edge.md │ │ └── spanning-trees-problems.md │ ├── string-searching │ │ ├── _index.md │ │ ├── manacher.md │ │ ├── prefix-function.md │ │ ├── tandem-repeats.md │ │ └── z-function.md │ ├── string-structures │ │ ├── _index.md │ │ ├── aho-corasick.md │ │ ├── automaton.md │ │ ├── img │ │ │ ├── lcp.png │ │ │ ├── life.gif │ │ │ ├── sa-sort.png │ │ │ └── trie.png │ │ ├── palindromic-tree.md │ │ ├── suffix-array.md │ │ ├── suffix-tree.md │ │ └── trie.md │ ├── tree-structures │ │ ├── _index.md │ │ ├── b-tree.md │ │ ├── img │ │ │ └── treap.png │ │ ├── implicit.md │ │ ├── pbds.md │ │ ├── red-black-tree.md │ │ ├── splay-tree.md │ │ ├── stl-trees.md │ │ └── treap.md │ └── trees │ │ ├── _index.md │ │ ├── binary-lifting.md │ │ ├── centroid.md │ │ ├── condensed.md │ │ ├── heavy-light.md │ │ ├── img │ │ ├── centroid.jpg │ │ ├── heavy-light.png │ │ ├── lca.png │ │ └── tour.png │ │ ├── lca-rmq.md │ │ ├── merging.md │ │ ├── tarjan.md │ │ ├── tree-dynamic.md │ │ └── tree-queries.md │ ├── dl │ ├── _index.md │ ├── advanced │ │ ├── _index.ru.md │ │ ├── distillation.ru.md │ │ ├── metric-learning.ru.md │ │ └── transfer-learning.ru.md │ ├── aux │ │ ├── 01-intro │ │ │ ├── _index.ru.md │ │ │ ├── notebook.ru.ipynb │ │ │ └── slides.ru.md │ │ └── _index.ru.md │ ├── cv │ │ ├── _index.ru.md │ │ ├── cnn.ru.md │ │ ├── processing.ru.md │ │ └── segmentation.ru.md │ ├── fundamentals │ │ ├── _index.ru.md │ │ ├── backprop.ru.md │ │ ├── gradient-descent │ │ │ └── _index.ru.md │ │ └── loss.ru.md │ ├── generative │ │ ├── _index.ru.md │ │ ├── autoencoder.ru.md │ │ ├── flow.ru.md │ │ ├── gan.ru.md │ │ └── vae.ru.md │ ├── layers │ │ ├── _index.ru.md │ │ ├── dropout.ru.md │ │ ├── linear.ru.md │ │ ├── relu.ru.md │ │ └── softmax.ru.md │ └── nlp │ │ ├── _index.ru.md │ │ ├── attention.ru.md │ │ ├── dialogue.ru.md │ │ ├── rnn.ru.md │ │ ├── seq2seq.ru.md │ │ └── tokenization.ru.md │ ├── math │ ├── _index.md │ ├── algebra │ │ ├── _index.ru.md │ │ ├── complex-numbers.ru.md │ │ ├── complex.md │ │ ├── linear-algebra │ │ │ ├── _index.ru.md │ │ │ └── linalg.ru.md │ │ ├── polynomials │ │ │ └── _index.ru.md │ │ ├── Операции_с_Матрицами.md │ │ └── Свойства_Матриц.md │ ├── calculus │ │ ├── _index.ru.md │ │ ├── derivative.ru.md │ │ └── integral.ru.md │ ├── combinatorics │ │ ├── _index.ru.md │ │ ├── bernside.ru.md │ │ ├── binomial.ru.md │ │ ├── catalan.ru.md │ │ ├── factorials │ │ │ ├── _index.ru.md │ │ │ ├── factorial-divisors.ru.md │ │ │ ├── factorial-modulo.ru.md │ │ │ └── factorial-number-system.ru.md │ │ ├── gray-code.ru.md │ │ ├── inclustion-exclusion.ru.md │ │ ├── Бином_Ньютона.md │ │ ├── Биномиальные_коэффициенты.md │ │ ├── ПСП.md │ │ └── Числа_Каталана.md │ ├── geometry │ │ ├── _index.ru.md │ │ └── Формула_Пика.md │ ├── number-theory │ │ ├── _index.ru.md │ │ ├── chinese-remainder-theorem.ru.md │ │ ├── euler.md │ │ ├── fibonacci.ru.md │ │ ├── little-fermat.md │ │ ├── stern-brocot.ru.md │ │ ├── Диофантово_уравнение.md │ │ ├── Китайская_теорема_об_остатках.md │ │ ├── Модульная_арифметика.md │ │ ├── Простое_число.md │ │ └── Теорема_Эйлера.md │ └── probability │ │ ├── _index.ru.md │ │ ├── bayes.ru.md │ │ ├── birthday-paradox.ru.md │ │ ├── distributions.ru.md │ │ ├── expectation.ru.md │ │ ├── limit-theorems │ │ └── _index.ru.md │ │ ├── markov-chains.ru.md │ │ ├── processes.ru.md │ │ ├── variance.ru.md │ │ ├── Вероятность.md │ │ ├── Матожидание.md │ │ ├── Парадокс_Монти-холла.md │ │ ├── Парадокс_дней_рождений.md │ │ ├── Случайная_величина.md │ │ └── Условная_вероятность.md │ └── ml │ ├── _index.md │ ├── data-wrangling │ ├── _index.ru.md │ ├── matplotlib.ru.md │ ├── numpy.ru.md │ └── pandas.ru.md │ ├── dimensionality-reduction │ ├── _index.md │ ├── img │ │ ├── pca-sample.png │ │ ├── pca.png │ │ └── tsne-sample.png │ ├── svd.md │ └── t-sne.md │ ├── ensemble │ ├── _index.md │ ├── bagging.md │ ├── boosting.md │ ├── decision-trees.md │ ├── img │ │ └── tree.jpg │ └── stacking.md │ ├── fundamentals │ ├── _index.md │ ├── img │ │ ├── poly16.png │ │ └── poly3.png │ └── overfitting.md │ ├── models │ ├── _index.md │ ├── linear-models │ │ ├── _index.md │ │ ├── img │ │ │ └── sigmoid.png │ │ ├── linear-regression.md │ │ └── logistic-regression.md │ └── polynomial.md │ ├── preprocessing │ ├── _index.md │ └── texts.md │ ├── problems │ ├── _index.md │ ├── classification.md │ ├── clustering.md │ ├── img │ │ ├── agglomerative.jpg │ │ ├── clustering.png │ │ ├── dbscan.png │ │ ├── errors.png │ │ └── k-means.png │ ├── metrics.md │ ├── ranking.md │ └── regression.md │ ├── ranking │ ├── _index.md │ ├── recsys.md │ └── search.md │ ├── rl │ ├── _index.ru.md │ ├── actor-critic.ru.md │ ├── bandits.ru.md │ └── reinforce.ru.md │ └── stats │ ├── _index.ru.md │ ├── ab-tests.ru.md │ └── maximum-likelihood.ru.md ├── netlify.toml ├── scripts ├── check-links.sh ├── list-files.sh └── stats.ipynb ├── static ├── favicon.ico └── img │ ├── binary-heap.svg │ ├── bst.png │ ├── bst.svg │ ├── chernobyl.jpg │ ├── complex-circle.png │ ├── fenwick_ranges.png │ ├── hash-table.png │ ├── heap-layout.svg │ ├── safe-edge.png │ ├── scooby-doo.jpg │ ├── sparse-table.png │ └── stasyan.jpg └── themes └── algorithmica ├── LICENSE ├── README.md ├── archetypes └── default.md ├── assets ├── dark.sass └── style.sass ├── i18n ├── en.toml └── ru.toml ├── layouts ├── 404.html ├── _default │ ├── _markup │ │ ├── render-codeblock-center.html │ │ ├── render-heading.html │ │ └── render-image.html │ ├── baseof.html │ ├── list.html │ ├── list.searchindex.json │ └── single.html ├── partials │ ├── analytics.html │ ├── breadcrumb.html │ ├── buttons.html │ ├── content.html │ ├── division.html │ ├── footer.html │ ├── head.html │ ├── header.html │ ├── katex.html │ ├── nextprev.html │ ├── search.html │ ├── section.html │ ├── sidebar.html │ └── toc.html └── shortcodes │ └── code.html ├── static ├── fonts │ ├── Crimson_Text.zip │ ├── Source_Sans_Pro.zip │ ├── cmu.woff2 │ ├── crimson.ttf │ ├── garamond.woff2 │ ├── georgia.woff2 │ ├── inconsolata.woff2 │ ├── linux-libertine.ttf │ ├── merriweather.woff2 │ ├── opensans.woff2 │ └── sourcesans.ttf ├── icons │ ├── adjust-solid.svg │ ├── bars-solid.svg │ ├── bug-solid.svg │ ├── clock-solid.svg │ ├── edit-solid.svg │ ├── github-brands.svg │ ├── history-solid.svg │ ├── language-solid.svg │ ├── moon-regular.svg │ ├── moon-solid.svg │ ├── print-solid.svg │ ├── search-solid.svg │ └── user-solid.svg ├── scripts │ ├── lunr.multi.min.js │ ├── lunr.ru.min.js │ └── lunr.stemmer.support.min.js ├── syntax-dark.css └── syntax.css └── theme.yaml /.gitignore: -------------------------------------------------------------------------------- 1 | public 2 | resources 3 | .vscode 4 | *.lock 5 | *.csv 6 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "themes/reveal-hugo"] 2 | path = themes/reveal-hugo 3 | url = https://github.com/dzello/reveal-hugo 4 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Algorithmica v3 2 | 3 | Algorithmica is an open-access web book dedicated to the art and science of computing. 4 | 5 | You can contribute via [Prose](https://prose.io/) by clicking on the pencil icon on the top right on any page or by editing its source directly on GitHub. We use a slightly different Markdown dialect, so if you are not sure that the change is correct (for example, editing an intricate LaTeX formula), you can install [Hugo](https://gohugo.io/) and build the site locally — or just create a pull request, and a preview link will be automatically generated for you. 6 | 7 | If you happen to speak Russian, please also read the [contributing guidelines](https://ru.algorithmica.org/contributing/). 8 | 9 | --- 10 | 11 | Key technical changes from the [previous version](https://github.com/algorithmica-org/articles): 12 | 13 | * pandoc -> Hugo 14 | * CSS -> Sass 15 | * Github Pages -> Netlify 16 | * Yandex.Metrica -> ~~Google Analytics~~ went back to Metrica 17 | * algorithmica.org/{lang}/* -> {lang}.algorithmica.org/* 18 | * Rich metadata support (language, sections, TOCs, authors...) 19 | * Automated global table of contents 20 | * Theming support 21 | * Search support (Lunr) 22 | 23 | Short-term todo list: 24 | 25 | * Style adjustments for mobile and print versions 26 | * A pdf version of the whole website 27 | * Meta-information support (for Google Scholar and social media) 28 | * [Sticky table of contents](https://css-tricks.com/table-of-contents-with-intersectionobserver/) 29 | -------------------------------------------------------------------------------- /assets/slides.sass: -------------------------------------------------------------------------------- 1 | $font-text: 'Source Sans', serif !default 2 | $font-code: 'Inconsolata', monospace !default 3 | $font-headings: 'Garamond', serif !default 4 | 5 | $borders: 1px solid #eaecef !default 6 | 7 | /* fonts */ 8 | @font-face 9 | font-family: 'CMU' 10 | src: url(fonts/cmu.woff2) 11 | 12 | @font-face 13 | font-family: 'Merriweather' 14 | src: url(fonts/merriweather.woff2) 15 | 16 | @font-face 17 | font-family: 'Inconsolata' 18 | src: url(fonts/inconsolata.woff2) 19 | 20 | @font-face 21 | font-family: 'Garamond' 22 | src: url(fonts/garamond.woff2) 23 | 24 | @font-face 25 | font-family: "Open Sans" 26 | src: url(fonts/opensans.woff2) 27 | 28 | @font-face 29 | font-family: "Source Sans" 30 | src: url(fonts/sourcesans.ttf) 31 | 32 | @font-face 33 | font-family: "Crimson" 34 | src: url(fonts/crimson.ttf) 35 | 36 | body 37 | font-family: $font-text 38 | font-size: 24px 39 | 40 | h1 41 | font-size: 2em 42 | text-align: center 43 | margin-top: 0 44 | margin-bottom: 20px 45 | 46 | h2 47 | font-size: 1.5em 48 | 49 | h3 50 | font-size: 1.25em 51 | -------------------------------------------------------------------------------- /config.yaml: -------------------------------------------------------------------------------- 1 | baseURL: "https://ru.algorithmica.org/" 2 | theme: 3 | - algorithmica 4 | - reveal-hugo 5 | pygmentsUseClasses: true 6 | outputFormats: 7 | Reveal: 8 | baseName: index 9 | mediaType: text/html 10 | isHTML: true 11 | SearchIndex: 12 | mediaType: "application/json" 13 | baseName: "searchindex" 14 | isPlainText: true 15 | notAlternative: true 16 | outputs: 17 | home: 18 | - HTML 19 | - SearchIndex 20 | markup: 21 | goldmark: 22 | footnote: false # katex conflict 23 | renderer: 24 | unsafe: true 25 | defaultContentLanguage: en 26 | sectionPagesMenu: main 27 | languages: 28 | en: 29 | title: Algorithmica 30 | baseURL: https://en.algorithmica.org 31 | contentDir: content/english 32 | languageName: English 33 | languageCode: "en-us" 34 | weight: 1 35 | ru: 36 | title: Алгоритмика 37 | baseURL: https://ru.algorithmica.org 38 | contentDir: content/russian 39 | languageName: Русский 40 | languageCode: "ru-ru" 41 | weight: 2 42 | params: 43 | repo: "https://github.com/algorithmica-org/algorithmica" 44 | reveal_hugo: 45 | #theme: white 46 | slide_number: true 47 | transition: none 48 | custom_theme: "slides.sass" 49 | custom_theme_compile: true 50 | -------------------------------------------------------------------------------- /content/english/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Algorithmica 3 | hideSidebar: true 4 | noToc: true 5 | --- 6 | 7 | Algorithmica is an open-access web book dedicated to the art and science of computing. 8 | 9 | It is created by [Sergey Slotin](http://sereja.me/) and the teachers and students of [Tinkoff Generation](https://fintech.tinkoff.ru/study/generation/) — a nonprofit educational organization that trains about half of the finalists of the Russian Olympiad in Informatics. 10 | 11 | The English version of the website is a work in progress; the only useful thing you can find here is the continuously updated draft of [Algorithms for Modern Hardware](hpc). We are currently more focused on [the Russian version](https://ru.algorithmica.org/), which hosts various course materials that we use ourselves. 12 | 13 | If you spot an error, please create an issue on [GitHub](https://github.com/algorithmica-org/algorithmica) or, preferably, fix it right away (the pencil icon on the top-right). 14 | -------------------------------------------------------------------------------- /content/english/hpc/algorithms/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Algorithms Case Studies 3 | weight: 11 4 | --- 5 | 6 | When you try to explain a complex concept, it is generally a good idea to give a very simple and minimal example illustrating it. This is why in this book you see about a dozen different ways of calculating the sum of an array, each highlighting a certain CPU feature. 7 | 8 | But the main purpose of this book is not to learn computer architecture just for the sake of learning it, but to acquire real-world skills in software optimization. The next two chapters exist to help you achieve this goal, as they contain detailed case studies of various algorithms that are much harder to optimize than the sum of an array. 9 | 10 | 21 | -------------------------------------------------------------------------------- /content/english/hpc/algorithms/img/column-major.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/algorithms/img/column-major.jpg -------------------------------------------------------------------------------- /content/english/hpc/algorithms/img/gcd-dependency1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/algorithms/img/gcd-dependency1.png -------------------------------------------------------------------------------- /content/english/hpc/algorithms/img/gcd-dependency2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/algorithms/img/gcd-dependency2.png -------------------------------------------------------------------------------- /content/english/hpc/algorithms/img/prefix-outline.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/algorithms/img/prefix-outline.png -------------------------------------------------------------------------------- /content/english/hpc/algorithms/img/rho.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/algorithms/img/rho.jpg -------------------------------------------------------------------------------- /content/english/hpc/algorithms/reading-integers.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Reading Decimal Integers 3 | weight: 10 4 | draft: true 5 | --- 6 | 7 | I wrote a new integer parsing algorithm that is ~35x faster than scanf. 8 | 9 | (No, this is not an April Fools' joke — although it does sound ridiculous.) 10 | 11 | Zen 2 @ 2GHz. The compiler is Clang 13. 12 | 13 | Ridiculous. 14 | 15 | ### Iostream 16 | 17 | ### Scanf 18 | 19 | ### Syncronization 20 | 21 | ### Getchar 22 | 23 | ### Buffering 24 | 25 | ### SIMD 26 | 27 | http://0x80.pl/notesen/2014-10-12-parsing-decimal-numbers-part-1-swar.html 28 | 29 | 30 | ### Serial 31 | 32 | ### Transpose-based approach 33 | 34 | ### Instruction-level parallelism 35 | 36 | 37 | ### Modifications 38 | 39 | ILP benefits would not be that huge. 40 | 41 | One huge asterisk. We get the integers, and we can even do other parsing algorithms on them. 42 | 43 | 1.75 cycles per byte. 44 | 45 | AVX-512 both due to larger SIMD lane size and dedicated operations for filtering. 46 | 47 | It accounts for ~2% of all time, but it can be optimized by using special procedures. Pad buffer with any digits. 48 | 49 | ### Future work 50 | 51 | Next time, we will be *writing* integers. 52 | 53 | You can create a string searcing algorithm by computing hashes in rabin-karp algorithm — although it does not seem to be possible to make an *exact* algorithm for that. 54 | 55 | ## Acknowledgements 56 | 57 | http://0x80.pl/articles/simd-parsing-int-sequences.html 58 | 59 | https://stackoverflow.com/questions/25622745/transpose-an-8x8-float-using-avx-avx2/25627536#25627536 60 | -------------------------------------------------------------------------------- /content/english/hpc/algorithms/sorting.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Sorting 3 | weight: 6 4 | draft: true 5 | --- 6 | -------------------------------------------------------------------------------- /content/english/hpc/architecture/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Computer Architecture 3 | aliases: [/hpc/analyzing-performance/assembly] 4 | weight: 2 5 | --- 6 | 7 | When I began learning how to optimize programs myself, one big mistake I made was to rely primarily on the empirical approach. Not understanding how computers really worked, I would semi-randomly swap nested loops, rearrange arithmetic, combine branch conditions, inline functions by hand, and follow all sorts of other performance tips I've heard from other people, blindly hoping for improvement. 8 | 9 | Unfortunately, this is how most programmers approach optimization. Most texts about performance do not teach you to reason about software performance qualitatively. Instead they give you general advice about certain implementation approaches — and general performance intuition is clearly not enough. 10 | 11 | It would have probably saved me dozens, if not hundreds of hours if I learned computer architecture *before* doing algorithmic programming. So, even if most people aren't *excited* about it, we are going to spend the first few chapters studying how CPUs work and start with learning assembly. 12 | -------------------------------------------------------------------------------- /content/english/hpc/architecture/img/birthday.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/architecture/img/birthday.png -------------------------------------------------------------------------------- /content/english/hpc/architecture/img/clt.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/architecture/img/clt.png -------------------------------------------------------------------------------- /content/english/hpc/architecture/img/monte-carlo.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/architecture/img/monte-carlo.gif -------------------------------------------------------------------------------- /content/english/hpc/architecture/img/pdf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/architecture/img/pdf.png -------------------------------------------------------------------------------- /content/english/hpc/architecture/interaction.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Interrupts and System Calls 3 | weight: 9 4 | draft: true 5 | --- 6 | 7 | ```asm 8 | global _start 9 | 10 | section .text 11 | 12 | _start: 13 | mov rax, 1 ; write( 14 | mov rdi, 1 ; STDOUT_FILENO, 15 | mov rsi, msg ; "Hello, world!\n", 16 | mov rdx, msglen ; sizeof("Hello, world!\n") 17 | syscall ; ); 18 | 19 | mov rax, 60 ; exit( 20 | mov rdi, 0 ; EXIT_SUCCESS 21 | syscall ; ); 22 | 23 | section .rodata 24 | msg: db "Hello, world!", 10 25 | msglen: equ $ - msg 26 | ``` 27 | 28 | Interrupts are costly. They are not supposed to be on the normal execution path. Exceptions. 29 | 30 | There is some overhead associated with doing system calls, so they are usually avoided. For example, all I/O is usually buffered, so that you send a single, say, 4KB piece of data to the OS. 31 | -------------------------------------------------------------------------------- /content/english/hpc/arithmetic/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Arithmetic 3 | weight: 6 4 | published: true 5 | --- 6 | 7 | As we repeatedly demonstrate throughout this book, knowing darker corners of the instruction set can be very fruitful, especially in the case of [CISC](/hpc/architecture/isa) platforms like x86, which currently has [somewhere between 1000 and 4000](https://stefanheule.com/blog/how-many-x86-64-instructions-are-there-anyway/) distinct instructions, depending on how you count. 8 | 9 | Most of these instructions are related to arithmetic, and using them all efficiently to optimize arithmetic operations requires a great deal of both knowledge, skill, and creativity. Therefore, in this chapter, we will discuss number representations and their use in numerical algorithms. 10 | 11 | 18 | -------------------------------------------------------------------------------- /content/english/hpc/arithmetic/compression.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Data Compression 3 | weight: 8 4 | draft: true 5 | --- 6 | 7 | ... 8 | -------------------------------------------------------------------------------- /content/english/hpc/arithmetic/img/aes.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/arithmetic/img/aes.png -------------------------------------------------------------------------------- /content/english/hpc/arithmetic/img/clock.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/arithmetic/img/clock.gif -------------------------------------------------------------------------------- /content/english/hpc/arithmetic/img/complex-circle.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/arithmetic/img/complex-circle.png -------------------------------------------------------------------------------- /content/english/hpc/arithmetic/img/complex-plane.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/arithmetic/img/complex-plane.png -------------------------------------------------------------------------------- /content/english/hpc/arithmetic/img/iq.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/arithmetic/img/iq.jpg -------------------------------------------------------------------------------- /content/english/hpc/arithmetic/img/mnist.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/arithmetic/img/mnist.png -------------------------------------------------------------------------------- /content/english/hpc/arithmetic/img/newton.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/arithmetic/img/newton.png -------------------------------------------------------------------------------- /content/english/hpc/arithmetic/img/permutation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/arithmetic/img/permutation.png -------------------------------------------------------------------------------- /content/english/hpc/arithmetic/img/roots.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/arithmetic/img/roots.png -------------------------------------------------------------------------------- /content/english/hpc/compilation/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Compilation 3 | aliases: [/hpc/analyzing-performance/compilation] 4 | weight: 4 5 | --- 6 | 7 | The main benefit of [learning assembly language](../architecture/assembly) is not the ability to write programs in it, but the understanding of what is happening during the execution of compiled code and its performance implications. 8 | 9 | There are rare cases where we *really* need to switch to handwritten assembly for maximal performance, but most of the time compilers are capable of producing near-optimal code all by themselves. When they do not, it is usually because the programmer knows more about the problem than what can be inferred from the source code but failed to communicate this extra information to the compiler. 10 | 11 | In this chapter, we will discuss the intricacies of getting the compiler to do exactly what we want and gathering useful information that can guide further optimizations. 12 | -------------------------------------------------------------------------------- /content/english/hpc/compilation/arithmetic.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Arithmetic Optimizations 3 | weight: 10 4 | draft: true 5 | --- 6 | 7 | ... 8 | -------------------------------------------------------------------------------- /content/english/hpc/complexity/img/bug.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/complexity/img/bug.jpg -------------------------------------------------------------------------------- /content/english/hpc/complexity/img/complexity.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/complexity/img/complexity.jpg -------------------------------------------------------------------------------- /content/english/hpc/complexity/img/cpu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/complexity/img/cpu.png -------------------------------------------------------------------------------- /content/english/hpc/complexity/img/dennard.ppm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/complexity/img/dennard.ppm -------------------------------------------------------------------------------- /content/english/hpc/complexity/img/die-shot.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/complexity/img/die-shot.jpg -------------------------------------------------------------------------------- /content/english/hpc/complexity/img/lithography.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/complexity/img/lithography.png -------------------------------------------------------------------------------- /content/english/hpc/complexity/img/mos-6502.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/complexity/img/mos-6502.jpg -------------------------------------------------------------------------------- /content/english/hpc/cpu-cache/img/address.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/cpu-cache/img/address.png -------------------------------------------------------------------------------- /content/english/hpc/cpu-cache/img/cache1-full.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/cpu-cache/img/cache1-full.png -------------------------------------------------------------------------------- /content/english/hpc/cpu-cache/img/cache1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/cpu-cache/img/cache1.png -------------------------------------------------------------------------------- /content/english/hpc/cpu-cache/img/cache2-full.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/cpu-cache/img/cache2-full.png -------------------------------------------------------------------------------- /content/english/hpc/cpu-cache/img/cache2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/cpu-cache/img/cache2.png -------------------------------------------------------------------------------- /content/english/hpc/cpu-cache/img/cache3-full.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/cpu-cache/img/cache3-full.png -------------------------------------------------------------------------------- /content/english/hpc/cpu-cache/img/cache3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/cpu-cache/img/cache3.png -------------------------------------------------------------------------------- /content/english/hpc/cpu-cache/img/lstopo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/cpu-cache/img/lstopo.png -------------------------------------------------------------------------------- /content/english/hpc/cpu-cache/img/ram.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/cpu-cache/img/ram.png -------------------------------------------------------------------------------- /content/english/hpc/data-structures/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Data Structures Case Studies 3 | weight: 12 4 | --- 5 | 6 | Optimizing data structures is different from optimizing [algorithms](/hpc/algorithms) as data structure problems have more dimensions: you may be optimizing for *throughput*, for *latency*, for *memory usage*, or any combination of those — and this complexity blows up exponentially when you need to process *multiple* query types and consider multiple query distributions. 7 | 8 | This makes simply [defining benchmarks](/hpc/profiling/noise/) much harder, let alone the actual implementations. In this chapter, we will try to navigate all this complexity and learn how to design efficient data structures with extensive case studies. 9 | 10 | A brief review of the [CPU cache system](/hpc/cpu-cache) is strongly advised. 11 | -------------------------------------------------------------------------------- /content/english/hpc/data-structures/bitset.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Bitmaps 3 | draft: true 4 | weight: 6 5 | --- 6 | 7 | -------------------------------------------------------------------------------- /content/english/hpc/data-structures/filters.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Probabilistic Filters 3 | weight: 10 4 | draft: true 5 | --- 6 | 7 | bloom filters have the inverse behavior of caches* 8 | - bloom filter: miss == definitely not present, hit == probably present 9 | - cache: miss == probably not present, hit == definitely present 10 | -------------------------------------------------------------------------------- /content/english/hpc/data-structures/hash-tables.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Hash Tables 3 | weight: 8 4 | draft: true 5 | --- 6 | 7 | 8 | ## Hash Tables 9 | 10 | ![](https://upload.wikimedia.org/wikipedia/commons/thumb/7/7d/Hash_table_3_1_1_0_1_0_0_SP.svg/2560px-Hash_table_3_1_1_0_1_0_0_SP.svg.png =500x) 11 | 12 | ---- 13 | 14 | ### Chaining 15 | 16 | ![](https://upload.wikimedia.org/wikipedia/commons/d/d0/Hash_table_5_0_1_1_1_1_1_LL.svg =500x) 17 | 18 | A lot of linked lists or growable arrays 19 | 20 | ---- 21 | 22 | ### Open Addressing 23 | 24 | ![](https://upload.wikimedia.org/wikipedia/commons/b/bf/Hash_table_5_0_1_1_1_1_0_SP.svg =500x) 25 | 26 | Fixed number of cells and a hash function $f_i(x)$ that decides where to look on $i$-th step 27 | 28 | ---- 29 | 30 | Implementation with a cyclic array: 31 | 32 | ```cpp 33 | struct hashmap { 34 | const int size = (1<<24); 35 | int a[size] = {-1}, b[size]; 36 | 37 | static inline int h(int x) { return (x^179)*7; } 38 | 39 | void add(int x, int y) { 40 | int k = h(x) % size; 41 | while (a[k] != -1 && a[k] != x) 42 | k = (k + 1) % size; 43 | a[k] = x, b[k] = y; 44 | } 45 | 46 | int get(int x) { 47 | for (int k = h(x) % size; a[k] != -1; k = (k + 1) % size) 48 | if (a[k] == x) 49 | return b[k]; 50 | return -1; 51 | } 52 | }; 53 | ``` 54 | 55 | Same asymptotic complexity, but 2-3x difference in real speed 56 | 57 | ---- 58 | 59 | ![](https://upload.wikimedia.org/wikipedia/commons/1/1c/Hash_table_average_insertion_time.png =500x) 60 | 61 | The only downside is that you need to rehash it more often 62 | -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/b-tree.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/b-tree.jpg -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/b-tree.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/b-tree.png -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/binary-heat.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/binary-heat.png -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/binary-search.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/binary-search.png -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/bplus.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/bplus.png -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/eytzinger-heat.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/eytzinger-heat.png -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/eytzinger-search.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/eytzinger-search.png -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/eytzinger.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/eytzinger.png -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/eytzinger_old.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/eytzinger_old.png -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/fenwick-sum.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/fenwick-sum.png -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/fenwick-update.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/fenwick-update.png -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/segtree-layout.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/segtree-layout.png -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/segtree-path.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/segtree-path.png -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/segtree-permuted.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/segtree-permuted.png -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/segtree-succinct.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/segtree-succinct.png -------------------------------------------------------------------------------- /content/english/hpc/data-structures/img/segtree-wide.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/data-structures/img/segtree-wide.png -------------------------------------------------------------------------------- /content/english/hpc/distributed/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Distributed Computing 3 | weight: 200 4 | part: Distributed Computing 5 | draft: true 6 | --- 7 | -------------------------------------------------------------------------------- /content/english/hpc/distributed/actor.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Actor Model 3 | weight: 4 4 | --- 5 | -------------------------------------------------------------------------------- /content/english/hpc/distributed/algorithms/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Distributed Algorithms 3 | weight: 2 4 | --- 5 | -------------------------------------------------------------------------------- /content/english/hpc/distributed/cloud.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Cloud Computing 3 | weight: 5 4 | --- 5 | -------------------------------------------------------------------------------- /content/english/hpc/distributed/mapreduce/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: MapReduce 3 | weight: 3 4 | --- 5 | -------------------------------------------------------------------------------- /content/english/hpc/distributed/mpi/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Message Passing Interface 3 | weight: 1 4 | --- 5 | -------------------------------------------------------------------------------- /content/english/hpc/external-memory/img/hierarchy.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/external-memory/img/hierarchy.png -------------------------------------------------------------------------------- /content/english/hpc/external-memory/img/k-way.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/external-memory/img/k-way.png -------------------------------------------------------------------------------- /content/english/hpc/external-memory/img/list-ranking.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/external-memory/img/list-ranking.png -------------------------------------------------------------------------------- /content/english/hpc/external-memory/img/memory-vs-compute.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/external-memory/img/memory-vs-compute.png -------------------------------------------------------------------------------- /content/english/hpc/external-memory/img/mergesort.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/external-memory/img/mergesort.png -------------------------------------------------------------------------------- /content/english/hpc/external-memory/img/opt.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/external-memory/img/opt.png -------------------------------------------------------------------------------- /content/english/hpc/external-memory/img/sparse-table.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/external-memory/img/sparse-table.png -------------------------------------------------------------------------------- /content/english/hpc/external-memory/img/virtual-memory.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/external-memory/img/virtual-memory.jpg -------------------------------------------------------------------------------- /content/english/hpc/external-memory/management.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Memory Management 3 | weight: 99 4 | draft: true 5 | --- 6 | -------------------------------------------------------------------------------- /content/english/hpc/external-memory/sublinear.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Sublinear Algorithms 3 | weight: 10 4 | draft: true 5 | --- 6 | 7 | Sketching 8 | -------------------------------------------------------------------------------- /content/english/hpc/number-theory/error-correction.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Error Correction 3 | weight: 6 4 | draft: true 5 | --- 6 | 7 | ... 8 | -------------------------------------------------------------------------------- /content/english/hpc/number-theory/img/clock.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/number-theory/img/clock.gif -------------------------------------------------------------------------------- /content/english/hpc/number-theory/rng.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Random Number Generation 3 | weight: 7 4 | draft: true 5 | --- 6 | 7 | We can use iterated hash function for what it's worth. 8 | 9 | Linear congruent generator 10 | period of LCG 11 | 12 | -------------------------------------------------------------------------------- /content/english/hpc/parallel/algorithms/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Paralell Algorithms 3 | weight: 4 4 | --- 5 | -------------------------------------------------------------------------------- /content/english/hpc/parallel/algorithms/openmp.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: OpenMP 3 | --- 4 | -------------------------------------------------------------------------------- /content/english/hpc/parallel/concurrency/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Concurrency 3 | weight: 1 4 | --- 5 | 6 | Concurrency is the ability of different parts of a program to execute out-of-order (or possibly in parallel), without affecting the result. 7 | 8 | Concurrency is everywhere. You may listen to music while reading this book. Two programs manage, even if they work on the same core. 9 | 10 | Multi-threaded programming. Much harder than normal one. Different langauges solve this problem differently. In this section we will go through the main approaches. 11 | -------------------------------------------------------------------------------- /content/english/hpc/parallel/concurrency/event-driven.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Event-driven Concurrency 3 | weight: 4 4 | --- 5 | 6 | You might have seen it in JavaScript. Such languages have event loop that constantly. They also use a single thread, because every blocking operation is mostly I/O. 7 | 8 | ```js 9 | var callback = function() { 10 | console.log("Button clicked") 11 | } 12 | 13 | document.getElementById('someButton').addEventListener("click", callback) 14 | ``` 15 | 16 | Event-driven environments are usually single-threaded and achieve multi-threading by "sharding" requests. 17 | 18 | ## Actor Model 19 | 20 | A more generalized approach is called the *actor model*. 21 | 22 | It is very popular in the JVM world. 23 | 24 | ```scala 25 | import akka.actor.Actor 26 | import akka.actor.ActorSystem 27 | import akka.actor.Props 28 | 29 | class HelloActor extends Actor { 30 | def receive = { 31 | case "hello" => println("hello back at you") 32 | case _ => println("huh?") 33 | } 34 | } 35 | 36 | object Main extends App { 37 | val system = ActorSystem("HelloSystem") 38 | // default Actor constructor 39 | val helloActor = system.actorOf(Props[HelloActor], name = "helloactor") 40 | helloActor ! "hello" 41 | helloActor ! "buenos dias" 42 | } 43 | ``` 44 | 45 | One very important advantage of using message brokers is that you can decouple communication and also move actors to another network node, enabling distributed computing. 46 | -------------------------------------------------------------------------------- /content/english/hpc/parallel/concurrency/fibers.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Fibers 3 | weight: 3 4 | --- 5 | 6 | *Fibers* are lightweight threads implemented in languages itself. The way they work is they pick up. The language thus has to maintain its own runtime. 7 | 8 | ```go 9 | package main 10 | 11 | import ( 12 | "fmt" 13 | "time" 14 | ) 15 | 16 | func say(s string) { 17 | for i := 0; i < 5; i++ { 18 | time.Sleep(100 * time.Millisecond) 19 | fmt.Println(s) 20 | } 21 | } 22 | 23 | func main() { 24 | go say("world") 25 | say("hello") 26 | } 27 | ``` 28 | 29 | The way they work is that the language maintains a group of threads ready to pick up from where they left. This is called N:M scheduling. 30 | 31 | Similar runtimes exist for other languages, e.g., for C++ and Rust. 32 | -------------------------------------------------------------------------------- /content/english/hpc/parallel/concurrency/processes.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Processes 3 | weight: 1 4 | --- 5 | 6 | It works well when you need. 7 | 8 | Fork system call is used for creating a new process, which is called child process, which runs concurrently with the process that makes the fork() call (parent process). After a new child process is created, both processes will execute the next instruction following the fork() system call. A child process uses the same pc(program counter), same CPU registers, same open files which use in the parent process. 9 | 10 | It takes no parameters and returns an integer value. Below are different values returned by fork(). 11 | 12 | ```cpp 13 | #include 14 | #include 15 | #include 16 | int main() { 17 | // make two process which run same 18 | // program after this instruction 19 | fork(); 20 | 21 | printf("Hello world!\n"); 22 | return 0; 23 | } 24 | ``` 25 | 26 | Major disadvantage is the extra cost. It is managed by the operating system. Separate processes are used when you need such granularity. 27 | 28 | Forked processes can neither see nor alter the memory space of each other. 29 | -------------------------------------------------------------------------------- /content/english/hpc/parallel/gpu/cuda.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: CUDA 3 | --- 4 | -------------------------------------------------------------------------------- /content/english/hpc/parallel/img/moores-law.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/parallel/img/moores-law.jpg -------------------------------------------------------------------------------- /content/english/hpc/parallel/runtimes.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Threading Runtimes 3 | weight: 6 4 | draft: true 5 | --- 6 | -------------------------------------------------------------------------------- /content/english/hpc/parallel/synchronization/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Synchronization Primitives 3 | weight: 2 4 | --- 5 | 6 | Consider the following loop: 7 | 8 | ```cpp 9 | int s = 0; 10 | 11 | for (int i = 0; i < n; i++) { 12 | s += a[i]; 13 | } 14 | ``` 15 | 16 | We can make it parallel like this: 17 | 18 | ```cpp 19 | int s = 0; 20 | 21 | #pragma omp parallel for 22 | for (int i = 0; i < n; i++) { 23 | s += a[i]; 24 | } 25 | ``` 26 | 27 | This snippet uses OpenMP, which will be covered in the next chapter. What you need to know about it for now is that it spawns a number of threads and distributes work evenly between them. You can write an equivalent function with threads in C++. 28 | 29 | The problem 30 | -------------------------------------------------------------------------------- /content/english/hpc/parallel/synchronization/mutex.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Mutual Exclusion 3 | weight: 1 4 | --- 5 | -------------------------------------------------------------------------------- /content/english/hpc/pipelining/img/bubble.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/pipelining/img/bubble.png -------------------------------------------------------------------------------- /content/english/hpc/pipelining/img/pipeline.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/pipelining/img/pipeline.png -------------------------------------------------------------------------------- /content/english/hpc/pipelining/img/superscalar.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/pipelining/img/superscalar.png -------------------------------------------------------------------------------- /content/english/hpc/simd/img/gather-scatter.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/simd/img/gather-scatter.png -------------------------------------------------------------------------------- /content/english/hpc/simd/img/hsum.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/simd/img/hsum.png -------------------------------------------------------------------------------- /content/english/hpc/simd/img/intel-extensions.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/simd/img/intel-extensions.webp -------------------------------------------------------------------------------- /content/english/hpc/simd/img/simd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/english/hpc/simd/img/simd.png -------------------------------------------------------------------------------- /content/english/hpc/slides/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Slides 3 | ignoreIndexing: true 4 | weight: 1000 5 | draft: true 6 | --- 7 | 8 | This is an attempt to make a university course out of the book. 9 | 10 | Work in progress. 11 | -------------------------------------------------------------------------------- /content/english/hpc/summary.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Summary 3 | weight: 99 4 | ignoreIndexing: true 5 | draft: true 6 | --- 7 | 8 | Now we have enough information to summarize what we've learned. 9 | 10 | Loop unrolling. 11 | 12 | Here is a checklist (from easiest to hardest): 13 | 14 | 0. Turn on optimization (`-march=native`, `-O3`, `-ffast-math`, `-funroll-loops`) 15 | 1. Determine whether the algorithm is memory-bound or compute-bound. 16 | 2. Blocking: try to split data in parts that fit cache 17 | 3. Memory access patterns: try to linearize every reads 18 | 4. Prefetching: if access pattern is not well predictable, or port is free, add a prefetching step 19 | 5. Branching: remove branching 20 | 6. Loop Unrolling: `#pragma GCC unroll n` 21 | 7. Data Dependencies: consult and instruction table or llvm-mca 22 | 8. SIMD: simplify a loop 23 | 9. Arithmetic: use smallest type available and turn on `-ffast-math` 24 | 10. Temporal locality 25 | 11. Allocations 26 | 12. Profile stuff -------------------------------------------------------------------------------- /content/russian/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Алгоритмика 3 | hideSidebar: true 4 | --- 5 | 6 | На этом сайте находятся материалы различных CS-курсов, проводящихся в [Tinkoff Generation](https://fintech.tinkoff.ru/study/generation/). 7 | 8 | Проект открытый, живёт на [гитхабе](https://github.com/algorithmica-org/algorithmica). Помощь в [подготовке статей](contributing), исправление ошибок и любая другая обратная связь очень приветствуется. Разрабатывает и поддерживает [Сергей Слотин](http://sereja.me/). 9 | -------------------------------------------------------------------------------- /content/russian/cs/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Алгоритмы 3 | menuTitle: CS 4 | weight: 1 5 | hideSidebar: true 6 | --- 7 | 8 | В этот раздел с течением времени будут переноситься статьи с [алгокода](http://wiki.algocode.ru/), [емакса](http://e-maxx.ru/algo/) и [старой алгоритмики](https://algorithmica.org/ru/). 9 | -------------------------------------------------------------------------------- /content/russian/cs/algebra/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Алгебра 3 | weight: 17 4 | part: Математика 5 | --- 6 | 7 | В этой главе мы рассмотрим основные алгоритмы вычислительной алгебры. 8 | 9 | Рекомендуется математическая подготовка на уровне младших курсов технических вузов. 10 | -------------------------------------------------------------------------------- /content/russian/cs/algebra/img/convolution.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/algebra/img/convolution.gif -------------------------------------------------------------------------------- /content/russian/cs/algebra/img/dogs.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/algebra/img/dogs.jpg -------------------------------------------------------------------------------- /content/russian/cs/algebra/img/extrapolation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/algebra/img/extrapolation.png -------------------------------------------------------------------------------- /content/russian/cs/algebra/img/fft-shuffle.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/algebra/img/fft-shuffle.png -------------------------------------------------------------------------------- /content/russian/cs/algebra/img/lagrange.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/algebra/img/lagrange.gif -------------------------------------------------------------------------------- /content/russian/cs/algebra/img/linear.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/algebra/img/linear.png -------------------------------------------------------------------------------- /content/russian/cs/algebra/img/matmul.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/algebra/img/matmul.png -------------------------------------------------------------------------------- /content/russian/cs/algebra/img/roots-unity.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/algebra/img/roots-unity.png -------------------------------------------------------------------------------- /content/russian/cs/arithmetic/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Арифметика 3 | weight: 6 4 | --- 5 | 6 | В этой главе мы обсудим представление чисел в памяти и операции с ними. 7 | -------------------------------------------------------------------------------- /content/russian/cs/arithmetic/floating-point.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Вещественные числа 3 | authors: 4 | - Сергей Слотин 5 | date: 2021-08-21 6 | weight: 2 7 | draft: true 8 | --- 9 | 10 | 11 | $$ 12 | 1.2345 = 13 | \underbrace{12345}\_\text{mantissa} 14 | \times {\underbrace{10}\_\text{base}\\!\\!\\!\\!} 15 | ^{\overbrace{-4}^\text{exponent}} 16 | $$ 17 | 18 | 19 | $$ 20 | 42 = 10101_2 = 1.0101_2 \times 2^5 21 | $$ 22 | 23 | > Первое правило вещественных чисел — не использовать вещественные числа 24 | 25 | Все переменные типа `double` хранятся в компьютере неточно (ну а как вы представите ⅓ в двоичной системе счисления?). Поэтому при работе с даблами нужно **всегда** учитывать эту погрешность. Например, чтобы сравнить два дабла, надо проверить, что они отличаются по модулю меньше, чем на очень маленькое число `eps`: 26 | 27 | ```c++ 28 | const double eps = 1e-8; 29 | 30 | bool eq (double a, double b) { return abs(a-b) < eps } 31 | ``` 32 | 33 | Чтобы так не делать, старайтесь по возможности использовать только инты и абсолютную точность. Иногда есть трюки, позволяющие так делать: например, если в задаче все входные точки целочисленные и нас просят посчитать какую-то площадь, то можно все координаты домножить на два, и тогда ответ тоже будет целым (см. векторное произведение), который только при выводе нужно будет поделить на четыре. 34 | 35 | ### $0 \neq -0$ 36 | 37 | Действительные числа так хранятся, что $0$ и $-0$ могут быть разными числами. Имейте это ввиду. 38 | 39 | ### Область определения обратных функций 40 | 41 | `acos`, `asin` и прочие обратные тригонометрические функций требуют, чтобы им на вход подавалось число от -1 до 1. Для безопасности, отмасштабируйте числа, перед тем как брать от них эти функции. 42 | -------------------------------------------------------------------------------- /content/russian/cs/arithmetic/img/intel-isa.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/arithmetic/img/intel-isa.png -------------------------------------------------------------------------------- /content/russian/cs/arithmetic/img/simd-vs-scalar.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/arithmetic/img/simd-vs-scalar.gif -------------------------------------------------------------------------------- /content/russian/cs/arithmetic/img/simd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/arithmetic/img/simd.png -------------------------------------------------------------------------------- /content/russian/cs/basic-structures/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Базовые структуры данных 3 | part: Структуры данных 4 | authors: 5 | - Сергей Слотин 6 | - Даниил Николенко 7 | prerequisites: 8 | - ../complexity/amortized 9 | weight: 7 10 | --- 11 | 12 | *Структуры данных* — это форматы эффективного хранения и обработки логически связанных данных. 13 | 14 | *Реализации* структур данных состоят из конкретного способа хранения данных в памяти и логики, реализующей *интерфейс*. Когда детали реализации не важны, говорят об *абстрактных структурах данных*, состоящих только из интерфейса. 15 | 16 | Структуры данных повсеместно используются в алгоритмах для решения вспомогательных задач, и в этой главе мы рассмотрим несколько базовых абстрактных структур данных, которые несложно реализовать самостоятельно. 17 | -------------------------------------------------------------------------------- /content/russian/cs/basic-structures/deque.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Дек 3 | weight: 7 4 | draft: true 5 | --- 6 | 7 | `deque` - структура, позволяющая работать и с началом и концом 8 | одновременно, то есть вставка и удаление с двух сторон 9 | 10 | ``` C++ 11 | deque name; // дек типа T с названием name 12 | name.front(), name.back(); // ссылка на первый и последний элемент соответственно 13 | name.pop_front(), name.pop_back(); // удаление первого и последнего элемента 14 | name.push_front(x), name.push_back(x); // вставка x в начало/конец 15 | ``` 16 | 17 | Дек - это структура данных, которая тоже хранит упорядоченные элементы с 18 | такими операциями за $O(1)$: 19 | 20 | - `push_back(x)` - положить элемент в конец дека 21 | - `push_front(x)` - положить элемент в начало дека 22 | - `pop_back()` - вынуть и вернуть элемент из конца дека 23 | - `pop_front()` - вынуть и вернуть элемент из начала дека 24 | 25 | То есть очередь и стек можно реализовать с помощью дека. Чаще всего 26 | удобно вместо очереди использовать именно дек. 27 | 28 | Один из способ реализации дека --- с помощью закольцованного буфера. 29 | -------------------------------------------------------------------------------- /content/russian/cs/basic-structures/img/linked.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/basic-structures/img/linked.png -------------------------------------------------------------------------------- /content/russian/cs/basic-structures/img/memory-layout.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/basic-structures/img/memory-layout.png -------------------------------------------------------------------------------- /content/russian/cs/basic-structures/queue.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Очередь 3 | weight: 6 4 | draft: true 5 | --- 6 | 7 | В C++ реализована очередь. Называется она queue. Чтобы ее использовать, 8 | необходимо подключить заголовочный файл `queue`. Объявление очереди 9 | выглядит так: 10 | 11 | ``` C++ 12 | queue q; 13 | ``` 14 | 15 | Очередь - структура, реализующая принцип FIFO (первый пришел - первый 16 | вышел), то есть для очереди существуют две основные функции: вставить 17 | в конец и достать с начала. 18 | 19 | ``` C++ 20 | q.front(); // ссылка на первый элемент 21 | q.back(); // ссылка на последний элемент 22 | q.push(x); // добавить в конец 23 | q.pop(); //удалить с начала 24 | ``` 25 | 26 | Очередь — это структура данных, которая тоже хранит упорядоченные 27 | элементы с такими операциями за $O(1)$: 28 | 29 | - `push(x)` — положить элемент в конец очереди 30 | - `pop()` — вынуть и вернуть элемент из начала очереди 31 | 32 | Выполняется принцип FIFO (First In - First Out) — кто первый пришел, тот 33 | первый и ушел. Очередь удобно использовать для моделирования реальных 34 | очередей, ведь они позволяют честно распределить что-то — кто первый 35 | пришел, тот первый и получил. Также очередь часто используют для 36 | алгоритмов с несколькими независимыми процессами — удобно хранить 37 | очередь задач, которые нужно выполнить, и процесс, когда освобождается, 38 | берет из очереди самую раннюю добавленную задачу и берется ее 39 | выполнять. 40 | 41 | В с++ — `queue`` queue_name ` -------------------------------------------------------------------------------- /content/russian/cs/combinatorial-objects/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Комбинаторные объекты 3 | weight: 14 4 | draft: true 5 | --- 6 | -------------------------------------------------------------------------------- /content/russian/cs/combinatorial-objects/encode-decode.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Кодирование 3 | weight: 100 4 | draft: true 5 | --- -------------------------------------------------------------------------------- /content/russian/cs/combinatorial-objects/numbers.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Числа с заданным свойством 3 | weight: 3 4 | --- 5 | 6 | ## Облегчение 7 | 8 | Решим сначала задачу найти количество чисел \< $10^k$ с суммой $S$, 9 | пусть dp\[i\]\[j\] - количество чисел из i разрядов с суммой j, 10 | тогда ответ - dp\[k\]\[s\], формула пересчета же следующая $dp\[i + 11 | 1\]\[j + c\] += dp\[i\]\[j\] \\forall c in \[0, 9\]$ 12 | 13 | ## Возвращение 14 | 15 | Заметим, что единственное, что теперь меняется, это то что нам нужно 16 | знать меньше ли то число которое мы набрали нашего $k$ или нет, 17 | давайте, тогда изменим нашу динамику на $dp\[i\]\[s\]\[can\]$ - мы 18 | набрали первые i цифр числа, с суммой s и при этом can = 1, если мы уже 19 | меньше числа $k$ и 0 иначе, тогда база - dp\[0\]\[0\]\[0\] = 1, пусть 20 | $k_{i}$ - i-ая цифра с начала числа $k$, формула перехода 21 | $dp\[i\]\[j\]\[0\] = \\sum\\limits_{c = 0}^{c \<= k_{i - 1}} dp\[i - 22 | 1\]\[j - c\]\[0\], dp\[i\]\[j\]\[1\] = \\sum\\limits_{c = 0}^{c \< 23 | k_{i - 1}} dp\[i - 1\]\[j - c\]\[0\] + \\sum\\limits_{c = 0}^{c \<= 9} 24 | dp\[i - 1\]\[j - c\]\[1\]$, ответ - dp\[len(k)\]\[s\]\[1\] + 25 | dp\[len(k)\]\[s\]\[0\]. 26 | 27 | --- 28 | 29 | ## Задача 30 | 31 | Найти количество чисел из $n$ разрядов, у которых все соседние цифры 32 | разной четности 33 | 34 | ## Решение 35 | 36 | 1\) $dp_{i, mod}$ - количество чисел из $i$ разрядов с четностью 37 | последней цифры - mod 2) База $dp_{1, 1} = 4, dp_{1, 0} = 1$ 3) 38 | $dp_{i, mod} = dp_{i - 1, 1 \\bigoplus mod} \\cdot 5$ 4) Порядок 39 | обхода - вперед 5) Ответ - $dp_{n, 0} + dp_{n, 1}$ 40 | 41 | Также можно подумать о комбинаторном решении задачи. 42 | -------------------------------------------------------------------------------- /content/russian/cs/combinatorial-optimization/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Комбинаторная оптимизация 3 | weight: 15 4 | --- 5 | 6 | *Комбинаторная оптимизация* заключается в поиске некотрого *оптимального* объекта в конечном множестве объектов. 7 | 8 | За долгое время любую задачу комбинаторной оптимизации можно решить полным перебором, но для большого класса задач есть либо гораздо более быстрые точные решения, либо весьма хорошие аппроксимации. О таких задачах мы и поговорим в этой главе. 9 | -------------------------------------------------------------------------------- /content/russian/cs/combinatorial-optimization/huffman.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Код Хаффмана 3 | weight: 2 4 | draft: true 5 | --- 6 | -------------------------------------------------------------------------------- /content/russian/cs/combinatorial-optimization/img/annealing.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/combinatorial-optimization/img/annealing.gif -------------------------------------------------------------------------------- /content/russian/cs/combinatorial-optimization/img/tsp.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/combinatorial-optimization/img/tsp.gif -------------------------------------------------------------------------------- /content/russian/cs/combinatorial-optimization/linear-programming.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Линейное программирование 3 | draft: true 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/cs/combinatorial-optimization/tsp.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Задача коммивояжёра 3 | weight: 4 4 | draft: true 5 | --- -------------------------------------------------------------------------------- /content/russian/cs/complexity/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Вычислительная сложность 3 | part: Анализ алгоритмов 4 | weight: 1 5 | --- 6 | 7 | В этой главе мы поговорим о том, как оценивать вычислительные ресурсы — такие как время и память — которые требуются для завершения алгоритмов. 8 | -------------------------------------------------------------------------------- /content/russian/cs/complexity/amortization.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Амортизация 3 | weight: 4 4 | draft: true 5 | --- 6 | 7 | ## BogoSort 8 | 9 | ## Стационарные точки 10 | 11 | ## Обновления минимума 12 | 13 | ```cpp 14 | int m = 1e9, cnt = 0; 15 | for (int i = 0; i < n; i++) 16 | if (a[i] < m) 17 | m = i, cnt++; 18 | ``` 19 | 20 | $O(\log n)$ 21 | -------------------------------------------------------------------------------- /content/russian/cs/complexity/img/divide-and-conquer.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/complexity/img/divide-and-conquer.png -------------------------------------------------------------------------------- /content/russian/cs/complexity/models.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Модели вычислений 3 | weight: 1 4 | draft: true 5 | --- 6 | 7 | -------------------------------------------------------------------------------- /content/russian/cs/complexity/randomized.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Рандомизированные алгоритмы 3 | weight: 5 4 | draft: true 5 | --- 6 | 7 | ## BogoSort 8 | 9 | ## Стационарные точки 10 | 11 | ## Обновления минимума 12 | 13 | ```cpp 14 | int m = 1e9, cnt = 0; 15 | for (int i = 0; i < n; i++) 16 | if (a[i] < m) 17 | m = i, cnt++; 18 | ``` 19 | 20 | $O(\log n)$ 21 | -------------------------------------------------------------------------------- /content/russian/cs/convex-hulls/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Выпуклые оболочки 3 | author: Сергей Слотин 4 | weight: 28 5 | --- 6 | 7 | **Выпуклое множество** — такое множество точек, что, для любых двух точек множества, все точки на отрезке между ними тоже принадлежат этому множеству. 8 | 9 | **Выпуклая оболочка** множества точек — такое выпуклое множество точек, что все точки фигуры также лежат в нем. 10 | 11 | **Минимальная выпуклая оболочка** множества точек — это минимальная по площади выпуклая оболочка. 12 | 13 | Для экономии времени дальше минимальные выпуклые оболочки мы будем называть просто выпуклыми оболочками. 14 | 15 | ![](img/convex-hull.png) 16 | 17 | Для практических целей выпуклые оболочки полезны тем, что они компактно хранят всю необходимую информацию о множестве точек, что позволяет быстро отвечать на разнообразные запросы на этом множестве. 18 | 19 | Выпуклые оболочки можно рассматривать в любом пространстве, но в этой статье мы ограничимся двумерным и научимся их эффективно и строить по какому-то множеству из $n$ точек на плоскости и применять для ответов разнообразные на запросы об этом множестве. 20 | -------------------------------------------------------------------------------- /content/russian/cs/convex-hulls/chan.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Алгоритм Чана 3 | weight: 3 4 | --- 5 | 6 | Как уже упоминалось ранее, иногда существенную роль играет то, что алгоритм Джарвиса работает за $O(nh)$, а не $O(n^2)$: когда известно, что оболочка небольшая, он лучше алгоритма Грэхэма за $O(n \log n)$. 7 | 8 | Алгоритм Чана пытается получить лучшее из двух и объединить алгоритмы Джарвиса и Грэхэма, чтобы получить асимптотику $O(n \log h)$. 9 | 10 | **Алгоритм.** Разделим все точки на группы по $m$ точек. В каждой группе построим выпуклую оболочку за $O(m \log m)$ алгоритмом Грэхэма. Точки никак не упорядочены, и эти оболочки могут пересекаться — это нормально. Суммарно для всех групп понадобится $O(n \log m)$ операций. 11 | 12 | Затем, начиная с самой левой нижней точки, мы будем строить общую выпуклую оболочку аналогично алгоритму Джарвиса, но теперь «самую правую точку» можно находить каждый раз не за $O(n)$, а за $O(\frac{n}{m} \log m)$, если делать бинарный поиск в каждой из $\frac{n}{m}$ оболочек. 13 | 14 | ![Здесь группы разделены по $x$, но это только для демонстрации](../img/chan.gif) 15 | 16 | Получается, что такое решение будет работать за $O(h \frac{n}{m} \log m + n \log m)$. Если заранее приблизительно знать $h$, то можно положить $m = h$, и тогда асимптотика составит $O(n \log h)$. 17 | 18 | Понятно, что ни при каких применимых на практике ограничениях, даже если оболочка состоит из трёх точек, этот алгоритм не будет быстрее обычного алгоритма Грэхэма, так что автор не будет приводить его реализацию. Этот способ просто интересен с теоретической точки зрения. 19 | 20 | **Упражнение.** Придумайте, как при неизвестном $h$ подбирать $m$ так, чтобы асимптотика оставалась $O(n \log h)$. -------------------------------------------------------------------------------- /content/russian/cs/convex-hulls/img/chan.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/convex-hulls/img/chan.gif -------------------------------------------------------------------------------- /content/russian/cs/convex-hulls/img/convex-hull.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/convex-hulls/img/convex-hull.png -------------------------------------------------------------------------------- /content/russian/cs/convex-hulls/img/graham.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/convex-hulls/img/graham.gif -------------------------------------------------------------------------------- /content/russian/cs/convex-hulls/img/jarvis.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/convex-hulls/img/jarvis.jpg -------------------------------------------------------------------------------- /content/russian/cs/convex-hulls/img/jarvis.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/convex-hulls/img/jarvis.png -------------------------------------------------------------------------------- /content/russian/cs/convex-hulls/li-chao.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Дерево Ли Чао 3 | draft: true 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/cs/decomposition/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Декомпозиция задач 3 | weight: 5 4 | --- 5 | 6 | В этой главе представлены общие способы решения задач путем разбиения на более простые. 7 | -------------------------------------------------------------------------------- /content/russian/cs/decomposition/divide-and-conquer.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Разделяй и властвуй 3 | draft: true 4 | --- 5 | 6 | Проанализируем название - разделяй и властвуй - значит метод будет 7 | разделять задачу на две и как-то властвовать. 8 | 9 | Мы уже разобрали метод mitm, когда мы просто решали каждую из двух 10 | частей, как исходную задачу, давайте теперь и полученные две 11 | задачи решать также : разбивая на задачи все меньше и меньше, пока 12 | не доберемся до элементарной(длины 1). 13 | -------------------------------------------------------------------------------- /content/russian/cs/decomposition/img/2d-scanline.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/decomposition/img/2d-scanline.jpg -------------------------------------------------------------------------------- /content/russian/cs/decomposition/img/2d-sum.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/decomposition/img/2d-sum.jpg -------------------------------------------------------------------------------- /content/russian/cs/decomposition/img/cliques.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/decomposition/img/cliques.png -------------------------------------------------------------------------------- /content/russian/cs/dynamic-subsets/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Динамика по подмножествам 3 | weight: 13 4 | draft: true 5 | --- 6 | 7 | -------------------------------------------------------------------------------- /content/russian/cs/dynamic-subsets/parameter-answer.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Замена ответа на параметр 3 | draft: true 4 | --- -------------------------------------------------------------------------------- /content/russian/cs/factorization/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Факторизация и простые числа 3 | weight: 19 4 | --- 5 | 6 | Одним из важнейших достижений античной греческой математики является доказательство утверждения, которое мы сейчас называем *основной теоремой арифметики*: 7 | 8 | > Всякое число, большее 1, может быть разложено в произведение простых чисел, и это разложение единственно с точностью до порядка множителей. 9 | > 10 | > *— Евклид, IV век до н. э.* 11 | 12 | Однако древние греки по какой-то причине не разработали эффективные методы вычисления этого разложения на миллиметровых кристаллах кремния — чем мы в свою очередь и займёмся в этой главе. 13 | -------------------------------------------------------------------------------- /content/russian/cs/factorization/img/rho.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/factorization/img/rho.jpg -------------------------------------------------------------------------------- /content/russian/cs/factorization/sqrt-factorization.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Факторизация за корень 3 | weight: 2 4 | draft: true 5 | --- 6 | -------------------------------------------------------------------------------- /content/russian/cs/flows/min-cut.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Минимальные разрезы 3 | draft: true 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/cs/games/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Теория игр 3 | weight: 16 4 | --- 5 | 6 | *Теория игр* занимается изучением оптимальных стратегий в *играх*: произвольных процессах, в которых участвуют две и более сторон, ведущие борьбу за реализацию своих интересов. 7 | 8 | Под играми люди обычно подразумевают разные «несерьёзные» активности, в которых люди участвуют для обучения, социализации или утоления психологических потребностей. Например: 9 | 10 | - «Крестики-нолики» 11 | - Шахматы 12 | - Покер 13 | - «Колонизаторы» 14 | - «Мафия» 15 | - StarCraft II 16 | 17 | Однако в более общем смысле почти все взаимодействия в реальном мире являются математическими играми: 18 | 19 | - Торговля 20 | - Аукционы 21 | - Поиск работы 22 | - Дейтинг 23 | - Преступность 24 | - Конкуренция в бизнесе 25 | - Войны 26 | - Политика 27 | - Любые переговоры 28 | 29 | Чтобы достаточно точно описать всё это разнообразие игр, нужна очень богатая теория, во многом граничащая с экономикой и информатикой. 30 | 31 | В этом разделе мы сконцентрируемся на отдельном классе *комбинаторных игр*, которые можно решать с помощью динамического программирования. 32 | -------------------------------------------------------------------------------- /content/russian/cs/games/img/nim.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/games/img/nim.jpg -------------------------------------------------------------------------------- /content/russian/cs/games/img/zugzwang.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/games/img/zugzwang.png -------------------------------------------------------------------------------- /content/russian/cs/games/img/Введение_в_теорию_комбинаторных_игр.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/games/img/Введение_в_теорию_комбинаторных_игр.pdf -------------------------------------------------------------------------------- /content/russian/cs/games/minimax.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Минимаксные игры 3 | weight: 3 4 | draft: true 5 | --- -------------------------------------------------------------------------------- /content/russian/cs/games/pruning.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Перебор с отсечениями 3 | weight: 4 4 | draft: true 5 | --- -------------------------------------------------------------------------------- /content/russian/cs/geometry-advanced/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Продвинутая геометрия 3 | weight: 29 4 | draft: true 5 | --- 6 | -------------------------------------------------------------------------------- /content/russian/cs/geometry-advanced/area.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Нахождение площадей 3 | draft: true 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/cs/geometry-advanced/planar-graphs.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Планарные графы 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/cs/geometry-basic/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Геометрические примитивы 3 | part: Геометрия 4 | authors: 5 | - Александр Гришутин 6 | - Полина Романченко 7 | editors: 8 | - Сергей Слотин 9 | weight: 27 10 | date: 2021-08-26 11 | --- 12 | 13 | В математике, геометрические задачи в основном доказательные: обычно требуется показать, что угол $A$ равен углу $B$, или что такой-то отрезок во столько-то раз больше другого. В школе её используют для знакомства с основными принципами логики и отучивания от слова «очевидно». 14 | 15 | В программировании (как и в реальной жизни) задачи совершенно другого плана: геометрия больше количественная, чем качественная, и применяется для оптимизации чего-то, для подсчета точных величин, или для выполнения зависящих от конкретных чисел проверок. 16 | 17 | Для решения подобных задач есть два подхода: алгебраический и конструктивный. Когда математик говорит «пересечем две прямые», он представляет громоздкое уравнение, с которым он потом будет работать. Программист же хочет абстрагироваться и написать функцию `intersect(a, b)`, в корректности которой он точно уверен, которую он будет вызывать по необходимости, не беспокоясь об алгебраических выражениях. Это позволяет разбить задачу на много маленьких кусочков, которые можно решать по отдельности, а не возиться с формулами. 18 | 19 | ![](img/voronoi.png) 20 | 21 | В этой главе мы рассмотрим как раз такой конструктивный подход к вычислительной геометрии и научимся манипулировать различными геометрическими объектами с помощью ООП в C++. 22 | -------------------------------------------------------------------------------- /content/russian/cs/geometry-basic/img/area.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/geometry-basic/img/area.jpg -------------------------------------------------------------------------------- /content/russian/cs/geometry-basic/img/cross.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/geometry-basic/img/cross.jpg -------------------------------------------------------------------------------- /content/russian/cs/geometry-basic/img/dodecahedron.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/geometry-basic/img/dodecahedron.gif -------------------------------------------------------------------------------- /content/russian/cs/geometry-basic/img/dot.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/geometry-basic/img/dot.jpg -------------------------------------------------------------------------------- /content/russian/cs/geometry-basic/img/findx.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/geometry-basic/img/findx.jpg -------------------------------------------------------------------------------- /content/russian/cs/geometry-basic/img/ray.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/geometry-basic/img/ray.gif -------------------------------------------------------------------------------- /content/russian/cs/geometry-basic/img/ray.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/geometry-basic/img/ray.png -------------------------------------------------------------------------------- /content/russian/cs/geometry-basic/img/segments.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/geometry-basic/img/segments.png -------------------------------------------------------------------------------- /content/russian/cs/geometry-basic/img/trapeze.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/geometry-basic/img/trapeze.jpg -------------------------------------------------------------------------------- /content/russian/cs/geometry-basic/img/trapeze.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/geometry-basic/img/trapeze.png -------------------------------------------------------------------------------- /content/russian/cs/geometry-basic/img/triangles.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/geometry-basic/img/triangles.png -------------------------------------------------------------------------------- /content/russian/cs/geometry-basic/img/vector.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/geometry-basic/img/vector.jpg -------------------------------------------------------------------------------- /content/russian/cs/geometry-basic/img/voronoi.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/geometry-basic/img/voronoi.png -------------------------------------------------------------------------------- /content/russian/cs/graph-traversals/img/bridges.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/graph-traversals/img/bridges.png -------------------------------------------------------------------------------- /content/russian/cs/graph-traversals/img/components.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/graph-traversals/img/components.jpg -------------------------------------------------------------------------------- /content/russian/cs/graph-traversals/img/disconnected.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/graph-traversals/img/disconnected.png -------------------------------------------------------------------------------- /content/russian/cs/graph-traversals/img/euler-small.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/graph-traversals/img/euler-small.png -------------------------------------------------------------------------------- /content/russian/cs/graph-traversals/img/euler.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/graph-traversals/img/euler.png -------------------------------------------------------------------------------- /content/russian/cs/graph-traversals/img/graph.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/graph-traversals/img/graph.png -------------------------------------------------------------------------------- /content/russian/cs/graph-traversals/img/graphs.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/graph-traversals/img/graphs.gif -------------------------------------------------------------------------------- /content/russian/cs/graph-traversals/img/russia.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/graph-traversals/img/russia.png -------------------------------------------------------------------------------- /content/russian/cs/graph-traversals/img/scc.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/graph-traversals/img/scc.png -------------------------------------------------------------------------------- /content/russian/cs/graph-traversals/img/sorting.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/graph-traversals/img/sorting.png -------------------------------------------------------------------------------- /content/russian/cs/hashing/img/chess-game-tree.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/hashing/img/chess-game-tree.jpg -------------------------------------------------------------------------------- /content/russian/cs/hashing/img/chess.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/hashing/img/chess.png -------------------------------------------------------------------------------- /content/russian/cs/hashing/img/hash-table.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/hashing/img/hash-table.png -------------------------------------------------------------------------------- /content/russian/cs/hashing/img/sicilian.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/hashing/img/sicilian.png -------------------------------------------------------------------------------- /content/russian/cs/hashing/rope.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Строп 3 | draft: true 4 | --- 5 | 6 | 7 | ### Хранение строк в декартовом дереве 8 | 9 | Если для вас всё вышеперечисленное тривиально: можно делать много клёвых вещей, если «оборачивать» строки в [декартово дерево](treap). В вершине дерева можно хранить символ, а также хэш подстроки, соответствующей её поддереву. Чтобы поддерживать хэш, нужно просто добавить в `upd()` пересчёт хеша от конкатенации трёх строк — левого сына, своего собственного символа и правого сына. 10 | 11 | Имея такое дерево, мы можем обрабатывать запросы, связанные с изменением строки: удаление и вставка символа, перемещение и переворот подстрок, а если дерево персистентное — то и копирование подстрок. При запросе хеша подстроки нам, как обычно, нужно просто вырезать нужную подстроку и взять хэш, который будет лежать в вершине-корне. 12 | 13 | Если нам не нужно обрабатывать запросы вставки и удаления символов, а, например, только изменения, то можно использовать и дерево отрезков вместо декартова. 14 | 15 | -------------------------------------------------------------------------------- /content/russian/cs/heuristic/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Эвристические алгоритмы 3 | weight: 40 4 | draft: true 5 | --- 6 | 7 | *Эвристическими* называют алгоритмы, которые не имеют формального обоснования своей корректности или низкого времени работы, однако хорошо работают на практике. 8 | -------------------------------------------------------------------------------- /content/russian/cs/heuristic/bandits.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Многорукие бандиты 3 | draft: true 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/cs/heuristic/genetic.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Генетические алгоритмы 3 | draft: true 4 | --- -------------------------------------------------------------------------------- /content/russian/cs/heuristic/img/annealing.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/heuristic/img/annealing.gif -------------------------------------------------------------------------------- /content/russian/cs/heuristic/img/tsp.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/heuristic/img/tsp.gif -------------------------------------------------------------------------------- /content/russian/cs/interactive/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Бинпоиск и интерактивки 3 | weight: 3 4 | authors: 5 | - Андрей Гаркавый 6 | - Сергей Слотин 7 | --- 8 | 9 | В предыдущей главе мы рассматривали различные способы сделать последовательности упорядоченными; в этой мы обсудим, где это может быть полезным. 10 | -------------------------------------------------------------------------------- /content/russian/cs/interactive/convex-functions.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Выпуклые функции 3 | authors: 4 | - Сергей Слотин 5 | draft: true 6 | --- 7 | 8 | В этой статье мы немного поговорим о применимости бинарного поиска. 9 | 10 | **Задача.** Дана последовательность $a$, найти арифметическую прогрессию $b_i = b_0 + d * i$, минимизирующую сумму абсолютных ошибок $|a_i - b_i|$. На сотню заходил тернарник по d и нахождение медианы ( O(n log n) ). 11 | 12 | f(h, d) это сумма функций вида |h+kd|. Каждая такая функция выпукла — если её нарисовать, то это немного перекошенный клин. Сумма выпуклых функций выпукла, значит f тоже. 13 | Точки (d, g(h, d)) где g(d) = min { f(h, d) }, можно представить как кривую, огибающую функцию f снизу. Она выпукла, так как в противном случае существовала бы точка между двумя точками из f, не принадлежащие f, чего не может быть из определения выпуклости f. 14 | Если эта кривая выпукла, то минимум на ней можно искать тернарником и гг. 15 | -------------------------------------------------------------------------------- /content/russian/cs/interactive/interactive.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Интерактивные задачи 3 | draft: true 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/cs/interactive/parallel-search.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: «Параллельный» бинарный поиск 3 | draft: true 4 | --- -------------------------------------------------------------------------------- /content/russian/cs/layer-optimizations/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Пересчет динамики по слоям 3 | weight: 16 4 | authors: 5 | - Сергей Слотин 6 | - Константин Амеличев 7 | created: "2019" 8 | date: 2021-08-29 9 | --- 10 | 11 | **Задача.** Даны $n$ точек на прямой, отсортированные по своей координате $x_i$. Нужно найти $m$ отрезков, покрывающих все точки, минимизировав при этом сумму квадратов их длин. 12 | 13 | **Базовое решение** — определить состояние динамики $f[i, j]$ как минимальную стоимость покрытия $i$ первых точек используя не более $j$ отрезков. Пересчитывать её можно перебором всех возможных последних отрезков: 14 | 15 | $$ 16 | f[i, j] = \min_{k < i} \{f[k, j-1] + (x_{i-1}-x_k)^2 \} 17 | $$ 18 | 19 | Итоговым ответом будет $f[n, m]$, а суммарно такая динамика будет работать за $O(n^2 m)$. 20 | 21 | ```c++ 22 | // x[] — отсортированный массив координат точек, индексация с нуля 23 | 24 | // квадрат длины отрезка с i-той до j-той точки 25 | int cost(int i, int j) { 26 | return (x[j] - x[i]) * (x[j] - x[i]); 27 | } 28 | 29 | for (int i = 0; i <= m; i++) 30 | f[0][i] = 0; // если нам не нужно ничего покрывать, то всё и так хорошо 31 | // все остальные f предполагаем равными бесконечности 32 | 33 | for (int i = 1; i <= n; i++) 34 | for (int j = 1; j <= m; j++) 35 | for (int k = 0; k < i; k++) 36 | f[i][j] = min(f[i][j], f[k][j - 1] + cost(k, i - 1)); 37 | ``` 38 | 39 | (Заметим, что циклы по `i` и `j` можно поменять местами.) 40 | 41 | В этой главе мы рассмотрим 4 связанных между собой способа её соптимизировать, помимо непосредственно этой задачи обобщающихся и на многие другие динамики. -------------------------------------------------------------------------------- /content/russian/cs/layer-optimizations/img/scooby-doo.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/layer-optimizations/img/scooby-doo.jpg -------------------------------------------------------------------------------- /content/russian/cs/matching/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Паросочетания 3 | weight: 23 4 | --- 5 | 6 | **Задача.** Пусть есть $n$ мальчиков и $m$ девочек. Про каждого мальчика и про каждую девочку известно, с кем они не против танцевать. Нужно составить как можно больше пар, в которых партнёры хотят танцевать друг с другом. 7 | 8 | ![](img/matching.png) 9 | 10 | Формализуем эту задачу, представив мальчиков и девочек как вершины в двудольном графе, рёбрами которого будет отношение «могут танцевать вместе». Будем в дальнейшем обозначать левую долю графа как $L$, а правую долю как $R$. 11 | 12 | **Паросочетанием** $M$ называется набор попарно несмежных рёбер графа (иными словами, любой вершине графа должно быть инцидентно не более одного ребра из $M$). 13 | 14 | Все вершины, у которых есть смежное ребро из паросочетания (т.е. которые имеют степень ровно один в подграфе, образованном $M$), назовём *насыщенными* этим паросочетанием. 15 | 16 | *Мощностью* паросочетания назовём количество рёбер в нём. *Наибольшим* (*максимальным*) паросочетанием назовём паросочетание, мощность которого максимальна среди всех возможных паросочетаний в данном графе, а *совершенным* — где все вершины левой доли им насыщенны. 17 | 18 | Паросочетания [можно искать](http://e-maxx.ru/algo/matching_edmonds) не только в двудольных графах, однако общий алгоритм неприятно кодить, и он работает за $O(n^3)$, так что в этой главе мы сфокусируемся только на двудольных графах. 19 | -------------------------------------------------------------------------------- /content/russian/cs/matching/img/alternating.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/matching/img/alternating.jpg -------------------------------------------------------------------------------- /content/russian/cs/matching/img/cubes.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/matching/img/cubes.jpg -------------------------------------------------------------------------------- /content/russian/cs/matching/img/cubes.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/matching/img/cubes.png -------------------------------------------------------------------------------- /content/russian/cs/matching/img/hall.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/matching/img/hall.gif -------------------------------------------------------------------------------- /content/russian/cs/matching/img/matching.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/matching/img/matching.png -------------------------------------------------------------------------------- /content/russian/cs/matching/stable-marriage.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Задача о марьяже 3 | weight: 5 4 | draft: true 5 | --- 6 | -------------------------------------------------------------------------------- /content/russian/cs/modular/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Модулярная арифметика 3 | weight: 17 4 | --- 5 | 6 | Компьютеры обычно хранят время в секундах, прошедших с 1 января 1970 года — начала «эпохи Unix». 7 | 8 | Люди также хранят время относительно какого-то момента в прошлом — обычно имеющего какую-то политическую, культурную или религиозную значимость — в зависимости от календаря. На момент написания этой статьи, прошло примерно 63882260594 секунд с 0 года н. э. 9 | 10 | Но в отличие от компьютеров, мы в повседневной жизни не пользуемся *всей* этой информацией. В зависимости от задачи, нам достаточно знания о том, что сейчас 14:00 и пора на обед, или что сегодня четверг и в Subway скидка на итальянский BMT. Вместо целого таймстемпа мы используем его *остаток*, содержащий лишь ту информацию, которая нам нужна. 11 | 12 | Самая удобная вещь про остатки в том, что они цикличны: после 12 на часах идёт 1, и поэтому число всегда остается небольшим. Гораздо проще работать с одно- или двузначными числами вместо 11-значных. 13 | 14 | ![](img/clock.gif) 15 | 16 | **Задача.** Пусть сегодня четверг. Какой день недели будет через год? 17 | 18 | Если мы пронумеруем все дни недели от 0 с 6 начиная с понедельника, то четверг получит номер 3. Нам нужно добавить к этому числу 365 и затем взять остаток от деления на 7. Так как `365 % 7` удобно равен 1, то мы получаем, что через год будет пятница (если это не високосный год, в случае чего будет суббота). 19 | 20 | *Модулярная арифметика* занимается изучением подобных интересных свойств остатков. 21 | -------------------------------------------------------------------------------- /content/russian/cs/modular/img/clock.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/modular/img/clock.gif -------------------------------------------------------------------------------- /content/russian/cs/modular/img/euclidean.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/modular/img/euclidean.png -------------------------------------------------------------------------------- /content/russian/cs/modular/modulo-optimization.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Оптимизация операций по модулю 3 | authors: 4 | - Иван Сафонов 5 | weight: 100 6 | draft: true 7 | --- 8 | 9 | Давайте разберемся, как считать значения выражения по модулю так, чтобы 10 | это требовало минимального количества процессорных операций. 11 | 12 | Если мы складываем значения, каждое из которых меньше $MOD$, то можно не 13 | брать их по модулю, а обходиться $if$-ами и вычитанием: 14 | 15 | ``` c++ numberLines 16 | int res = a + b; 17 | if (res >= MOD) { 18 | res -= MOD; 19 | } 20 | ``` 21 | 22 | В некоторых задачах, где надо считать сумму произведений величин, каждая 23 | из которых меньше $MOD$, бывает полезна следующая 24 | неасимптотическая оптимизация: Будем считать все 25 | произведения по модулю $MOD^2$, для подсчета сумм таких величин 26 | воспользуемся предыдущей техникой, а затем единожды возьмем 27 | ответ по модулю $MOD$. Такой трюк бывает полезен, к примеру, при 28 | [перемножении матриц](Возведение_матрицы_в_степень "wikilink"): 29 | 30 | ``` c++ numberLines 31 | matrix multiple(matrix& a, matrix &b) { 32 | int n = a.size(); 33 | int m = b[0].size(); 34 | int k = b.size(); 35 | matrix c(n, m); 36 | for (int i = 0; i < n; i++) { 37 | for (int j = 0; j < m; j++) { 38 | int res = 0; 39 | for (int t = 0; t < k; t++) { 40 | res += a[i][t] * b[t][j]; 41 | if (res >= MOD2) { 42 | res -= MOD2; 43 | } 44 | } 45 | c[i][j] = res % MOD; 46 | } 47 | } 48 | return res; 49 | } 50 | ``` 51 | -------------------------------------------------------------------------------- /content/russian/cs/numerical/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Численные методы 3 | weight: 39 4 | part: Разное 5 | --- 6 | 7 | Во многих задачах ответ требуется найти не абсолютно точно, а с каким-то допустимым уровнем ошибки. Часто это мотивируется тем, что в данных из реального мира и так содержатся ошибки моделирования и измерения, на несколько порядков превосходящие ошибки численных алгоритмов. 8 | 9 | В этой главе мы рассмотрим несколько подобных общих методов нахождения приближенных решений. 10 | -------------------------------------------------------------------------------- /content/russian/cs/numerical/gradient-descent.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Градиентный спуск 3 | draft: true 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/cs/numerical/img/monte-carlo.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/numerical/img/monte-carlo.gif -------------------------------------------------------------------------------- /content/russian/cs/numerical/img/newton.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/numerical/img/newton.png -------------------------------------------------------------------------------- /content/russian/cs/persistent/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Персистентность 3 | weight: 11 4 | authors: 5 | - Сергей Слотин 6 | date: 2021-09-11 7 | --- 8 | 9 | Персистентные структуры данных (англ. *persistent data structures*) — это структуры данных, которые при внесении в них изменений сохраняют доступ ко всем своим предыдущим состояниям. 10 | 11 | Есть несколько «уровней» персистентности: 12 | 13 | - Частичная — к каждой версии можно делать запросы, но изменять можно только последнюю. 14 | - Полная — можно делать запросы к любой версии и менять любую версию. 15 | - Конфлюэнтная — помимо этого можно объединять две структуры данных в одну (например, сливать вместе кучи или деревья поиска). 16 | - Функциональная — структуру можно реализовать на чистом функциональном языке: для любой переменной значение может быть присвоено только один раз и изменять значения переменных нельзя. 17 | 18 | Персистентные структуры используются в текстовых редакторах, системах контроля версий, базах данных, в некоторых параллельных алгоритмах, а также в функциональном программировании. 19 | 20 | Помимо этого, персистентные структуры нередко используются и для решения «обычных» алгоритмических задач, что и будет основным фокусом этой главы. 21 | -------------------------------------------------------------------------------- /content/russian/cs/persistent/img/path-copy.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/persistent/img/path-copy.png -------------------------------------------------------------------------------- /content/russian/cs/programming/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Технологии программирования 3 | weight: 100 4 | --- 5 | 6 | В этом разделе собрано всё, что относится к программированию в общем, а не только к алгоритмам. 7 | -------------------------------------------------------------------------------- /content/russian/cs/programming/python.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Ликбез по Python 3 | weight: 2 4 | draft: true 5 | --- 6 | -------------------------------------------------------------------------------- /content/russian/cs/range-queries/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Запросы на отрезках 3 | weight: 10 4 | --- 5 | 6 | [Бинарные деревья поиска](/cs/tree-structures) можно использовать почти для любых запросов про точечные множества: добавление, удаление, сумма, минимум, прибавление на отрезке, $k$-тое меньшее... 7 | 8 | Однако у общих бинарных деревьев есть и несколько недостатков: их сложно реализовывать, они довольно медленно работают (за счет прохождения по ссылкам), и на самом деле для некоторых запросов они не оптимальны. 9 | 10 | Если рассматриваемые множества фиксированного размера (например, массив размера $10^6$), то можно построить поверх них более эффективные статические структуры, которые не меняют свое устройство с течением времени, а только изменяют свои значения. О таких структурах мы и поговорим в этой главе. 11 | -------------------------------------------------------------------------------- /content/russian/cs/range-queries/img/fenwick-ranges.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/range-queries/img/fenwick-ranges.png -------------------------------------------------------------------------------- /content/russian/cs/range-queries/img/prefix-sum.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/range-queries/img/prefix-sum.png -------------------------------------------------------------------------------- /content/russian/cs/range-queries/img/sparse-table.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/range-queries/img/sparse-table.png -------------------------------------------------------------------------------- /content/russian/cs/range-queries/veb.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Дерево ван Эмде Боаса 3 | draft: true 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/cs/segment-tree/array.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Дерево отрезков на массиве 3 | weight: 2 4 | draft: true 5 | --- 6 | 7 | 8 | ![](http://i.imgur.com/GGBmcEP.png) 9 | -------------------------------------------------------------------------------- /content/russian/cs/segment-tree/img/segtree-example.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/segment-tree/img/segtree-example.jpg -------------------------------------------------------------------------------- /content/russian/cs/segment-tree/img/segtree-example.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/segment-tree/img/segtree-example.png -------------------------------------------------------------------------------- /content/russian/cs/segment-tree/img/segtree-ranges.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/segment-tree/img/segtree-ranges.png -------------------------------------------------------------------------------- /content/russian/cs/segment-tree/img/segtree-ranges2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/segment-tree/img/segtree-ranges2.png -------------------------------------------------------------------------------- /content/russian/cs/segment-tree/img/segtree-ranges3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/segment-tree/img/segtree-ranges3.png -------------------------------------------------------------------------------- /content/russian/cs/sequences/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Последовательности 3 | weight: 4 4 | --- 5 | 6 | В этой главе рассматриваются алгоритмы для неотсортированных последовательностей. 7 | -------------------------------------------------------------------------------- /content/russian/cs/sequences/memory-bound.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Однопроходные алгоритмы 3 | draft: true 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/cs/set-structures/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Структуры для множеств 3 | weight: 9 4 | --- 5 | 6 | В этой главе рассматриваются структуры для неупорядоченных множеств. 7 | -------------------------------------------------------------------------------- /content/russian/cs/set-structures/img/dsu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/set-structures/img/dsu.png -------------------------------------------------------------------------------- /content/russian/cs/set-structures/img/path-compression.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/set-structures/img/path-compression.png -------------------------------------------------------------------------------- /content/russian/cs/shortest-paths/diameter.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Нахождение диаметра дерева 3 | weight: 100 4 | draft: true 5 | --- 6 | -------------------------------------------------------------------------------- /content/russian/cs/shortest-paths/img/ShortestPaths2015.ppt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/shortest-paths/img/ShortestPaths2015.ppt -------------------------------------------------------------------------------- /content/russian/cs/shortest-paths/img/dijkstra-proof.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/shortest-paths/img/dijkstra-proof.png -------------------------------------------------------------------------------- /content/russian/cs/shortest-paths/img/dijkstra.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/shortest-paths/img/dijkstra.gif -------------------------------------------------------------------------------- /content/russian/cs/shortest-paths/img/maze.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/shortest-paths/img/maze.gif -------------------------------------------------------------------------------- /content/russian/cs/shortest-paths/img/shortest-unweighted.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/shortest-paths/img/shortest-unweighted.png -------------------------------------------------------------------------------- /content/russian/cs/shortest-paths/img/shortest-weighted.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/shortest-paths/img/shortest-weighted.png -------------------------------------------------------------------------------- /content/russian/cs/sorting/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Сортировки 3 | weight: 2 4 | authors: 5 | - Андрей Гаркавый 6 | - Сергей Слотин 7 | --- 8 | 9 | Задача сортировки массива заключается в том, чтобы расставить его элементы в определённом порядке — чаще всего по неубыванию: каждый элемент должен быть больше или равен предыдущему. 10 | 11 | ```python 12 | a = [5, 2, 1, 3, 1] 13 | a.sort() 14 | print(a) # [1, 1, 2, 3, 5] 15 | ``` 16 | 17 | Хотя эффективные алгоритмы сортировки реализованы в стандартной библиотеке большинства языков, полезно знать, какие подходы существуют, потому что часто можно модифицировать их для решения других смежных задач. Все алгоритмы в этом разделе относительно несложные и являются хорошими упражнениями в [оценке времени работы](../complexity). 18 | 19 | Полезно вместе с описанием алгоритмов смотреть их [визуализацию](https://visualgo.net/nl/sorting). 20 | -------------------------------------------------------------------------------- /content/russian/cs/sorting/bubble.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Сортировка пузырьком 3 | weight: 1 4 | published: true 5 | --- 6 | 7 | Наш первый подход будет заключаться в следующем: обозначим за $n$ длину массива и $n$ раз пройдёмся по нему слева направо, меняя два соседних элемента, если первый больше второго. 8 | 9 | Каждую итерацию максимальный элемент «всплывает» как пузырек к концу массива — отсюда и название. 10 | 11 | ```cpp 12 | void bubble_sort(int *a, int n) { 13 | for (int k = 0; k < n; k++) 14 | for (int i = 0; i < n - 1; i++) 15 | // сравниваем элемент со следующим 16 | if (a[i] > a[i + 1]) 17 | // меняем местами, если следующий меньше 18 | swap(a[i], a[i + 1]); 19 | } 20 | 21 | int a[5] = {5, 2, 1, 3, 1}; 22 | 23 | bubble_sort(a, 5); 24 | 25 | for (int i = 0; i < 5; i++) 26 | cout << a[i] << " "; 27 | ``` 28 | 29 | **Корректность.** По индукции можно показать, что после $k$ шагов алгоритма сортировки пузырьком последние $k$ чисел всегда отсортированы, а значит алгоритм работает корректно. 30 | 31 | **Асимптотика.** Так как у нас два вложенных цикла, каждый из которых делает не более $O(n)$ итераций, внутри которых за $O(1)$ происходит сравнение и `swap`, суммарное время работы будет не более $O(n^2)$. 32 | 33 | **Упражнение.** Алгоритм можно немного (неасимптотически) ускорить. Как нужно изменить границы в двух `for`-циклах, чтобы не делать никаких лишних действий? 34 | -------------------------------------------------------------------------------- /content/russian/cs/sorting/distribution.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Сортировка распределений 3 | draft: true 4 | --- 5 | 6 | -------------------------------------------------------------------------------- /content/russian/cs/sorting/heapsort.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Сортировка кучей 3 | authors: 4 | - Денис Акилов 5 | editors: 6 | - Сергей Слотин 7 | weight: 6 8 | date: 2021-10-21 9 | prerequisites: 10 | - /cs/basic-structures/heap 11 | - selection 12 | --- 13 | 14 | Причина, по которой [сортировка выбором](/cs/sorting/selection) работает за квадратичное время — это линейный поиск минимума на каждом шаге. 15 | 16 | Чтобы соптимизировать время работы алгоритма, мы можем завести специальную структуру данных, которая поддерживает быстрое извлечение минимума из набора неупорядоченных элементов, добавить весь исходных массив в неё, а затем по одному извлекать минимум в новый отсортированных массив. 17 | 18 | Это ровно то, что делает [двоичная куча](/cs/basic-structures/heap) — за $O(\log n)$ на операцию. Воспользовавшись ей, получаем алгоритм, работающий за $O(n \log n)$: 19 | 20 | ```cpp 21 | void heapsort(int* a, int n) { 22 | // копируем массив в кучу 23 | t_n = n; 24 | copy(a, a + n, t + 1); 25 | build_heap(); 26 | for (int i = 1; i <= n; i++) { 27 | // удаляем минимум, он останется в ячейке t[n + 1 - i] 28 | swap(t[1], t[n + 1 - i]); 29 | t_n--; 30 | sift_down(1); 31 | } 32 | // получили массив t[1..n], в котором все элементы упорядочены по убыванию 33 | reverse(t, t + n + 1); 34 | copy(t, t + n, a); 35 | } 36 | ``` 37 | 38 | Примечательно, что в случае «почти отсортированного» массива алгоритм можно немного ускорить. Если гарантируется, что каждый элемент находится на расстоянии не более $k$ от своей позиции в отсортированном массиве, то нам достаточно поддерживать кучу размера $O(k)$, считать массив «окном» из $k$ элементов, и после добавления очередного элемента выписывать минимум. Такой алгоритм будет работать за $O(n \log k)$. 39 | -------------------------------------------------------------------------------- /content/russian/cs/sorting/insertion.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Сортировка вставками 3 | weight: 3 4 | --- 5 | 6 | Пусть на $k$-ом шаге у нас уже отсортирован префикс длины $k$. Чтобы увеличить этот отсортированный префикс, мы можем взять элемент, следующий после него, и менять его с левым соседом, пока этот элемент не окажется больше своего левого соседа. Когда это произойдет, это будет означать, что он будет больше всех элементов слева и меньше всех элементов префикса справа, и значит мы правильно вставили этот элемент в отсортированную часть массива. 7 | 8 | ```cpp 9 | void insertion_sort(int *a, int n) { 10 | for (int k = 1; k < n; k++) 11 | for (int i = k; i > 0 && a[i - 1] < a[i]; i--) 12 | // мы ещё не дошли до начала массива и предыдущий элемент меньше 13 | swap(a[i], a[i - 1]); 14 | } 15 | ``` 16 | 17 | Время работы в худшем случае тоже квадратичное — например, когда массив упорядочен по убыванию. 18 | 19 | Однако, в отличие от двух предыдущих квадратичных сортировок, в некоторых хороших случаях время работы может быть меньше, потому что мы добавили условие ранней остановки во внутреннем цикле. Например, алгоритм сделает $O(n)$ операций, если массив изначально отсортирован. 20 | 21 | **Упражнение.** Покажите, что алгоритм делает $O(n k)$ операций, если массив «почти отсортирован» в том смысле, что каждый элемент находится на расстоянии не более $k$ от его позиции в отсортированном массиве. 22 | -------------------------------------------------------------------------------- /content/russian/cs/sorting/quicksort.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Быстрая сортировка 3 | weight: 5 4 | draft: true 5 | --- 6 | 7 | Быстрая сортировка заключается в том, что на каждом шаге мы находим опорный элемент, все элементы, которые меньше его кидаем в левую часть, остальные в правую, а затем рекурсивно спускаемся в обе части. 8 | 9 | ```cpp 10 | // partition - функция разбивающие элементы 11 | // на меньшие и больше/равные a[index], 12 | // при этом функция возвращает границу разбиения 13 | void partition(int l, int r, int p) { 14 | 15 | } 16 | 17 | void quicksort(int l, int r){ 18 | if (l < r){ 19 | int index = (l + r) / 2; /* index - индекс опорного элемента для 20 | начала сделаем его равным середине отрезка*/ 21 | index = partition(l, r, index); 22 | quicksort(l, index); 23 | quicksort(index + 1, r); 24 | } 25 | } 26 | ``` 27 | 28 | Давайте оценим асимптотику данной сортировки. На случайных данных она работает за $O(NlogN)$ , так как каждый раз мы будем делить массив на две примерно равные части, то есть суммарно размер рекурсии будет около логарифма и при этом на каждом этапе рекурсии мы просмотрим не более, чем размер массива. 29 | Однако можно легко найти две проблемы, одна - одинаковые числа, а вторая - если вдруг середина - минимум или максимум. 30 | 31 | Существуют несколько выходов из этой ситуации : 32 | 33 | 1. Давайте если быстрая сортировка работает долго, то запустим любую другую сортировку за $NlogN$. 34 | 2. Давайте делить массив не на две, а на три части(меньше, равны, больше). 35 | 3. Чтобы избавиться от проблемы с максимумом/минимумом в середине, давайте **брать случайный элемент**. 36 | -------------------------------------------------------------------------------- /content/russian/cs/sorting/radix.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Цифровая сортировка 3 | weight: 9 4 | authors: 5 | - Сергей Слотин 6 | --- 7 | 8 | Цифровая сортировка — это способ применить идею сортировки подсчетом на большие ключи. 9 | 10 | Пусть нам нужно отсортировать большой массив `int`-ов — скажем, $10^5$ элементов. Мы можем сначала отсортировать его по первым двум байтам (то есть используя $\lfloor x / 2^{16} \rfloor$ как ключ) стабильной сортировкой подсчетом, а затем получившуюся последовательность отсортировать по вторым двум байтам (используя $x \bmod 2^{16}$ как ключ). 11 | 12 | Реализация, использующая подсчет через массив векторов: 13 | 14 | ```cpp 15 | const int c = (1<<16); 16 | 17 | void radix_sort(vector &a) { 18 | int n = (int) a.size(); 19 | vector b[c]; 20 | 21 | for (int i = 0; i < n; i++) 22 | b[a[i] % c].push_back(a[i]); 23 | 24 | int k = 0; 25 | for (int i = 0; i < c; i++) { 26 | for (size_t j = 0; j < b[i].size(); j++) 27 | a[k++] = b[i][j]; 28 | b[i].clear(); 29 | } 30 | 31 | for (int i = 0; i < n; i++) 32 | b[a[i]/c].push_back(a[i]); 33 | 34 | k = 0; 35 | for (int i = 0; i < c; i++) 36 | for (size_t j = 0; j < b[i].size(); j++) 37 | a[k++] = b[i][j]; 38 | } 39 | ``` 40 | 41 | Этот подход можно обобщить на любой тип и размер ключа. 42 | -------------------------------------------------------------------------------- /content/russian/cs/sorting/selection.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Сортировка выбором 3 | weight: 2 4 | published: true 5 | --- 6 | 7 | Похожим методом является **сортировка выбором** (минимума или максимума). 8 | 9 | Чтобы отсортировать массив, $n$ раз выберем минимум среди еще неотсортированных чисел и поставим его на свое место (а именно, на $k$-тую позицию после $k$-той итерации). Чтобы упростить реализацию, на $k$-ой итерации будем искать минимум на отрезке $[k, n - 1]$, меняя его местами с текущим $k$-тым элементом, после чего отрезок $[0, k]$ будет отсортирован. 10 | 11 | ```cpp 12 | void selection_sort(int *a, int n) { 13 | for (int k = 0; k < n - 1; k++) 14 | for (int j = k + 1; j < n; j++) 15 | if (a[k] > a[j]) 16 | swap(a[j], a[k]); 17 | } 18 | ``` 19 | 20 | Доказательства корректности и времени работы аналогичны [пузырьковой сортировке](../bubble): после каждой из $O(n)$ итераций мы за время $O(n)$ получаем отсортированный префикс (первые $k$ элементов), а значит за $O(n^2)$ операций отсортируем весь массив целиком. 21 | -------------------------------------------------------------------------------- /content/russian/cs/sorting/sorting-networks.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Сортирующие сети 3 | weight: 10 4 | draft: true 5 | --- 6 | -------------------------------------------------------------------------------- /content/russian/cs/spanning-trees/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Связность и остовные деревья 3 | weight: 22 4 | --- 5 | 6 | Рассмотрим следующую задачу: 7 | 8 | > Авиакомпания содержит $m$ рейсов между $n$ городами, $i$-ый из них обходится в $w_i$ рублей, причём из любого города можно добраться до любого другого. В стране наступил кризис, и нужно отказаться от как можно большего числа из них таким образом, что содержание оставшихся рейсов будет наиболее дешевым. 9 | 10 | Иными словами, нужно найти дерево минимального веса, которое является подграфом данного неориентированного графа. Почему дерево? Потому что в противном случае там был бы цикл, из которого можно удалить какое-то ребро и получить более оптимальный ответ. А если это больше, чем одно дерево, то какие-то две вершины остаются несвязны. 11 | 12 | Такие деревья называют *остовами* (*каркас*, *скелет*; ударение на первый слог, но так мало кто произносит; англ. *minimum spanning tree* — дословно, минимальное покрывающее дерево). 13 | 14 | В этой статье мы рассмотрим алгоритмы нахождения остовных деревьев и классические задачи на них. 15 | -------------------------------------------------------------------------------- /content/russian/cs/spanning-trees/img/safe-edge.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/spanning-trees/img/safe-edge.png -------------------------------------------------------------------------------- /content/russian/cs/spanning-trees/kruskal.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Алгоритм Краскала 3 | prerequisites: 4 | - safe-edge 5 | - /cs/set-structures/dsu 6 | weight: 3 7 | --- 8 | 9 | Другой способ использовать лемму о безопасном ребре — отсортировать все ребра и пытаться добавлять их в изначально пустой остов в порядке возрастания их весов. 10 | 11 | Если очередное ребро соединяет какие-то две уже соединенные вершины, то проигнорируем его. Иначе оно является безопасным, так как оно минимальное из соединяющих какие-то две различные компоненты, и его можно добавить. 12 | 13 | Звучит очень просто: отсортировать все рёбра, пройтись по ним циклом и делать проверку, что вершины в разных компонентах. Но наивная проверка `dfs`-ом от концов всех ребер будет работать за $O(nm)$. Асимптотику можно улучшить до $O(m \log m)$ — до стоимости сортировки ребер — если для проверок использовать [систему непересекающихся множеств](/cs/set-structures/dsu). 14 | 15 | За исключением реализации СНМ, код получается очень коротким: 16 | 17 | ```c++ 18 | struct Edge { 19 | int from, to, weight; 20 | }; 21 | 22 | vector edges; 23 | 24 | sort(edges.begin(), edges.end(), [](Edge a, Edge b) { 25 | return a.weight < b.weight; 26 | }); 27 | 28 | for (auto [a, b, w] : edges) { 29 | // компоненты разные, если лидеры разные 30 | if (p(a) != p(b)) { 31 | // добавим ребро (a, b) 32 | unite(a, b); 33 | } 34 | } 35 | ``` 36 | 37 | Раз остовные деревья являются частным случаем [матроида](/cs/combinatorial-optimization/matroid), то алгоритм Краскала является частным случаем алгоритма Радо-Эдмондса. 38 | -------------------------------------------------------------------------------- /content/russian/cs/spanning-trees/safe-edge.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Лемма о безопасном ребре 3 | weight: 1 4 | --- 5 | 6 | Назовем подграф $T$ графа $G$ *безопасным*, если он является подграфом какого-то минимального остова. 7 | 8 | Назовем ребро безопасным, если при добавлении его в подграф $T$ получившийся подграф $T'$ тоже является безопасным, то есть подграфом какого-то минимального остова. 9 | 10 | *Разрезом* связного графа будем называть подмножество рёбер и вершин, образующих подграф, в котором есть ровно две компоненты связности. Ребро *пересекает* данный разрез, если при его добавлении граф снова становится связным. 11 | 12 | Все алгоритмы для поиска минимального остова опираются на следующее утверждение: 13 | 14 | **Лемма о безопасном ребре.** Рассмотрим произвольный разрез какого-либо подграфа минимального остова. Тогда ребро минимального веса, пересекающее этот разрез, является безопасным. 15 | 16 | **Доказательство:** Рассмотрим какой-то минимальный остов, в котором этого ребра нет. Если его добавить, то образуется цикл, из которого можно удалить ребро не меньшего веса, получив ответ точно не хуже. Противоречие. 17 | 18 | ![](../img/safe-edge.png) 19 | 20 | Получается, что для построения минимального остова мы можем действовать жадно: на каждом шаге добавлять ребро минимального веса, которое увеличивает уже построенную часть остова. Есть несколько способов это сделать, о которых мы поговорим дальше. 21 | 22 | ### Следствия 23 | 24 | - Если веса всех рёбер различны, то остов будет уникален. 25 | - Минимальный остов является также и остовом с минимальным произведением весов рёбер (замените веса всех рёбер на их логарифмы). 26 | - Минимальный остов является также и остовом с минимальным весом самого тяжелого ребра. 27 | - Остовные деревья — частный случай [матроидов](/cs/combinatorial-optimization/matroid). 28 | -------------------------------------------------------------------------------- /content/russian/cs/spanning-trees/spanning-trees-problems.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Проблемы на остовные деревья 3 | draft: true 4 | --- 5 | 6 | 7 | Если вы решаете задачу, где ребра не добавляются, а удаляются, и нужно поддерживать минимальный остов, то можно попробовать решать задачу «с конца» и применить алгоритм Крускала. 8 | -------------------------------------------------------------------------------- /content/russian/cs/string-searching/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Поиск подстроки 3 | part: Строки 4 | weight: 30 5 | --- 6 | 7 | Рассмотрим задачу, которая возникает каждый раз, когда вы делаете `ctrl+f`: 8 | 9 | > Есть большой текст $t$. Нужно найти все вхождения строки $s$ в него. 10 | 11 | Наивное решение со сравнением всех подстрок $t$ длины $|s|$ со строкой $s$ работает за $O(|t| \cdot |s|)$. Если текст большой, то длинные слова в нем искать становится очень долго. 12 | 13 | Однако существует множество способов решить эту задачу за $O(|s| + |t|)$, два самых распространённых и простых из них: через *префикс-функцию* и через *z-функцию* (*примечание: не «зи», а «зет»*). 14 | -------------------------------------------------------------------------------- /content/russian/cs/string-structures/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Строковые структуры 3 | weight: 32 4 | --- 5 | 6 | Автоматы — абстрактные математические объекты, как-то реагирующие на некоторые *события*, или *символы*. 7 | 8 | Автомат определяется начальным состоянием, множеством возможных состояний, множеством символов, а также функцией, которая по паре из текущего состояния и символа определяет, в какое новое состояние должен переходить автомат. 9 | 10 | Автоматы могут описывать много различных процессов и вычислений. Например, компьютер сам по себе является частным случаем реализации автомата: состоянием является содержимое оперативной памяти и регистров, событиями — взаимодействие с пользователем, правилами перехода — архитектура. 11 | 12 | Другим примером являются клеточные автоматы, возможно знакомые читателю по [игре «Жизнь»](https://ru.wikipedia.org/wiki/%D0%98%D0%B3%D1%80%D0%B0_%C2%AB%D0%96%D0%B8%D0%B7%D0%BD%D1%8C%C2%BB) Джона Конвея. В ней состояние и правила переходов автомата определяется состоянием каждой индивидуальной клетки, так, что правила применяются сразу ко всей решетке. 13 | 14 | ![«Ружьё Госпера» в игре «Жизнь»](img/life.gif) 15 | 16 | В этом разделе мы рассмотрим конкретные применения автоматов в контексте строковых задач. 17 | -------------------------------------------------------------------------------- /content/russian/cs/string-structures/img/lcp.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/string-structures/img/lcp.png -------------------------------------------------------------------------------- /content/russian/cs/string-structures/img/life.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/string-structures/img/life.gif -------------------------------------------------------------------------------- /content/russian/cs/string-structures/img/sa-sort.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/string-structures/img/sa-sort.png -------------------------------------------------------------------------------- /content/russian/cs/string-structures/img/trie.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/string-structures/img/trie.png -------------------------------------------------------------------------------- /content/russian/cs/tree-structures/b-tree.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: B-деревья 3 | draft: true 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/cs/tree-structures/img/treap.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/tree-structures/img/treap.png -------------------------------------------------------------------------------- /content/russian/cs/tree-structures/red-black-tree.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Красно-черное дерево 3 | draft: true 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/cs/tree-structures/splay-tree.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Splay-дерево 3 | draft: true 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/cs/trees/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Корневые деревья 3 | weight: 23 4 | --- 5 | 6 | Дерево называется *корневым*, если оно ориентировано, и из какой-то вершины (называемой *корнем*) можно попасть во все остальные. 7 | 8 | Примеры корневых деревьев: 9 | 10 | - наследование классов в языках программирования (если множественное наследование запрещено), 11 | - дерево факторизации числа на простые (в общем случае не уникальное), 12 | - иерархия в какой-нибудь организации, 13 | - дерево парсинга математичеких выражений. 14 | 15 | Задачи на корневые деревья весьма бесполезны в реальной жизни, но зато очень интересны с алгоритмической точки зрения, и поэтому часто встречаются на олимпиадах по программированию. 16 | -------------------------------------------------------------------------------- /content/russian/cs/trees/img/centroid.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/trees/img/centroid.jpg -------------------------------------------------------------------------------- /content/russian/cs/trees/img/heavy-light.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/trees/img/heavy-light.png -------------------------------------------------------------------------------- /content/russian/cs/trees/img/lca.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/trees/img/lca.png -------------------------------------------------------------------------------- /content/russian/cs/trees/img/tour.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/cs/trees/img/tour.png -------------------------------------------------------------------------------- /content/russian/cs/trees/merging.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Метод переливаний 3 | draft: true 4 | --- 5 | 6 | 7 | Рассмотрим задачу, дано корневое дерево вершины которого раскрашенны в 8 | цвета. Для каждой вершины нужно посчитать количество различных цветов 9 | в её поддереве. 10 | 11 | Что-бы узнать количество различных достаточно использовать std::set или 12 | std::unordered_set. Мы хотим для каждой вершины, в какой-то момент 13 | времени, получить такой set. 14 | 15 | Ответ для листьев получается очевидным образом. Теперь, пусть у нас есть 16 | структура-ответ для всех её сыновей. Обединив их все мы получим искомую 17 | структуру для нашей вершины. Но обединение будет работать за суммарный 18 | размер поддерева. Воспользуемся идеей переливания от меньшего к 19 | большему. Выберем самого большого сына и скопируем себе его 20 | структуру (следует хранить не сам set, а указатель на него). Теперь 21 | пройдемся по элементам set-ов всех остальных детей и добавим их в наш 22 | set. 23 | 24 | ### Оценим время работы 25 | 26 | Рассмотрим вершину $v$. Пусть сейчас она находится в структуре, которая 27 | отвечает за $k$ вершин. Если мы посмотрели на вершину $v$, значит 28 | сейчас мы переливаем эту структуру в другую, следовательно, размер 29 | структуры, в которой находится $v$ хотя бы $2 \* k$, следовательно, не 30 | может произойти больше $O(log(N))$ переливаний одной вершины, где $N$ 31 | - количество вершин во всем дереве. Тогда понятно, что всего переливаний 32 | будет $O(Nlog(N)$, и в зависимости от выбора set-а или unordered_set-а 33 | мы получим ассимптотику $- O(Nlog^2(N))$ или $O(Nlog(N))$. -------------------------------------------------------------------------------- /content/russian/cs/trees/tree-dynamic.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: ДП на деревьях 3 | draft: true 4 | --- 5 | 6 | ### Идея 7 | 8 | Динамическое программирование, заключается в том, что мы решаем большую 9 | задачу, разбивая ее на маленькие, что же такое маленькое подзадачи в 10 | деревьях, давайте считать, что если мы решаем задачу для какой-то 11 | вершины, то маленькие задачи - поддеревья этой вершины. 12 | 13 | ### Пример задачи 14 | 15 | Пусть задано взвешенное дерево, с весами $w_{i, j}$, где $i$ и $j$ — 16 | вершины дерева, соединённые ребром. Пусть вес паросочетания - сумма 17 | весов, написанных на ребрах. Необходимо составить 18 | [паросочетание](паросочетание "wikilink") 19 | максимального веса в этом дереве. 20 | 21 | ### Решение 22 | 23 | Пусть $dp_{i, 0}$ - максимальное паросочетание в поддереве $i$-й 24 | вершины, если мы еще не брали ребро из $i$ вершины(так как 25 | рассматривается поддерево, то это ребро строго в одного из 26 | сыновей), $dp_{i, 1}$ — если взяли, тогда, как посчитать 27 | $dp_{i, 0}$ для вершины, $dp_{i, 0} = \\sum\\limits_{v \\in sons(i)} 28 | max(dp_{v, 0}, dp_{v, 1})$, так как если мы не берем ребро из $i$ 29 | вершины вниз, то мы можем взять любой ответ для сыновей. $dp_{i, 30 | 1} = max_{j \\ \\in \\ sons(i)} ((\\sum\\limits_{v \\in sons(i), v \!= 31 | j} max(dp_{v, 0}, dp_{v, 1})) + w_{i, j} + dp_{j, 0})$, так как мы 32 | точно должны взять ребро из $i$ в какого-то сына и для этого сына $x$ 33 | мы имеем право взять только $dp_{x, 0}$, а вот для всех остальных 34 | вершин можем выбрать, что хотим 35 | 36 | ### Другие задачи 37 | 38 | - [Сумма длин всех путей в 39 | дереве](Сумма_длин_всех_путей_в_дереве "wikilink") 40 | - [Диаметр](Диаметр "wikilink") -------------------------------------------------------------------------------- /content/russian/dl/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Глубокое обучение 3 | menuTitle: DL 4 | weight: 4 5 | draft: true 6 | --- 7 | -------------------------------------------------------------------------------- /content/russian/dl/advanced/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Продвинутые методы 3 | weight: 6 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/dl/advanced/distillation.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Дистилляция 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/advanced/metric-learning.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Metric learning 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/advanced/transfer-learning.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Transfer learning 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/aux/01-intro/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Презентация про градиентный спуск 3 | outputs: 4 | - Reveal 5 | --- 6 | -------------------------------------------------------------------------------- /content/russian/dl/aux/01-intro/slides.ru.md: -------------------------------------------------------------------------------- 1 | # Глубокое обучение 2 | 3 | Лекция 1 4 | 5 | Сергей Слотин\ 6 | 12 февраля, 2021 7 | 8 | --- 9 | 10 | ## Моделирование 11 | 12 | * Пытаемся найти функцию между фичами ($X$) и целевой переменной ($y$) 13 | * Пользуемся предположениями о том, как должно выглядеть идеальное решение. 14 | Например: «$y = f_k(x) = kx + \epsilon$ для какого-то $k$» 15 | * После этого мы вводим какую-то **функцию потерь** (например, $l(y') = (y'-y)^2$) и подбираем параметры модели, которые минимизируют её ожидаемое значение. 16 | 17 | --- 18 | 19 | ![](https://sqream.com/wp-content/uploads/2017/03/cpu_vs_gpu-11.png) 20 | 21 | --- 22 | 23 | ![](https://ml4a.github.io/images/figures/non_convex_function.png) -------------------------------------------------------------------------------- /content/russian/dl/aux/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Дополнительные материалы 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/cv/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Компьютерное зрение 3 | menuTitle: CV 4 | weight: 4 5 | --- 6 | -------------------------------------------------------------------------------- /content/russian/dl/cv/cnn.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Свёрточные сети 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/cv/processing.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Обработка изображений 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/cv/segmentation.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Сегментация 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/fundamentals/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Основы 3 | weight: 1 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/dl/fundamentals/backprop.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Backpropagation 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/fundamentals/loss.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Функции потерь 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/generative/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Генеративные модели 3 | weight: 3 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/dl/generative/autoencoder.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Автоэнкодеры 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/generative/flow.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Flow-based модели 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/generative/gan.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Generative Adversarial Networks 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/generative/vae.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Вариационный автоэнкодер 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/layers/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Общие слои 3 | weight: 2 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/dl/layers/dropout.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Dropout 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/layers/linear.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Линейный слой 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/layers/relu.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: ReLU 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/layers/softmax.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Softmax 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/nlp/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Компьютерная лингвистика 3 | menuTitle: NLP 4 | weight: 5 5 | --- 6 | -------------------------------------------------------------------------------- /content/russian/dl/nlp/attention.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Механизм Attention 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/nlp/dialogue.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Диалоговые системы 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/nlp/rnn.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Рекуррентные сети 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/nlp/seq2seq.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Seq2seq 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/dl/nlp/tokenization.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Токенизация 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Математика 3 | menuTitle: Math 4 | weight: 2 5 | draft: true 6 | --- 7 | -------------------------------------------------------------------------------- /content/russian/math/algebra/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Алгебра 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/algebra/complex-numbers.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Комплексные числа 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/algebra/linear-algebra/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Линейная алгебра 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/algebra/polynomials/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Многочлены 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/algebra/Свойства_Матриц.md: -------------------------------------------------------------------------------- 1 | ## Сложение 2 | 3 | 1\) Коммутативность $A + B = B + A$ 4 | 5 | 2\) Ассоциативность $(A + B) + C = A + (B + C)$ 6 | 7 | 3\) $A + 0 = A$, нулевая матрица - матрица заполненная нулями, того же 8 | размера, что и $A$ 9 | 10 | 4\) $(-A) + A = 0$ 11 | 12 | ## Умножение на число 13 | 14 | 1\) $\\lambda(A + B) = A \\cdot \\lambda + B \\cdot \\lambda$ 15 | 16 | 2\) $(\\lambda + \\mu) \\cdot A = \\lambda \\cdot A + \\mu \\cdot B$ 17 | 18 | 3\) $(\\lambda \\cdot \\mu) \\cdot A = \\lambda\\cdot (\\mu \\cdot A);$ 19 | 20 | 4\) $A \\cdot 1 = A$ 21 | 22 | ## Транспонирование 23 | 24 | 1)$(A^T)^T = A$ 25 | 26 | 2)$(A + B)^T = A^T + B^T$ 27 | 28 | 3)$(A \\cdot c)^T = A^T \\cdot c$ 29 | 30 | ## Умножение 31 | 32 | 1)$A \\cdot (B + C) = A \\cdot B + A \\cdot C$ 33 | 34 | 2)$(A \\cdot B) \\cdot C = A \\cdot (B \\cdot C)$ 35 | 36 | 3)$A \\cdot B \\neq B \\cdot A$ 37 | 38 | Пример : 39 | 40 | $A = \\begin{pmatrix} 41 | 42 | ` 0& 1\\` 43 | ` 0& 0` 44 | 45 | \\end{pmatrix}, B = \\begin{pmatrix} 46 | 47 | ` 0& 0\\` 48 | ` 1& 0` 49 | 50 | \\end{pmatrix}, A \\cdot B = \\begin{pmatrix} 51 | 52 | ` 1& 0\\` 53 | ` 0& 0` 54 | 55 | \\end{pmatrix}, B \\cdot A = \\begin{pmatrix} 56 | 57 | ` 0& 0\\` 58 | ` 0& 1` 59 | 60 | \\end{pmatrix}$ -------------------------------------------------------------------------------- /content/russian/math/calculus/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Математический анализ 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/calculus/derivative.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Производные 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/calculus/integral.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Интегралы 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/combinatorics/factorials/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Факториалы 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/combinatorics/factorials/factorial-number-system.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Факториальная система счисления 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/combinatorics/Бином_Ньютона.md: -------------------------------------------------------------------------------- 1 | ## Бином Ньютона 2 | 3 | Рассмотрим разложение выражения $(a+b)^n$. Докажем, что коэффициент при 4 | $a^kb^{n-k}$ равен $C_n^k$. Действительно 5 | $(a+b)^n=(a+b)(a+b)\\cdots(a+b)\~$($n$ раз). Чтобы получить член 6 | $a^kb^{n-k}$ надо из $k$ скобок выбрать $a$, а из остальных $b$. Как мы 7 | уже знаем, это можно сделать $C_n^k$. Значит, 8 | $(a+b)^n=\\sum\\limits_{k=0}^nC_n^ka^kb^{n-k}$. 9 | 10 | Из этого следует, что коэффициенты при разложении $(a+b)^n$ являются 11 | строкой треугольника Паскаля. -------------------------------------------------------------------------------- /content/russian/math/combinatorics/Биномиальные_коэффициенты.md: -------------------------------------------------------------------------------- 1 | ## Определение 2 | 3 | Посчитаем количество способов выбрать $k$ элементов из $n$ различных 4 | (называется числом сочетаний из $n$ по $k$ и обозначается $C_n^k$). 5 | 6 | ## Первый способ 7 | 8 | Точно так же на первое место мы можем поставить любой из $n$ элементов, 9 | на второе — любой из $n - 1$ оставшихся, на $k$-е место останется $n - 10 | k + 1$ вариант, то есть всего вариантов получится 11 | $n\\cdot(n-1)\\cdot\\ldots\\cdot(n-k+1)=\\frac{n\!}{(n-k)\!}$. Заметим, 12 | что так мы посчитали число _упорядоченных_ наборов из $k$ элементов и 13 | чтобы получить количество способов выбрать $k$ элементов из $n$ нужно 14 | поделить результат на $k\!$, ведь, как было установлено ранее, именно 15 | столько есть спобосов упорядочить $k$ элементов. В итоге получается 16 | $C_n^k=\\frac{n\!}{k\!(n-k)\!}$ 17 | 18 | ## Второй способ 19 | 20 | Есть и другой способ подсчета $C_n^k$ для $0 \< k \< n$. Посмотрим на 21 | первый элемент. Если он входит в набор, то осталось выбрать $k-1$ из 22 | $n-1$ оставшихся. Иначе нужно выбрать $k$ из $n-1$ оставшихся. Значит, 23 | $C_n^k=C_{n-1}^{k}+C_{n-1}^{k-1}$. Так можно найти все $C_n^k$ до 24 | какого-то $n$ за $O(n^2)$. 25 | 26 | ## Треугольник Паскаля 27 | 28 | Таким образом, $C_n^k$ легко представлять в виде бесконечного 29 | треугольника, где на сторонах стоят 1, а остальные числа равны 30 | сумме двух верхних. Легко видеть, что $C_n^k$ это $k$-е число в строке 31 | номер $n$. Это называют треугольником Паскаля. -------------------------------------------------------------------------------- /content/russian/math/combinatorics/Числа_Каталана.md: -------------------------------------------------------------------------------- 1 | ## Определение 2 | 3 | Посчитаем количество правильных скобочных последовательностей (ПСП). 4 | Интуитивно понятно, что это, но формально они определятюся так: - 5 | Пустая последовательность является ПСП - Если $A$ является ПСП, то 6 | $(A)$ является ПСП - Если $A$ и $B$ являются ПСП, то $AB$ является ПСП. 7 | 8 | Теперь, посчитаем количество ПСП с $2n$ скобками. Это называется числами 9 | Каталана и обозначается $C_n$. 10 | 11 | ## Формула 12 | 13 | Рассмотрим первое место, где разность количества открывающих и 14 | закрывающих скобок впервые становится равна 0 и часть ПСП до 15 | этого места обозначим $(A)$, а часть после обозначим $B$. Понятно, что 16 | $A$ и $B$ являются ПСП меньшего размера (возможно, пустыми). 17 | 18 | Теперь $C_n$ посчитать легко, перебирая размер $A$. 19 | 20 | $C_0=1$ 21 | 22 | $C_n=C_0C_{n-1}+C_1C_{n-2}+\\ldots+C_{n-1}C_0$ 23 | 24 | ## Альтернативные формулы 25 | 26 | $C_n = \\frac{1}{n+1}{2 n \\choose n} = \\frac{1}{2 n+1}{2 n+1 \\choose 27 | n} = \\binom{2 n}{n} - \\binom{2 n}{n-1}$ 28 | 29 | Другими словами, число Каталана $C_n$ равно разности центрального 30 | биномиального коэффициента и соседнего с ним в той же строке 31 | треугольника Паскаля. -------------------------------------------------------------------------------- /content/russian/math/geometry/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Геометрия 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/number-theory/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Теория чисел 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/number-theory/Диофантово_уравнение.md: -------------------------------------------------------------------------------- 1 | Диофантовым уравнением называется уравнение от двух целочисленных 2 | переменных $x, y$ вида $$ax + by = c$$ 3 | 4 | Такое уравнение задает прямую для вещественных чисел, но в случае 5 | натуральных чисел задаваемое множество не такое понятное. 6 | 7 | Например, если $c \\not\\equiv 0 \\pmod{gcd(a, b)}$, то решений точно 8 | нет, ведь левая часть делится на НОД, а правая --- нет. 9 | 10 | Оказывается, в остальных случаях решение существует. Достаточно перейти 11 | к уравнению $a'x + b'y = c'$, где $a' = \\frac{a}{gcd(a, b)}$ и 12 | $gcd(a', b') = 1$, а затем воспрользоваться [расширенным алгоритмом 13 | Евклида](Расширенный_алгоритм_Евклида "wikilink") для решения 14 | уравнения $a'x + b'y = 1$. Полученные решения необходимо будет 15 | умножить на $c$. 16 | 17 | Чтобы получить все решения, достаточно будет делать переход $(x, y) \\to 18 | (x + b' \\cdot k, y - a' \\cdot k), k \\in \\mathbb{Z}$ 19 | 20 | [Категория: Конспекты](Категория:_Конспекты "wikilink") -------------------------------------------------------------------------------- /content/russian/math/number-theory/Теорема_Эйлера.md: -------------------------------------------------------------------------------- 1 | ## Теорема Эйлера 2 | 3 | {{ Утверждение |Название=Теорема Эйлера |Показать название=1 4 | |Утверждение=Пусть $a$ взаимно просто с $m$. Тогда 5 | $a^{\\varphi(m)} \\equiv 1 \\pmod{m}$. |Доказательство=Пусть $x_1, 6 | x_2, \\ldots, x_{\\varphi(m)}$ — все натуральные числа, меньшие $m$ и 7 | взаимно простые с $m$. Рассмотрим следующий набор чисел: $ax_1, ax_2, 8 | \\ldots, ax_{\\varphi(m)}$ (все числа рассматриваются по модулю $m$). 9 | Число $a$ обратимо по модулю $m$, так как взаимно просто с ним. Из 10 | этого следует, что для $i \\neq j$: $ax_i \\neq ax_j$. Также 11 | заметим, что все эти числа обратимы по модулю $m$ как произведение 12 | двух обратимых (каждое из $x_i$ также обратимо по модулю $m$, так как 13 | взаимно просто с ним). Следовательно, множество чисел $x_1, x_2, 14 | \\ldots, x_{\\varphi(m)}$ совпадает с множеством чисел $ax_1, ax_2, 15 | \\ldots, ax_{\\varphi(m)}$. Значит $x_1 x_2 \\ldots x_{\\varphi(m)} 16 | \\equiv a^{\\varphi(m)} x_1 x_2 \\ldots x_{\\varphi(m)} \\pmod{m}$. 17 | Осталось заметить, что произведение $x_1 x_2 \\ldots 18 | x_{\\varphi(m)}$ также обратимо, из чего получаем $a^{\\varphi(m)} 19 | \\equiv 1 \\pmod{m}$. }} 20 | 21 | [Категория:Конспект](Категория:Конспект "wikilink") [Категория:Теория 22 | чисел](Категория:Теория_чисел "wikilink") -------------------------------------------------------------------------------- /content/russian/math/probability/bayes.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Теорема Байеса 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/probability/birthday-paradox.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Парадокс дней рождений 3 | --- 4 | 5 | Пусть $f(n, d)$ это вероятность того, что в группе из $n$ человек ни у кого не совпали дни рождения. 6 | Будем считать, что дни рождения распределены независимо и равномерно в промежутке от $1$ до $d$. 7 | 8 | $$ 9 | f(n, d) = (1-\frac{1}{d}) \times (1-\frac{2}{d}) \times ... \times (1-\frac{n-1}{d}) 10 | $$ 11 | 12 | Попытаемся оценить $f$: 13 | 14 | $$ 15 | \begin{aligned} 16 | e^x & = 1 + x + \frac{x^2}{2!} + \ldots & \text{(ряд Тейлора для экспоненты)} 17 | \\\ & \simeq 1 + x & \text{(аппроксимация для $|x| \ll 1$)} 18 | \\\ e^{-\frac{n}{d}} & \simeq 1 - \frac{n}{d} & \text{(подставим $\frac{n}{d} \ll 1$)} 19 | \\\ f(n, d) & \simeq e^{-\frac{1}{d}} \times e^{-\frac{2}{d}} \times \ldots \times e^{-\frac{n-1}{d}} & 20 | \\\ & = e^{-\frac{n(n-1)}{2d}} & 21 | \\\ & \simeq e^{-\frac{n^2}{2d}} & 22 | \end{aligned} 23 | $$ 24 | 25 | Из формулы видно, что вероятность $\frac{1}{2}$ достигается при $n \approx \sqrt{d}$ и в этой точке изменяется быстро. 26 | 27 | **Следствие**. В мультимножество нужно добавить $O(\sqrt{n})$ случайных чисел от 1 до $n$, чтобы какие-то два совпали. 28 | -------------------------------------------------------------------------------- /content/russian/math/probability/distributions.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Вероятностные распределения 3 | weight: 1 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/math/probability/expectation.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Математическое ожидание 3 | weight: 2 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/math/probability/limit-theorems/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Предельные теоремы 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/probability/markov-chains.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Марковские цепи 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/probability/processes.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Случайные процессы 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/math/probability/variance.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Дисперсия 3 | weight: 3 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/math/probability/Вероятность.md: -------------------------------------------------------------------------------- 1 | Пусть есть некий эксперимент, исход которого не вполне однозначен. 2 | Множество всех возможных результатов этого эксперимента(будем 3 | называть его $\\omega$) называют множеством элементарных исходов. 4 | Всякое подмножество $A \\in \\omega$ называют событием. Функцию $P : 5 | 2^{\\omega} \\to \[0,1\]$, удовлетворяющую следующим свойствам: 6 | 7 | (a) $P(\\omega) = 1$ 8 | 9 | (b) $A \\cap B = \\varnothing \\rightarrow P(A \\cup B) = P(A) + P(B)$ 10 | (правило суммы или аддитивность) 11 | 12 | называют вероятностной мерой, а значение $P(A)$ вероятностью события 13 | $A$. -------------------------------------------------------------------------------- /content/russian/math/probability/Матожидание.md: -------------------------------------------------------------------------------- 1 | Математическим ожиданием случайной величины $X$, которая принимает 2 | значения $x_1, x_2, \\ldots$ называется 3 | 4 | $ E\[X\] = \\sum_{x \\in S} p_S(x) \\cdot x $ 5 | 6 | Самое главное для нас свойство — ожидание линейно: 7 | 8 | $$ \\begin{align\*} E\[X+Y\] & = \\sum_{x, y} (x+y) p(x, y) \\\\ & = 9 | \\sum_{x, y} x p(x, y) + \\sum_{x, y} y p(x, y) \\\\ & = \\sum_x x 10 | p(x) \\sum_y p(y) + \\sum_y y p(y) \\sum_x p(x) \\\\ & = \\sum_x x 11 | p(x) + \\sum_y y p(y) \\\\ & = E\[X\] + E\[Y\] \\end{align\*} $$ 12 | 13 | Акцентируем внимание: $X$ и $Y$ вообще не важно какие. Возможно, они 14 | связаны как-то очень сложно, но это не важно. Как мы потом, увидем, 15 | это свойство очень упрощает вычисление матожиданий каких-то очень 16 | сложных шняг. 17 | 18 | Также, в частности его можно домножать на константу. -------------------------------------------------------------------------------- /content/russian/math/probability/Парадокс_Монти-холла.md: -------------------------------------------------------------------------------- 1 | # Парадокс Монти Холла 2 | 3 | ## Задача 4 | 5 | Вы участвуете в игре, в которой вам нужно выбрать одну из трёх дверей. 6 | За одной из дверей спрятан автомобиль, за двумя другими - козы. Вы 7 | выбираете одну из дверей (например 1-ую) после этого ведущий, 8 | который знает, где находится автомобиль, открывает одну из 9 | оставшихся дверей (например 3-ю) за которой находится коза. После 10 | этого ведущий предлагает вам изменить свой выбор и выбрать дверь номер 11 | 2. Увеличатся ли ваши шансы выиграть автомобиль, если вы примете 12 | предложение ведущего и измените свой выбор? 13 | 14 | ## Интуиция 15 | 16 | У нас две двери - за одной - коза, вероятность - $\\frac{1}{2} 17 | \\Rightarrow $ без разницы. 18 | 19 | ## Решение 20 | 21 | Пусть событие $A_{i}$ заключается в том, что автомобиль находится за 22 | $i$-й дверью, событие $B$ - в том, что ведущий открыл 3-ю дверь. 23 | $P(A_{i}$ = 1 Если автомобиль изначально находился за 1-й дверью 24 | (которую мы выбрали), то ведущий откроет любую из оставшихся 25 | дверей случайным образом, т.е. $P(B|A_{1}) = 1$. В 2 других же 26 | случаях условные вероятности равны: $P(B|A_{2}) = 1$ и $P(B|A_{3}) 27 | = 0$. Теперь с применим формулу Байеса и формулу полной вероятности для 28 | $B : P(A_{2}|B) = \\frac{P(B|A_{2})𝑃(A_{2})}{P(B|A_{1})P(A_{1}) + 29 | P(B|A_{2})P(A_{2}) + P(B|A_{3})P(A_{3})} = 30 | \\frac{\\frac{1}{3}}{\\frac{1}{6} + \\frac{1}{3}} = \\frac{2}{3}$ 31 | 32 | Таким образом, выгоднее изменить свой выбор. -------------------------------------------------------------------------------- /content/russian/math/probability/Случайная_величина.md: -------------------------------------------------------------------------------- 1 | Пусть есть некий эксперимент, исход которого не вполне однозначен. 2 | Множество всех возможных результатов этого эксперимента(будем 3 | называть его $\\omega$) называют множеством элементарных исходов. 4 | Всякое подмножество $A \\in \\omega$ называют событием. Функцию $P : 5 | 2^{\\omega} \\to \[0,1\]$, удовлетворяющую следующим свойствам: 6 | 7 | (a) $P(\\omega) = 1$ 8 | 9 | (b) $A \\cap B = \\varnothing \\rightarrow P(A \\cup B) = P(A) + P(B)$ 10 | (правило суммы или аддитивность) 11 | 12 | называют вероятностной мерой, а значение $P(A)$ вероятностью события 13 | $A$. -------------------------------------------------------------------------------- /content/russian/math/probability/Условная_вероятность.md: -------------------------------------------------------------------------------- 1 | ## Условная вероятность 2 | 3 | Условной вероятностью события $A$ при условии $B$ называется число 4 | $P(A|B) = \\frac{P(A \\cap B)}{P(B)}$. 5 | 6 | ## Правило произведения 7 | 8 | Равенство часто переписывают в виде $P(A \\cap B) = P(B) \\cdot P(A|B)$ 9 | и называют правилом произведения. 10 | 11 | ## Формула полной вероятности 12 | 13 | Пусть $\\omega = A_{1} \\cup A_{2} \\dots \\cup A_{n}$ и $\\forall i, 14 | j A_{i} \\cap A_{j} = \\varnothing$. Тогда : 15 | 16 | $\\forall P(B) = \\sum \\limits_{i} P(B|A_{i}) \\cdot P(A_{i})$ 17 | 18 | ## Независимые события 19 | 20 | С точки зрения вычисления вероятностей независимость события $A$ от 21 | события $B$ означает, что вероятность $A$ не меняется от того 22 | произошло событие $B$ или нет. Формализовать эту идею позволяет 23 | условная вероятность. Событие $A$ не зависит от события $B$, если 24 | $P(A|B) = P(A)$, что по определению условной вероятности можно 25 | переписать в виде $P(A \\cap B) = P(A) \\cdot P(B)$. Это 26 | равенство и принимают в качестве определения независимости. Если 27 | события не являются независимыми, то говорят, что они зависимые. 28 | 29 | ## Формула Байеса 30 | 31 | $P(A|B) = \\frac{P(B|A) \\cdot P(A)}{P(B)}$, так как $P(A|B) \\cdot P(B) 32 | = P(A \\cap B) = P(B|A) \\cdot P(A)$ -------------------------------------------------------------------------------- /content/russian/ml/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Машинное обучение 3 | menuTitle: ML 4 | weight: 3 5 | hideSidebar: true 6 | ignoreIndexing: true 7 | draft: true 8 | --- 9 | -------------------------------------------------------------------------------- /content/russian/ml/data-wrangling/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Работа с данными 3 | weight: 2 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/ml/data-wrangling/matplotlib.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Построение графиков (Matplotlib) 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/ml/data-wrangling/numpy.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Векторные данные (NumPy) 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/ml/data-wrangling/pandas.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Табличные данные (Pandas) 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/ml/dimensionality-reduction/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Уменьшение размерности 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/ml/dimensionality-reduction/img/pca-sample.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/ml/dimensionality-reduction/img/pca-sample.png -------------------------------------------------------------------------------- /content/russian/ml/dimensionality-reduction/img/pca.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/ml/dimensionality-reduction/img/pca.png -------------------------------------------------------------------------------- /content/russian/ml/dimensionality-reduction/img/tsne-sample.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/ml/dimensionality-reduction/img/tsne-sample.png -------------------------------------------------------------------------------- /content/russian/ml/dimensionality-reduction/t-sne.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: T-SNE 3 | --- 4 | 5 | Это гораздо более сложный нелинейный алгоритм. Он очень крут для 6 | визуализации данных, и работает только с переводом в 2D и 3D. 7 | 8 | Внутри там происходит что-то физическое - элементы будто разлетаются, 9 | причем чем дальше они друг от друга, тем сильнее они друг друга 10 | оттакливают. 11 | 12 | ![](../img/tsne-sample.png) 13 | 14 | ### Плюсы t-SNE {#плюсы-t-sne .unnumbered} 15 | 16 | - отлично визуализирует (2D, 3D) данные 17 | 18 | - физически разносит разные точки дальше друг от друга 19 | 20 | - сильно разные точки не могут в конце оказаться рядом 21 | 22 | ### Недостатки t-SNE {#недостатки-t-sne .unnumbered} 23 | 24 | - недетерминированность, результат меняется при каждом запуске 25 | 26 | - координаты ничего не значат сами по себе 27 | 28 | - нельзя легко добавить новые данные 29 | 30 | - долго работает 31 | 32 | - уменьшает только до 2 и 3 размерности -------------------------------------------------------------------------------- /content/russian/ml/ensemble/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Ансамблирование 3 | weight: 4 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/ml/ensemble/bagging.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Бэггинг 3 | --- 4 | 5 | ## Бэггинг 6 | 7 | Из исходных данных строим различные выборки(повторение элементов 8 | допустимо), для каждой применяется одинаковый алгоритм, все ответы 9 | усредняются. Очень часто для этого используют деревья. Много деревьев на 10 | случайных подвыборках -- RandomForest. -------------------------------------------------------------------------------- /content/russian/ml/ensemble/boosting.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Бустинг 3 | --- 4 | 5 | ## Бустинг 6 | 7 | Берём исходные данные, строим на них модель, получаем ответы. 8 | Зафиксируем ошибки модели, добавим их в исходные данные, можем добавить 9 | веса ошибкам. Опять строим модель, получаем ответы, считаем ошибки, 10 | добавляем в данные. И т д, пока не сделаем фиксированное число итераций 11 | бустинга или пока ошибка не станет достаточно маленькой. 12 | -------------------------------------------------------------------------------- /content/russian/ml/ensemble/img/tree.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/ml/ensemble/img/tree.jpg -------------------------------------------------------------------------------- /content/russian/ml/ensemble/stacking.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Стэкинг 3 | --- 4 | 5 | ## Стэккинг 6 | 7 | Возьмем несколько алгоритмов, KNN, DecisionTree, SVN и применим простой 8 | алгоритм принятия решений, например логистическую регрессию. Данные на 9 | вход одни и те же, алгоритмы разные. 10 | -------------------------------------------------------------------------------- /content/russian/ml/fundamentals/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Общие понятия 3 | weight: 1 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/ml/fundamentals/img/poly16.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/ml/fundamentals/img/poly16.png -------------------------------------------------------------------------------- /content/russian/ml/fundamentals/img/poly3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/ml/fundamentals/img/poly3.png -------------------------------------------------------------------------------- /content/russian/ml/fundamentals/overfitting.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Переобучение и валидация 3 | --- 4 | 5 | Рассмотрим простую функцию $f(x) = 3x^3 - 2x^2 + x + \varepsilon(x)$: 6 | 7 | Давайте попробуем приблизить эту функцию многочленом третьей степени: 8 | 9 | ![](../img/poly3.png) 10 | 11 | Видно, что мы получили довольно хорошее приближение исходной функции 12 | 13 | Попробуем увеличить степень нашей модели до шестнадцати: 14 | 15 | ![](../img/poly16.png) 16 | 17 | Видно, что модель стала хуже предсказывать исходную зависимость, но при 18 | этом на тренировочном множестве выдает идеальные ответы. 19 | 20 | Мы столкнулись с проблемой **переобучения (overfitting)**. 21 | 22 | ## Разбиение на обучающую и тестовую выборку и кросс-валидация 23 | 24 | Как узнать, находит ли исходную зависимость наша модель или 25 | переобучается? 26 | 27 | Обычно пользуются одним из двух подходов: 28 | 29 | 1. **Разбиение на обучающую и тестовую выборку (train test split)** 30 | 31 | Прежде чем обучать модель, разобьем исходное тренировочное множество 32 | на обучающую и валидационную (тестовую) выборки. 33 | 34 | Теперь, если мы обучим модель на обучающей выборке, то сможем 35 | сравнить значение функции потерь на валидационной выборке, объекты 36 | из которой модель не видела при обучении, и на обучающей. 37 | 38 | Если эти значения сильно отличаются, то можно говорить о 39 | переобучении нашей модели. 40 | 41 | 2. **Кросс-валидация** Разобьем исходное тренировочное множество на $k$ 42 | примерно равных частей. Теперь поочередно обучим $k$ моделей на 43 | $k - 1$, каждый раз выкидывая новую часть. Если мы посчитаем функцию 44 | ошибки для каждой модели на частях, которые не были включены при 45 | обучении, а затем усредним, то получим более объективное значение 46 | функции ошибки. 47 | -------------------------------------------------------------------------------- /content/russian/ml/models/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Модели 3 | weight: 3 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/ml/models/linear-models/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Линейные модели 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/ml/models/linear-models/img/sigmoid.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/ml/models/linear-models/img/sigmoid.png -------------------------------------------------------------------------------- /content/russian/ml/models/polynomial.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Приближение функции многочленами 3 | --- 4 | 5 | 1. Допустим, у нас есть функция от одной переменной $f(x)$. 6 | 7 | 2. Мы знаем ее значения на каком-то множестве точек (назовём его 8 | **тренировочным множеством**) c некоторым отклонением (шумом) 9 | $\varepsilon(x)$ 10 | 11 | 3. Хотим научиться восстанавливать (хотя бы приблизительно) эту 12 | функцию. 13 | 14 | Мы хотим найти набор коэффициентов 15 | $(\overline a_0, \overline a_1, \dots, \overline a_n)$, которые 16 | \<\<приближают>\> исходную функцию. Пусть 17 | $$P(x) = \overline a_0 + \overline a_1 x + \overline a_2 x^2 + \dots + \overline a_n x^n \approx f(x)$$ 18 | 19 | Из-за того, что значения из тренировочного множества неидеально 20 | приближают исходную функцию, мы не можем точно определить искомый набор 21 | коэффициентов. 22 | 23 | Эта проблема подводит нас к новому определению. Введём новую функцию 24 | $L(P)$, с помощью которой будем определять, насколько хорошо наша 25 | \<\<модель>\> $P(x)$ приближает исходную функцию $f(x)$. 26 | 27 | Назовем $L(P)$ **функцией ошибки** или **функцией потерь**. Будем 28 | считать, что чем меньше $L(P)$, тем лучше наша \<\<модель>\> приближает 29 | $f(x)$. 30 | 31 | Таким образом, минимизируя $L(P)$ будем получать наилучшее приближение 32 | функции $f(x)$ 33 | 34 | Рассмотрим самые часто используемые функции потерь: 35 | $$L(P) = \frac{1}{n}\sum^n_{i=0} (P(x_i) - f(x_i))^2 \hspace{10pt} \text{--- MSE}$$ 36 | $$L(P) = \sqrt{\frac{1}{n}\sum^n_{i=0} (P(x_i) - f(x_i))^2} \hspace{10pt} \text{--- RMSE}$$ 37 | $$L(P) = \frac{1}{n}\sum^n_{i=0} |P(x_i) - f(x_i)| \hspace{10pt} \text{--- L1 loss}$$ 38 | -------------------------------------------------------------------------------- /content/russian/ml/preprocessing/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Препроцессинг 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/ml/problems/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Задачи и метрики 3 | weight: 1 4 | --- 5 | 6 | В этом разделе мы рассмотрим различные типы задач, которые встречаются в машинном обучении. 7 | -------------------------------------------------------------------------------- /content/russian/ml/problems/img/agglomerative.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/ml/problems/img/agglomerative.jpg -------------------------------------------------------------------------------- /content/russian/ml/problems/img/clustering.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/ml/problems/img/clustering.png -------------------------------------------------------------------------------- /content/russian/ml/problems/img/dbscan.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/ml/problems/img/dbscan.png -------------------------------------------------------------------------------- /content/russian/ml/problems/img/errors.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/ml/problems/img/errors.png -------------------------------------------------------------------------------- /content/russian/ml/problems/img/k-means.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/content/russian/ml/problems/img/k-means.png -------------------------------------------------------------------------------- /content/russian/ml/problems/ranking.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Ранжирование 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/ml/problems/regression.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Регрессия 3 | --- 4 | 5 | Еще одним типом является **регрессия**. 6 | 7 | Например, можно рассмотреть такую задачу: мы хотим по росту родителей 8 | определить насколько высоким может быть их ребёнок. Действительно, как 9 | правило, есть зависимость, что у высоких родителей дети тоже имеют 10 | высокий рост и наоборот. 11 | 12 | Т.е. от классификации задача регрессии отличается тем, что тут целевая 13 | переменная --- вещественное число. 14 | 15 | **Обучающей выборкой** в данной задаче будет набор троек: (рост родителя 16 | №1, рост родителя №2, рост ребёнка). 17 | 18 | **Тестовой выборкой** --- набор двоек: рост родителя №1 и рост родителя 19 | №2. 20 | -------------------------------------------------------------------------------- /content/russian/ml/ranking/_index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Ранжирование 3 | weight: 5 4 | --- 5 | -------------------------------------------------------------------------------- /content/russian/ml/rl/_index.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Обучение с подкреплением 3 | menuTitle: RL 4 | weight: 6 5 | --- 6 | -------------------------------------------------------------------------------- /content/russian/ml/rl/actor-critic.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Actor-critic 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/ml/rl/bandits.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Многорукие бандиты 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/ml/rl/reinforce.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Policy Gradient 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/ml/stats/ab-tests.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: AB-тестирование 3 | --- 4 | -------------------------------------------------------------------------------- /content/russian/ml/stats/maximum-likelihood.ru.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Принцип максимального правдоподобия 3 | --- 4 | -------------------------------------------------------------------------------- /netlify.toml: -------------------------------------------------------------------------------- 1 | [build] 2 | command = "hugo --gc --minify" 3 | 4 | [context.production.environment] 5 | HUGO_VERSION = "0.96.0" 6 | HUGO_ENV = "production" 7 | HUGO_ENABLEGITINFO = "true" 8 | 9 | [context.split1] 10 | command = "hugo --gc --minify --enableGitInfo" 11 | 12 | [context.split1.environment] 13 | HUGO_VERSION = "0.96.0" 14 | HUGO_ENV = "production" 15 | 16 | [context.deploy-preview] 17 | command = "hugo --gc --minify --buildFuture -b $DEPLOY_PRIME_URL" 18 | 19 | [context.deploy-preview.environment] 20 | HUGO_VERSION = "0.96.0" 21 | 22 | [context.branch-deploy] 23 | command = "hugo --gc --minify -b $DEPLOY_PRIME_URL" 24 | 25 | [context.branch-deploy.environment] 26 | HUGO_VERSION = "0.96.0" 27 | 28 | [context.next.environment] 29 | HUGO_ENABLEGITINFO = "true" 30 | -------------------------------------------------------------------------------- /scripts/check-links.sh: -------------------------------------------------------------------------------- 1 | # hugo serve 2 | wget --spider -r -nd -nv http://localhost:1313/ 3 | -------------------------------------------------------------------------------- /scripts/list-files.sh: -------------------------------------------------------------------------------- 1 | find ./ -type f -name "*.md" -exec wc {} + 2 | -------------------------------------------------------------------------------- /static/favicon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/static/favicon.ico -------------------------------------------------------------------------------- /static/img/bst.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/static/img/bst.png -------------------------------------------------------------------------------- /static/img/chernobyl.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/static/img/chernobyl.jpg -------------------------------------------------------------------------------- /static/img/complex-circle.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/static/img/complex-circle.png -------------------------------------------------------------------------------- /static/img/fenwick_ranges.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/static/img/fenwick_ranges.png -------------------------------------------------------------------------------- /static/img/hash-table.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/static/img/hash-table.png -------------------------------------------------------------------------------- /static/img/safe-edge.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/static/img/safe-edge.png -------------------------------------------------------------------------------- /static/img/scooby-doo.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/static/img/scooby-doo.jpg -------------------------------------------------------------------------------- /static/img/sparse-table.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/static/img/sparse-table.png -------------------------------------------------------------------------------- /static/img/stasyan.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/static/img/stasyan.jpg -------------------------------------------------------------------------------- /themes/algorithmica/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2021 Sergey Slotin 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 6 | this software and associated documentation files (the "Software"), to deal in 7 | the Software without restriction, including without limitation the rights to 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software is furnished to do so, 10 | subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /themes/algorithmica/README.md: -------------------------------------------------------------------------------- 1 | ``` 2 | hugo gen chromastyles --style=pygments > syntax.css 3 | pygmentsUseClasses: true 4 | ``` 5 | -------------------------------------------------------------------------------- /themes/algorithmica/archetypes/default.md: -------------------------------------------------------------------------------- 1 | +++ 2 | +++ 3 | -------------------------------------------------------------------------------- /themes/algorithmica/assets/dark.sass: -------------------------------------------------------------------------------- 1 | $font-color: #DDD 2 | $background: #222 3 | $borders: 1px solid rgb(57, 57, 57) 4 | 5 | $code-background: #333 6 | $code-border: 1px solid #444 7 | $quote-line-color: 0.25em #444 solid 8 | 9 | $dimmed: rgb(179, 179, 179) 10 | $section-headers: rgb(239, 239, 239) 11 | $headers-color: rgb(239, 239, 239) 12 | $scrollbar1: #444 13 | $scrollbar2: #555 14 | $scrollbar3: #666 15 | 16 | $link-color: #80acd3 17 | $link-hover-color: #5490c5 18 | 19 | @import style.sass 20 | 21 | img 22 | filter: invert(85%) sepia(20%) saturate(100%) hue-rotate(29deg) brightness(85%) 23 | -------------------------------------------------------------------------------- /themes/algorithmica/i18n/en.toml: -------------------------------------------------------------------------------- 1 | [authors] 2 | one = "author" 3 | other = "authors" 4 | 5 | [editors] 6 | one = "editor" 7 | other = "editors" 8 | 9 | [published] 10 | other = "published" 11 | 12 | [updated] 13 | other = "updated" 14 | 15 | [sections] 16 | other = "sections" 17 | 18 | [search] 19 | other = "Search this book…" 20 | 21 | [searchCountPrefix] 22 | other = "Found" 23 | 24 | [searchCountSuffix] 25 | other = "pages" 26 | 27 | [prerequisites] 28 | other = "prerequisites" 29 | 30 | [translations] 31 | other = "translations" 32 | 33 | [copyright1] 34 | other = "Copyright 2021–2022 Sergey Slotin" 35 | 36 | [copyright2] 37 | other = " " # Content is distributed under CC BY-NC 38 | -------------------------------------------------------------------------------- /themes/algorithmica/i18n/ru.toml: -------------------------------------------------------------------------------- 1 | # https://github.com/Menelion/go-i18n/blob/0518f51fb3d0d0cdbd056b9b3a059e96351368f0/i18n/language/pluralspec.go#L280 2 | 3 | [authors] 4 | one = "автор" 5 | few = "авторы" 6 | many = "авторы" 7 | other = "авторы" 8 | 9 | [editors] 10 | one = "редактор" 11 | few = "редакторы" 12 | many = "редакторы" 13 | other = "редакторы" 14 | 15 | [published] 16 | other = "опубликовано" 17 | 18 | [updated] 19 | other = "обновлено" 20 | 21 | [sections] 22 | other = "статьи раздела" 23 | 24 | [search] 25 | other = "Поиск по сайту…" 26 | 27 | [searchCountPrefix] 28 | other = "Найдено" 29 | 30 | [searchCountSuffix] 31 | other = "страниц" 32 | 33 | [prerequisites] 34 | other = "пререквизиты" 35 | 36 | [translations] 37 | other = "переводы" 38 | 39 | [copyright1] 40 | other = "Copyleft 2017–2022 Algorithmica.org" # {{ .Count / . }} 41 | 42 | [copyright2] 43 | other = "Материалы распространяются под CC BY-SA" 44 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/404.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 404 — Not found 4 | 5 | 6 |
7 |

404

8 |

The article you were trying to find does not seem to exist yet.

9 |

If you got here by following some link on Algorithmica, we would really appreciate it if you helped us fix it.

10 |
11 | 12 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/_default/_markup/render-codeblock-center.html: -------------------------------------------------------------------------------- 1 | 
2 | {{.Inner}}
3 |
4 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/_default/_markup/render-heading.html: -------------------------------------------------------------------------------- 1 | {{- if .Page.IsPage -}} 2 | 3 | #{{ .Text | safeHTML }} 4 | {{- else -}} 5 | {{ .Text | safeHTML }} 6 | {{- end -}} 7 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/_default/_markup/render-image.html: -------------------------------------------------------------------------------- 1 |
2 | 3 |
{{ .Text }}
4 |
5 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/_default/baseof.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | {{- partial "head.html" . -}} 4 | 5 | {{- partial "sidebar.html" . -}} 6 |
7 | {{- partial "buttons.html" . -}} 8 |
9 | {{ partial "search.html" . }} 10 | {{- partial "header.html" . -}} 11 |
12 | {{- block "main" . }}{{- end }} 13 |
14 | {{ partial "nextprev.html" . }} 15 |
16 | {{ partial "footer.html" . }} 17 |
18 | 19 | 20 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/_default/list.html: -------------------------------------------------------------------------------- 1 | {{ define "main" }} 2 | {{ if not .Params.NoTOC }} 3 | {{ if .IsHome }} 4 | {{ range .Sections }} 5 |

{{ .Title }}

6 | {{ partial "division.html" . }} 7 | {{ end }} 8 |
9 | {{ else if .Parent.IsHome }} 10 | {{ partial "division.html" . }} 11 |
12 | {{ end }} 13 | {{ end }} 14 | {{ partial "content.html" . }} 15 | {{ end }} 16 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/_default/list.searchindex.json: -------------------------------------------------------------------------------- 1 | {{- $.Scratch.Add "searchindex" slice -}} 2 | {{- range $index, $element := .Site.Pages -}} 3 | {{- $.Scratch.Add "searchindex" (dict "id" $index "title" $element.Title "path" $element.RelPermalink "content" $element.Plain) -}} 4 | {{- end -}} 5 | {{- $.Scratch.Get "searchindex" | jsonify -}} 6 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/_default/single.html: -------------------------------------------------------------------------------- 1 | {{ define "main" }} 2 | {{ partial "content.html" . }} 3 | {{ end }} 4 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/partials/analytics.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 10 | 11 | 12 | 24 | 25 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/partials/breadcrumb.html: -------------------------------------------------------------------------------- 1 | 4 | {{ define "breadcrumbnav" }} 5 | {{ if .p1.Parent }} 6 | {{ template "breadcrumbnav" (dict "p1" .p1.Parent "p2" .p2 ) }} 7 | {{ else if not .p1.IsHome }} 8 | {{ template "breadcrumbnav" (dict "p1" .p1.Site.Home "p2" .p2 ) }} 9 | {{ end }} 10 | 11 | {{ cond (isset .p1.Params "menutitle") .p1.Params.MenuTitle .p1.Title }} 12 | 13 | {{ if ne .p1 .p2 }}/{{ end }} 14 | {{ end }} 15 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/partials/buttons.html: -------------------------------------------------------------------------------- 1 | 2 | {{ $path := "" }} 3 | {{ with .File }}{{ $path = .Path }}{{ end }} 4 |
5 | 6 | 9 | 10 | 11 | 15 | 16 | 17 | 20 | 21 |
22 |
{{.Title}}
23 |
24 | 25 | 26 | 27 | 28 | 31 | 32 | 33 | 34 | 35 |
36 | 37 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/partials/content.html: -------------------------------------------------------------------------------- 1 | {{ $blocks := split .RawContent "$$" }} 2 | {{ $page := . }} 3 | {{ range $idx, $text := $blocks }} 4 | {{ if (modBool $idx 2) }} 5 | {{ $miniBlocks := split $text "@@" }} 6 | {{ range $miniIdx, $miniText := $miniBlocks }} 7 | {{ if (modBool $miniIdx 2) }} 8 | {{ $page.RenderString $miniText }} 9 | {{ else }} 10 | 15 | {{ end }} 16 | {{ end }} 17 | {{ else }} 18 | $$ 19 | {{ safeHTML $text }} 20 | $$ 21 | {{ end }} 22 | {{ end }} 23 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/partials/division.html: -------------------------------------------------------------------------------- 1 | {{ $sections := .Sections }} 2 | {{ range where .Translations "Lang" "en" }} 3 | {{ $sections = $sections | lang.Merge .Sections }} 4 | {{ end }} 5 |
6 | {{ range $sections }} 7 | {{ if isset .Params "part" }} 8 |

{{.Params.Part}}

9 | {{ end }} 10 | {{ if (not (in .File.Dir "aux")) }} 11 | {{ partial "section.html" . }} 12 | {{ end }} 13 | {{ end }} 14 |
15 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/partials/footer.html: -------------------------------------------------------------------------------- 1 |
2 | {{ T "copyright1" (dateFormat "2006" now) }} 3 |
4 | {{ T "copyright2" | safeHTML }} 5 |
6 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/partials/katex.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 10 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/partials/search.html: -------------------------------------------------------------------------------- 1 | 7 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/partials/section.html: -------------------------------------------------------------------------------- 1 |
2 | {{ .Title }} 3 |
    4 | {{ $pages := .Pages }} 5 | {{ range where .Translations "Lang" "en" }} 6 | {{ $pages = $pages | lang.Merge .Pages }} 7 | {{ end }} 8 | {{ range $pages }} 9 |
  • {{ .Title }} {{ if .IsSection }}↪{{ end }}
    • 10 | {{ end }} 11 |
12 |
13 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/partials/sidebar.html: -------------------------------------------------------------------------------- 1 | 43 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/partials/toc.html: -------------------------------------------------------------------------------- 1 | {{ .TableOfContents }} 2 | -------------------------------------------------------------------------------- /themes/algorithmica/layouts/shortcodes/code.html: -------------------------------------------------------------------------------- 1 | {{ $file := (printf "%s/%s" .Page.Dir (.Get 0)) }} 2 | {{ $extension := index (split $file ".") 1 }} 3 | {{ highlight (readFile $file) $extension "" }} 4 | -------------------------------------------------------------------------------- /themes/algorithmica/static/fonts/Crimson_Text.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/themes/algorithmica/static/fonts/Crimson_Text.zip -------------------------------------------------------------------------------- /themes/algorithmica/static/fonts/Source_Sans_Pro.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/themes/algorithmica/static/fonts/Source_Sans_Pro.zip -------------------------------------------------------------------------------- /themes/algorithmica/static/fonts/cmu.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/themes/algorithmica/static/fonts/cmu.woff2 -------------------------------------------------------------------------------- /themes/algorithmica/static/fonts/crimson.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/themes/algorithmica/static/fonts/crimson.ttf -------------------------------------------------------------------------------- /themes/algorithmica/static/fonts/garamond.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/themes/algorithmica/static/fonts/garamond.woff2 -------------------------------------------------------------------------------- /themes/algorithmica/static/fonts/georgia.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/themes/algorithmica/static/fonts/georgia.woff2 -------------------------------------------------------------------------------- /themes/algorithmica/static/fonts/inconsolata.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/themes/algorithmica/static/fonts/inconsolata.woff2 -------------------------------------------------------------------------------- /themes/algorithmica/static/fonts/linux-libertine.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/themes/algorithmica/static/fonts/linux-libertine.ttf -------------------------------------------------------------------------------- /themes/algorithmica/static/fonts/merriweather.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/themes/algorithmica/static/fonts/merriweather.woff2 -------------------------------------------------------------------------------- /themes/algorithmica/static/fonts/opensans.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/themes/algorithmica/static/fonts/opensans.woff2 -------------------------------------------------------------------------------- /themes/algorithmica/static/fonts/sourcesans.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/algorithmica-org/algorithmica/ed1945c3d2de8548b1c744d3161eb668703db808/themes/algorithmica/static/fonts/sourcesans.ttf -------------------------------------------------------------------------------- /themes/algorithmica/static/icons/adjust-solid.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /themes/algorithmica/static/icons/bars-solid.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /themes/algorithmica/static/icons/bug-solid.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /themes/algorithmica/static/icons/clock-solid.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /themes/algorithmica/static/icons/edit-solid.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /themes/algorithmica/static/icons/github-brands.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /themes/algorithmica/static/icons/history-solid.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /themes/algorithmica/static/icons/language-solid.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /themes/algorithmica/static/icons/moon-regular.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /themes/algorithmica/static/icons/moon-solid.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /themes/algorithmica/static/icons/print-solid.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /themes/algorithmica/static/icons/search-solid.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /themes/algorithmica/static/icons/user-solid.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /themes/algorithmica/static/scripts/lunr.multi.min.js: -------------------------------------------------------------------------------- 1 | !function(e,t){"function"==typeof define&&define.amd?define(t):"object"==typeof exports?module.exports=t():t()(e.lunr)}(this,function(){return function(e){e.multiLanguage=function(){for(var t=Array.prototype.slice.call(arguments),i=t.join("-"),r="",n=[],s=[],p=0;p