merged

Author: Chillee

.github/workflows/ccpp.yml

@@ -0,0 +1,24 @@
+name: C/C++ CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install pdflatex
+      run: sudo apt-get install texlive-latex-base texlive-latex-recommended texlive-latex-extra
+    - name: Build pdf
+      run: make kactl
+    - name: Run compiles
+      run: make test-compiles
+    - name: Run stress tests
+      run: make test

.gitignore

@@ -1,3 +1,6 @@
+*
+!*/
+!*.*
 /build/
 a.out
 header.tmp

Makefile

@@ -6,11 +6,14 @@ help:
 	@echo "This makefile builds KACTL (KTH Algorithm Competition Template Library)"
 	@echo ""
 	@echo "Available commands are:"
-	@echo "	make fast	- to build KACTL, quickly (only runs LaTeX once)"
-	@echo "	make kactl	- to build KACTL"
-	@echo "	make clean	- to clean up the build process"
-	@echo "	make veryclean	- to clean up and remove kactl.pdf"
-	@echo "	make help	- to show this information"
+	@echo "	make fast		- to build KACTL, quickly (only runs LaTeX once)"
+	@echo "	make kactl		- to build KACTL"
+	@echo "	make clean		- to clean up the build process"
+	@echo "	make veryclean		- to clean up and remove kactl.pdf"
+	@echo "	make test		- to run all the stress tests in stress-tests/"
+	@echo "	make test-compiles	- to test compiling all headers"
+	@echo "	make help		- to show this information"
+	@echo "	make showexcluded	- to show files that are not included in the doc"
 	@echo ""
 	@echo "For more information see the file 'doc/README'"
 
@@ -22,7 +25,7 @@ kactl: test-session.pdf | build
 	$(LATEXCMD) content/kactl.tex && $(LATEXCMD) content/kactl.tex
 	cp build/kactl.pdf kactl.pdf
 
-clean: 
+clean:
 	cd build && rm -f kactl.aux kactl.log kactl.tmp kactl.toc kactl.pdf kactl.ptc
 
 veryclean: clean
@@ -33,6 +36,16 @@ veryclean: clean
 build:
 	mkdir -p build/
 
+test:
+	./doc/scripts/run-all.sh .
+
+test-compiles:
+	./doc/scripts/compile-all.sh .
+
 test-session.pdf: content/test-session/test-session.tex content/test-session/chapter.tex | build
 	$(LATEXCMD) content/test-session/test-session.tex
 	cp build/test-session.pdf test-session.pdf
+
+showexcluded: build
+	grep -RoPh '^\s*\\kactlimport{\K.*' content/ | sed 's/.$$//' > build/headers_included
+	find ./content -name "*.h" -o -name "*.py" -o -name "*.java" | grep -vFf build/headers_included

README.md

@@ -1,51 +1,65 @@
 # KACTL
 
-This repo hosts KACTL, KTH's ICPC team reference document.
-It consists of 25 pages of copy-paste:able code, for use in ICPC-style programming competitions.
+This repo hosts KACTL, [KTH](https://en.wikipedia.org/wiki/KTH_Royal_Institute_of_Technology)'s ICPC team reference document.
+It consists of 25 pages of copy-pasteable C++ code, for use in ICPC-style programming competitions.
 
 See [kactl.pdf](https://github.com/kth-competitive-programming/kactl/blob/master/kactl.pdf) for the final, browsable version,
 and [content/](https://github.com/kth-competitive-programming/kactl/tree/master/content) for raw source code.
 
 ## Aspirations
 
-KACTL algorithms should be: useful, short, fast enough, readable, and if relevant, easy to modify.
-Short and readable sometimes conflict -- usually then short takes precedence, although
-the algorithms should still be made easy to type in and hard to make typos in (since ICPC-style contests
-require you to copy them from paper).
-
+KACTL algorithms should be: useful, short, fast enough, well tested, and if relevant, readable and easy to modify.
 They should *not* be overly generic, since code is manually typed and that just adds overhead.
 Due to space issues, we also exclude algorithms that are very common/simple (e.g., Dijkstra), or very uncommon (general weighted matching).
 
-If you feel that something is missing, could be cleaned up, or notice a bug, please file an issue or send us a pull request!
+If you feel that something is missing, could be cleaned up, or notice a bug, please file an issue or [send a pull request](https://help.github.com/articles/fork-a-repo/)!
 
-## Hacking on KACTL
+## Customizing KACTL
 
-For coding style, try to copy existing code.
-Each algorithm should contain a header with the author of the code, the date it
-was added, a description of the algorithm, its testing status, and preferably also
-source, license and time complexity.
-Line width is 63 chars, with tabs for indentation (tab = 2 spaces in the pdf).
+While KACTL is usable as is, it's also easy to modify if you want to create a personalized copy.
+In particular, you may want to change the cover page, or make your own choice of algorithms to include --
+due to space concerns, not all algorithms in the repo are included in the pdf.
+You may also want to enable colored syntax highlighting.
 
-When adding/removing files, edit the corresponding `chapter.tex` file as well.
-`chapter.tex` also contains all non-source code, e.g. math and textual descriptions.
-For nicer alignment you might want to use `\hardcolumnbreak`, `\columnbreak` or `\newpage` commands,
+`content/kactl.tex` is the main file of KACTL, and can be edited to change team name, logo, syntax highlighting, etc.
+It imports `chapter.tex` files from each of the `content/` subdirectories, which define the contents of each chapter.
+These include source code, text and math in the form of LaTeX.
+To add/remove code from a chapter, add/remove a corresponding `\kactlimport` line from the `chapter.tex` file.
+For nicer alignment you might want to insert `\hardcolumnbreak`, `\columnbreak` or `\newpage` commands,
 though this is usually only done before important contests, and not on master.
+The algorithms that are not included in the pdf are left commented out in `chapter.tex`.
 
-To build KACTL, type `make kactl` (or `make fast`) on a \*NIX machine -- this will update `kactl.pdf`.
+To build KACTL, type `make kactl` (or `make fast`) on a \*nix machine -- this will update `kactl.pdf`.
 (Windows might work as well, but is not tested.) `doc/README` has a few more notes about this.
 
-kactl.pdf is to be kept to 25 pages + cover page.
-Occasionally the generated kactl.pdf is committed to the repo for convenience, but not too often because it makes git operations slower.
+Tips:
+1. Check out what's excluded by default by running `make showexcluded`.
+The default configuration is chosen to be a reasonable balance for beginners
+and advanced teams.
+2. Take advantage of the hashing when typing in these algorithms. Each
+algorithm has a 6 character MD5 hash in the upper right. This hash can be
+generated by using `hash.sh` or the `:Hash` command from the `.vimrc`. The
+hashing ignores whitespace and comments.
 
-Before printing KACTL for an official contest, you may want to locally change the arguments to `\team`, `\contest`, etc. in build/kactl.tex to something more fitting,
-You may also enable colored syntax highlighting in the same file.
+## Coding style
 
-To upstream your changes, [send a pull request](https://help.github.com/articles/fork-a-repo/).
+KACTL uses a relatively terse coding style, with a handful of macros/typedefs defined in the
+[template](https://github.com/kth-competitive-programming/kactl/blob/master/content/contest/template.cpp) that help shorten the code.
+Line width is 63 chars, with tabs for indentation (tab = 2 spaces in the pdf).
+
+Each algorithm contains a header with the author of the code, the date it
+was added, a description of the algorithm, its testing status, and preferably also
+source, license and time complexity.
+
+kactl.pdf is to be kept to 25 pages + cover page.
+Occasionally the generated kactl.pdf is committed to the repo for convenience, but not too often because it makes git operations slower.
 
 ## Testing
 
-KACTL algorithms are tested manually, on online judges and/or using fuzz-tests (see the `fuzz-tests` directory).
-Simple variable renamings etc. don't need testing, but it's prudent to at least run `./test-compiles.sh file.h` to make sure the file still compiles.
+KACTL aims for a high level of confidence in algorithm correctness.
+Testing is done both on online judges and (for newer algorithms) with stress tests
+that compare output to a more naive algorithm for a large amount of randomly generated cases.
+These tests live in the `stress-tests` directory, and are run with CI on every commit. The CI also verifies that all headers compile (except for a whitelist in `docs/scripts/skip_headers`) and that the latex compiles.
 
 `old-unit-tests` contains a couple of broken unit tests, last touched about ten years ago.
 
@@ -57,4 +71,4 @@ Many source files are marked with license (we try to go with
 Presumably good will is to be assumed from other authors, though, and in many cases permission should not be needed since the code is not distributed.
 To help trace things back, sources and authors are noted in source files.
 
-Everything in `fuzz-tests` and `build` is implicitly CC0.
+Everything in `stress-tests` is implicitly CC0, except reference implementations taken from around the Internet.

content/combinatorial/IntPerm.h

@@ -3,13 +3,14 @@
  * Date: 2018-07-06
  * License: CC0
  * Description: Permutation -> integer conversion. (Not order preserving.)
+ * Integer -> permutation can use a lookup table.
  * Time: O(n)
  */
 #pragma once
 
 int permToInt(vi& v) {
 	int use = 0, i = 0, r = 0;
-	trav(x, v) r = r * ++i + __builtin_popcount(use & -(1 << x)),
+	for(int x:v) r = r * ++i + __builtin_popcount(use & -(1<<x)),
 		use |= 1 << x;                     // (note: minus, not ~!)
 	return r;
 }

content/combinatorial/binomialModPrime.h

@@ -34,11 +34,28 @@ \section{Partitions and subsets}
 		\end{tabular}
 		\end{center}
 
+	\subsection{Lucas' Theorem}
+		Let $n,m$ be non-negative integers and $p$ a prime. Write $n=n_kp^k+...+n_1p+n_0$ and $m=m_kp^k+...+m_1p+m_0$. Then $\binom{n}{m} \equiv \prod_{i=0}^k\binom{n_i}{m_i} \pmod{p}$.
+
 	\subsection{Binomials}
-		\kactlimport{binomialModPrime.h}
 		\kactlimport{multinomial.h}
 
 \section{General purpose numbers}
+	\subsection{Bernoulli numbers}
+		EGF of Bernoulli numbers is $B(t)=\frac{t}{e^t-1}$ (FFT-able).
+		$B[0,\ldots] = [1, -\frac{1}{2}, \frac{1}{6}, 0, -\frac{1}{30}, 0, \frac{1}{42}, \ldots]$
+
+		Sums of powers:
+		\small
+		\[ \sum_{i=1}^n n^m = \frac{1}{m+1} \sum_{k=0}^m \binom{m+1}{k} B_k \cdot (n+1)^{m+1-k} \]
+		\normalsize
+
+		Euler-Maclaurin formula for infinite sums:
+		\small
+		\[ \sum_{i=m}^{\infty} f(i) = \int_m^\infty f(x) dx - \sum_{k=1}^\infty \frac{B_k}{k!}f^{(k-1)}(m) \]
+		\[ \approx \int_{m}^\infty f(x)dx + \frac{f(m)}{2} - \frac{f'(m)}{12} + \frac{f'''(m)}{720} + O(f^{(5)}(m)) \]
+		\normalsize
+
 	\subsection{Stirling numbers of the first kind}
 		Number of permutations on $n$ items with $k$ cycles.
 		\begin{align*}
@@ -65,6 +82,11 @@ \section{General purpose numbers}
 		$1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147, \dots$. For $p$ prime,
 		\[ B(p^m+n)\equiv mB(n)+B(n+1) \pmod{p} \]
 
+	\subsection{Labeled unrooted trees}
+		\# on $n$ vertices: $n^{n-2}$ \\
+		\# on $k$ existing trees of size $n_i$: $n_1n_2\cdots n_k n^{k-2}$ \\
+		\# with degrees $d_i$: $(n-2)! / ((d_1-1)! \cdots (d_n-1)!)$
+
 	\subsection{Catalan numbers}
 		\[ C_n=\frac{1}{n+1}\binom{2n}{n}= \binom{2n}{n}-\binom{2n}{n+1} = \frac{(2n)!}{(n+1)!n!} \]
 		\[ C_0=1,\ C_{n+1} = \frac{2(2n+1)}{n+2}C_n,\ C_{n+1}=\sum C_iC_{n-i} \]

content/combinatorial/chapter.tex

@@ -2,14 +2,13 @@
 using namespace std;
 
 #define rep(i, a, b) for(int i = a; i < (b); ++i)
-#define trav(a, x) for(auto& a : x)
 #define all(x) begin(x), end(x)
 #define sz(x) (int)(x).size()
 typedef long long ll;
 typedef pair<int, int> pii;
 typedef vector<int> vi;
 
 int main() {
-	cin.sync_with_stdio(0); cin.tie(0);
+	cin.tie(0)->sync_with_stdio(0);
 	cin.exceptions(cin.failbit);
 }

content/contest/template.cpp

@@ -1,13 +1,13 @@
 Pre-submit:
-Write a few simple test cases, if sample is not enough.
+Write a few simple test cases if sample is not enough.
 Are time limits close? If so, generate max cases.
 Is the memory usage fine?
 Could anything overflow?
 Make sure to submit the right file.
 
 Wrong answer:
 Print your solution! Print debug output, as well.
-Are you clearing all datastructures between test cases?
+Are you clearing all data structures between test cases?
 Can your algorithm handle the whole range of input?
 Read the full problem statement again.
 Do you handle all corner cases correctly?
@@ -22,11 +22,11 @@ Add some assertions, maybe resubmit.
 Create some testcases to run your algorithm on.
 Go through the algorithm for a simple case.
 Go through this list again.
-Explain your algorithm to a team mate.
-Ask the team mate to look at your code.
+Explain your algorithm to a teammate.
+Ask the teammate to look at your code.
 Go for a small walk, e.g. to the toilet.
 Is your output format correct? (including whitespace)
-Rewrite your solution from the start or let a team mate do it.
+Rewrite your solution from the start or let a teammate do it.
 
 Runtime error:
 Have you tested all corner cases locally?
@@ -45,8 +45,8 @@ What is the complexity of your algorithm?
 Are you copying a lot of unnecessary data? (References)
 How big is the input and output? (consider scanf)
 Avoid vector, map. (use arrays/unordered_map)
-What do your team mates think about your algorithm?
+What do your teammates think about your algorithm?
 
 Memory limit exceeded:
 What is the max amount of memory your algorithm should need?
-Are you clearing all datastructures between test cases?
+Are you clearing all data structures between test cases?

content/contest/troubleshoot.txt

@@ -6,6 +6,7 @@
  * Description: Computes partial sums a[0] + a[1] + ... + a[pos - 1], and updates single elements a[i],
  * taking the difference between the old and new value.
  * Time: Both operations are $O(\log N)$.
+ * Status: Stress-tested
  */
 #pragma once
 

content/data-structures/FenwickTree.h

@@ -6,6 +6,7 @@
  * Description: Computes sums a[i,j] for all i<I, j<J, and increases single elements a[i,j].
  *  Requires that the elements to be updated are known in advance (call fakeUpdate() before init()).
  * Time: $O(\log^2 N)$. (Use persistent segment trees for $O(\log N)$.)
+ * Status: stress-tested
  */
 #pragma once
 
@@ -18,7 +19,7 @@ struct FT2 {
 		for (; x < sz(ys); x |= x + 1) ys[x].push_back(y);
 	}
 	void init() {
-		trav(v, ys) sort(all(v)), ft.emplace_back(sz(v));
+		for (vi& v : ys) sort(all(v)), ft.emplace_back(sz(v));
 	}
 	int ind(int x, int y) {
 		return (int)(lower_bound(all(ys[x]), y) - ys[x].begin()); }

content/data-structures/FenwickTree2d.h

@@ -3,15 +3,16 @@
  * Date: 2018-07-23
  * License: CC0
  * Source: http://codeforces.com/blog/entry/60737
- * Description: Hash map with the same API as unordered\_map, but \tilde 3x faster.
+ * Description: Hash map with mostly the same API as unordered\_map, but \tilde
+ * 3x faster. Uses 1.5x memory.
  * Initial capacity must be a power of 2 (if provided).
  */
 #pragma once
 
 #include <bits/extc++.h> /** keep-include */
 // To use most bits rather than just the lowest ones:
-struct chash {
-	const uint64_t C = ll(2e18 * M_PI) + 71; // large odd number
+struct chash { // large odd number for C
+	const uint64_t C = ll(4e18 * acos(0)) | 71;
 	ll operator()(ll x) const { return __builtin_bswap64(x*C); }
 };
 __gnu_pbds::gp_hash_table<ll,int,chash> h({},{},{},{},{1<<16});
@@ -20,7 +21,7 @@ __gnu_pbds::gp_hash_table<ll,int,chash> h({},{},{},{},{1<<16});
 
 const int RANDOM = chrono::high_resolution_clock::now().time_since_epoch().count();
 struct chash { // To use most bits rather than just the lowest ones:
-	const uint64_t C = ll(2e18 * M_PI) + 71; // large odd number
+	const uint64_t C = ll(4e18 * acos(0)) | 71; // large odd number
 	ll operator()(ll x) const { return __builtin_bswap64((x^RANDOM)*C); }
 };
 __gnu_pbds::gp_hash_table<ll, int, chash> h({},{},{},{}, {1 << 16});

content/data-structures/HashMap.h

@@ -8,7 +8,7 @@
  * Use with a bump allocator for better performance, and SmallPtr or implicit indices to save memory.
  * Time: O(\log N).
  * Usage: Node* tr = new Node(v, 0, sz(v));
- * Status: fuzz-tested a bit
+ * Status: stress-tested a bit
  */
 #pragma once
 

content/data-structures/LazySegmentTree.h

@@ -4,9 +4,9 @@
  * License: CC0
  * Source: own work
  * Description: Container where you can add lines of the form kx+m, and query maximum values at points x.
- *  Useful for dynamic programming.
+ *  Useful for dynamic programming (``convex hull trick'').
  * Time: O(\log N)
- * Status: tested
+ * Status: stress-tested
  */
 #pragma once