YOU HELPED IN A GREAT WAY ____///////////////\\\\\\\\\\\________ A BIG SALUTE

Good job!

I love it :) But I think you can add more problems , and more advanced topics too

Are certain sections highlighted at the start of the section that its exclusively for ICPC participants? So that those aiming for IOI may not go in much deep! Thank you Keep up the good work

Logged in just to Upvote this blog and say thank you to pllk. Great job :)

Thank you! I think it is a really good book with very focused content. Just a suggestion, maybe you could include some competitive programming tricks into your book? For example, how to write a shortened version of a common algorithm (e.g. union-find can be written in 4 statements without using union-by-rank heuristic and is still good enough in competitions)?

Thank you for sharing. The book is well written. Definitely a plus!

Very useful and well written :)

Wow, this looks like a tremendous amount of work. I'm really curious about a few things.

How long did it take you? How old are you and are you a teacher? Have you written it in your free time, without the money compensation from e.g. university?

Brother its fantastic. I salute you.

I think this may be the best competitive programming book for beginners, I've ever seen! I've read some of Competitive Programming by Steven Halim already, and I would say that it is indeed a good book. However, truth be told I don't think it is necessarily beginner friendly. The way the sample code is written makes it somewhat difficult to read at times. Personally, I didn't know much C++ when I started to read it so the constant one-liner "if" and "for" statements he often uses obscured the meaning behind a lot of algorithms, for a few weeks, at times. So the clean code in your book is a huge plus.

One reason I can see this book being the best beginner book is that you "spell out" everything for the reader. I read the chapter on bit manipulation and I certainly believe it is the most well-written piece of literature on it I've ever seen. I don't think I've ever seen a coherent article written on using bitmasks for DP problems written for beginners either, and I can't wait to sink my teeth into the remainder of the book.

Awesome Work !! You can add some related problems in each chapter.

If you share the book sources, the community can translate it to other languages.

I read some prefix of the book

It's easy to read (but I didn't find anything new yet but that's pretty normal I suppose)

What I want you to consider is to promote a cleaner code. I think it's quite important especially when there are more than 1 coder in a team (but i find it useful even when I participate in personal contest)

What I mean, for example:

• When discussing defines for cycles, you may discuss pros and cons (e.g typing speed vs readability and harder to spot errors) (how your FOR will work when iterating from 10^10 to 10^10+5 ?)
• I find 1-indexed arrays very questionable
• (that's more debatable) binary search in my opinion is more handsome when formulated in terms of invariant f(l) = true, f(r) = false:

while(r - l > 1) {
   int m = (l + r) / 2;
   if (f(m)) {
      l = m;
   }
   else {
      r = m;
   }

• fixed size arrays (e.g in graph representation)
• understandable names (e.g array of used vertices in dfs)

By the way, You explain how to sort vector before introducing what it is, so may be it's worth moving sorting chapter after the introduction of vector because or at least say something like if you don't know what it's don't worry, you'll know in the next section.

I've noticed that you add pairs t vector using v.push_back({1, 2}) and v.push_back(make_tuple(1, 2, 3)). I believe, braces initialisation should work for tuple too (and also you may use emplace_back) in either case

A very well resourceful book.

Thanks a lot for the effort :) I think it would be great if you can add interesting sample problems for each topic and also add some more advanced techniques and algorithms. By the way, I would love to donate and to translate it into Turkish.

Thank you very much for your efforts. I literally learned more today than I did for the last month.

Surely great amount of work. But it will great if you add problem to practice section after every chapter of your book.

Wonderful book, and I think I'll use it often. But I do feel some important topics are missing. Perhaps they could be added into later editions? This could be another of the aspects where the codeforces community could help.

Topics that come to my mind would be fast exponentiation and its applications to DP, along with other dp optimizations like Knuth or convex hull trick, etc.

Method 2 for binary search would be cleaner if you change b = n/2 to b = (n+1)/2 and b /= 2 to b = (b + 1) / 2. This way you don't need the while loop.

People like you , are a blessing for the entire coding community .. :) Thanks a lot :)

If you add some problem name from different oj in each section . It will be more helpful .

хорошая книга

Thanks pllk, great work, and really amazing coverage of many topics, it would be really helpful to add some practice problems from OJs.

As it turns out, a lot of people are asking for practice problems. So I propose that you guys create a Wiki and make some top rated people willing to contribute an admin of the wiki. Anyone can add problems / editorials here and it will be approved if and only if the quality of the problem / editorial is high enough and actually helps someone to improve their skills.

Thanks a lot brother.

I haven't understood this line. Please someone explain me this line. In 2.2 Compexity Classes

A special property of square roots is that sqrt(n) = n/sqrt(n), so the square root sqrt(n) lies, in some sense, in the middle of the input.

I've gone through the "Advanced Topics" part and my reaction while reading this book can be described as: wow wow wow wow wow wow.....

Thank you for sharing it.

Thanks loads n loads.

Here is a book I wish I would have got earlier. Went through graph portion. For the first time, I felt dfs, bfs, bellman, Dijkstra are reachable and can be coded.

So kind of you that you have kept it free for all. I will advice this if someone wants to enter competitve programming.

Thanks again. A big hug.

Love the book, especially the advanced topics section, which includes most of the material needed to become a mid-purple.

THANKS SIRRR !!!!!

Your book is awesome. Thanks.

thanks and gratitude

Thank you very very very much!

Thank you for such an amazing book! Im wondering if theres an available epub version of this book?

In page 259, chapter 29: Geometry, I think it should be:

P a = {4,2};
P b = {3,-1};
cout << abs(b-a) << "\n"; // 3.16228

Instead:

P a = {4,2};
P b = {3,-1};
cout << abs(b-a) << "\n"; // 3.60555

Using the formular, we got:

You can add Bertrand's postulate to number theory chapter:

There are at least one prime p such that n < p < 2n where n > 1.

Can someone please send me the code for K-th ancestor in a successor graph. I have understood the algorithm but still not clear about writing the code. Thanks in advance.

A really nice resource, appreciate it.

OH my go-----------d!!! This is really an excellent book for a beginner like me. People learn from each other, share with each other and inspire each other. This is how the world develops generation by generation. I think this world needs people like you. With great power comes great responsibility!! Thank you so much for your invaluable contribution!!

This is #1 on HN right now: Thread. There's a bunch of feedback so I thought you should know. :)

Hey @pllk, thank you very much! By the way, do you have the printed version available for purchase? I would love to buy this book.

hey pllk

thank you very much for your awesome work

your book was very helpful to me

i'm using it to train for the IEEEXtreme programming competition

which — by the way — will be on October the 14th .

so if i may ask you ... will your book be ready before the competition or not ?

How can the complexity of Bellman-Ford algorithm implementation in the book be O(N.M) ? shouldn't this code be O(N^2.M) UPDATE: O(N^2.NM) ? (Although the real algorithm complexity is O(N.M) !)

Book page : 123

Does the book talk about how to problem solve?

In the greedy Section Minimizing sums
there are a solution for this:
Minimize (a1-x)^2 + (a2-x)^2 + (a3-x)^2 .... (an-x)^2
And the solution is x = (average (Ai) )
That is because the average is the avarage of the
polynomial roots from nx^2 -2x(a1+a2+...+an)

Someone could explain me why works please??
How prove this??
And it works for every power different to 2?

...

I have already try to learn CP through some famous books but that books are either difficult or no code in C++ illustration. Thank you very much. A good book for me, also beginners who start to learn CP.

Great work! I'm trying to translate into Japanese.

It's WIP and I completed until Ch.8. https://github.com/kmjp/cphb

Every book has a nice cover. This book is excellent. It deserves a nice and cool cover!

Would be interesting to have ideas for a book cover. So, let the ideas flow in!

Very good stuff. Good job!

My review on this book:

EVERY F*CKIN' ALPHA-NUMERIC CHAR WORTH

pg. 266, draft Dec 2017, discussing a general formula for the area of arbitrary quadrilaterals, you give the shoelace formula for which 'there are no special cases'.

However, the shoelace formula gives negative area if vertices are given in clockwise order, so you may want to add absolute value signs around the formula if you want 'no special cases'.

13.1 Bellman–Ford algorithm

I think the graph in your example should be directed, see this answer. Thank you.

It would be great if someone shares an ideal 20-page Cookbook for ACM ICPC Regional.

Your iterative union-find find function doesn't flatten the tree, making it slow on average, you have:
int find(int x) { while (x != link[x]) x = link[x]; return x; }
You should use a recursive one which flattens it:
int find(int x) { if (x == link[x]) return x; return link[x]=find(link[x]); }

Thanks for your work.

Here's the link for the online version of the book.

Competitive Programming

EDIT: My bad, if (S&(1<<k))>0 then partial(S^(1<<k),k)==partial(S^(1<<k),k-1), as S^(1<<k) has kth bit not set, so the k iteration didn't do anything so it's same as (k-1) iteration.

PRE-EDIT: Once again a great book! On page 105, you show the recurrence of partial(S,k) = partial(S, k-1) + partial(S^(1<<k), k-1), but that last term seems to be partial(S^(1<<k),k) in your code on the next page since you use only one array sum, and S^(1<<k) is smaller than S, so it is already calculated for k, not k-1. Which is right here?

Is the final version of the book available? pllk

I really appreciate your help. Thank you.