(Part 2) Top products from r/algorithms

You can come back to it later, yes. Why though? You'll need them "now", won't you? I mean, you're going through the book (Skiena's) now, not later. Isn't that right? If you learn it now, you will go through the book better equiped to get its message.

And, besides, it isn't that difficult. It's not trivial by any means. You can try some alternative resources.

• MIT has a course on math for CS, which include several topics which serve as a foundation to, among many things, proving things correct in CS. I don't believe the course will directly help you, but it seems worth to take a look (http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-042j-mathematics-for-computer-science-fall-2010/ - notice the video lectures link on the side).
  
• "Foundations of Computer Science", this is a book (http://www.amazon.com/Foundations-Computer-Science-Principles/dp/0716782847/) and they cover the topic of proofs in there too. It's a very good book for all I can remember.
  
• Dijkstra's books. He has two books that I know can help you on this: "Structured Programming" (http://www.amazon.com/Structured-Programming-P-I-C-studies-processing/dp/0122005503/) and "The Discipline of Programming" (http://www.amazon.com/Discipline-Programming-Edsger-W-Dijkstra/dp/013215871X/).
  
  I'm not sure why you're interested in deferring this to later. Personally, I believe having seen how proofs of correctness are somewhat done is way more worth it than seeing the algorithms themselves, although some algorithms are pretty educational (like quicksort and also binary search for example). Because even though you won't prove programs correct in practice, knowing how a proof might be devised helps you in writing programs that are easy to prove, and those have to be simple. The whole idea of structured programming that Dijkstra had in mind was to help with this. It's way more intuitive to reason about "while (i < 10) { <do something> }" than a bunch of goto's. In the while-loop case, you can clearly see that upon termination, i >= 10 is true for example. And you can also clearly derive some properties about the body of the loop inductively by analyzing previous iterations.
  
  A lot of good readable code techniques can be put in terms of easy to prove code. Like small functions that do very little, are very cohesive, and work collaboratively. Same for objects. It's way easier to prove correct a bunch of small pieces that work together by some simple means of combination, than a huge big thing.
  
  Good luck.

Online material: I don't know about any high-quality online-run courses, but with GAs (and EC in general) you'll get quite far with searching Google for "evolutionary algorithms filetype:pdf", or something similar. In addition to freestanding texts, there are many Unis that have courses on biologically inspired AI, with high-quality lecture notes available online.

Where to begin: A standard toy problem is "one max" (have your EA find the bitstring of all ones).
You can start with a pretty simple program, confirming that your EA can solve the problem, and then expand it into a flexible solution supporting multiple selection mechanisms, various representations (binary, real-valued, permutation-based, ...), development schemes, and nice visualizations. EA systems lend themselves quite well to OO design, although other approaches are possible.

Recommended dead trees: An excellent book on EC is de Jong's Evolutionary Computation: A Unified Approach. While quite short, this book, written by one of the absolute experts in the field, is very pedagogical, broad-scoped, and up to date. One problem, though, is that it it's somewhat short in its treatment of GP. If you're interested in GP as well (and who isn't?), you could get this little book which costs about 1 nickle.

Good luck with exploring Evolutionary Computing! It's an amazing subject. You can begin with a 20-line program that you can explain to a kid, and later find yourself reading grad-level mathematics exploring intricacies of some aspect of evolution. Just be prepared for some weird looks when you finally find yourself printing papers on "Incest prevention" in the school library.

Edit: Spelling.

This is actually a very good question, a prerequisite I completely forgot about. For the above algorithm books, both Discrete Math and Calculus (although less so) are a must.

I've only ever used Kenneth Rosen's text, which isn't exactly great for self-study. Perhaps you can find an online course with video, but I would consider attending your local community college and taking up courses in both. They are both fun and equally important.

One thing I will mention is the Tardos & Kleinberg Algorithms book will go over many proofs using a variety of proof techniques (there's a lot of love for proof by contradiction in algorithm analysis/correctness). You need to familiarize yourself with these, and the best way to do that is to take a course in discrete maths where you will learn the tools to do so. A math course solely based on proofs is also highly recommended, such as Introduction to Abstract Algebra.

So, I would suggest first taking a course in discrete math, and optionally calculus, before tackling any algorithms book. You can of course look up algorithms, implement them, but you won't have the tools necessary to perform analysis and determine correctness which is the important aspects of algorithm design. Also this applies to learning data structures.

I suggest you to not waste too much time reading 15 different books on algorithms or spreading on 15 different resources (YT videos, online courses, forums, tutorials, etc.). Stick to 1 or 2 good books (try Introduction to Algorithms and, if you're completely new to algorithms, and have no idea what are they and what is their role in computer science and science in general, I recommend book by same author that could make a good preparation to previous book; it's called Algorithms Unlocked ) and start applying that knowledge in the run (solving problems). Remember: don't waste time on hundreds of resources; they may be great and offer some really high quality information about topic, but you just don't have time to go through all of them. Good luck!

If you have a pressing need to get a handle on DP this probably won't help. That being said, I have an MS in applied math and think the way DP is presented to anyone coming at it from a CS perspective creates a lot of the confusion.

DP is NOT a programming paradigm. It is an optimization technique originally developed to reduce the search space of high dimensional problems.

I would recommend reading the first few chapters of this book (I have no relationship to or financial stake in either the book or you clicking the link): http://athenasc.com/dpbook.html

It does a good job of explaining how to think about DP without being prescriptive which I think is the flaw with the CLRS presentation.

Id also recommend this book (again, I have no interest in this): Dynamic Programming (Dover Books on Computer Science) https://www.amazon.com/dp/0486428095/ref=cm_sw_r_cp_apa_i_UT.7CbAEDXGAM

The book gets pretty dense pretty fast but if you push through the first few chapters it will give you additional insight as to the motivation behind why this technique was developed

My algorithms class presupposed that I took linear algebra, I think. I think you'll need to be able to do maths, but they taught me the maths I needed to know as I went along. It depends on the course, though. Here's the book we used in class. Here's its home page, but the link seems to be broken. It should be online for free. For example, I found another copy here. Here's the PDF Also a free book on linear algebra.

I loved "Algorithms in C++" by Sedgewick.

Standard recommendations will also be: "Introduction to Algorithms" by Cormen et al, and "Algorithms" by Dasgupta et al.

If you want to get introduced to the world of programming contests, I hear great things about Programming Challenges: The Programming Contest Training Manual.

I personally like Skiena's book
The Algorithm Design Manual
https://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1848000693

If you already studied algorithms but need a quick refresher, Algorithms in a Nutshell is good.
https://www.amazon.com/Algorithms-Nutshell-OReilly-George-Heineman/dp/059651624X/ref=sr_1_3?s=books&ie=UTF8&qid=1496051402&sr=1-3&keywords=algorithms+in+a+nutshell

GLPK is a commonly used library in a number of programming languages(R, Python, etc.) and Excel has a limited ability to do these problems.

If you want to take an Excel approach, I once took a class that used this book: https://www.amazon.com/Optimization-Modeling-Spreadsheets-Kenneth-Baker/dp/0470928638

Generally after CLRS you should be ready to read TAOCP. But if you still feel insufficient, Professor Knudth has another book that you can look into to enhance the math background - Concrete Mathematics: A Foundation for Computer Science.

http://www.amazon.com/Knapsack-Problems-Implementations-Wiley-Interscience-Optimization/dp/0471924202/ ?

A good lightweight introduction: Programming Collective Intelligence

If you'd like a single, but more difficult, reference that covers much of the breadth of machine learning: Machine Learning: A probabiliistic Perspective

Hi, if you want to look further into the swarm based approach, Gianni di Caros Thesis is a good resource. Chapter 3-5 cover combinatorial problems and the ACO metaheuristic. http://www.idsia.ch/~gianni/Papers/thesis.pdf

I am currently reading http://www.amazon.com/Ant-Colony-Optimization-Bradford-Books/dp/0262042193/

The practical application of the metaheuristic to a lot of problems is described there. This may help you with your problem. Voices whisper you can find this as a pdf on the internet - I bought it though...

Oh man, you thread has wrecked my day. You're question prompted me to pull down an algorithm book from a collage class I had about 8 years ago. Out fell some 3x5 cards with algorithm names and short notes summing up the algorithm. I'd written the cards to get ready for tests.

I looked through the cards, then looked at my task list for the day and it made me want to cry. I've been doing bullshit busy work so long in corporate America I've forgotten almost everything I ever learned in collage.

If you love programming, work for a small company when you leave college. If you're incompetent and only looking for a paycheck, go work for a corporation.