Have you ever heard a software engineer refer to a problem as "NP-complete"? That's fancy computer science jargon shorthand for "incredibly hard":

The most notable characteristic of NP-complete problems is that no fast solution to them is known; that is, the time required to solve the problem using any currently known algorithm increases very quickly as the size of the problem grows. As a result, **the time required to solve even moderately large versions of many of these problems easily reaches into the billions or trillions of years**, using any amount of computing power available today. As a consequence, determining whether or not it is possible to solve these problems quickly is one of the principal unsolved problems in Computer Science today.

While a method for computing the solutions to NP-complete problems using a reasonable amount of time remains undiscovered, computer scientists and programmers still frequently encounter NP-complete problems. An expert programmer should be able to recognize an NP-complete problem so that he or she does not unknowingly waste time trying to solve a problem which so far has eluded generations of computer scientists.

You do want to be an *expert* programmer, don't you? Of course you do!

NP-complete problems are like hardcore pornography. Nobody can define what makes a problem NP-complete, exactly, but you'll know it when you see it. Just this once, I'll refrain from my usual practice of inserting images to illustrate my point.

(Update: I was shooting for a poetic allusion to the P=NP problem here but based on the comments this is confusing and arguably incorrect. So I'll redact this sentence. Instead, I point you to this P=NP poll (pdf); read the comments from CS professors (including Knuth) to get an idea of how realistic this might be.)

Instead, I'll recommend a book Anthony Scian recommended to me: Computers and Intractability: A Guide to the Theory of NP-Completeness.

Like all the software engineering books I recommend, this book has a timeless quality. It was originally published in 1979, a shining testament to smart people attacking truly difficult problems in computer science: "I can't find an efficient algorithm, but neither can all these famous people."

So how many problems are NP-complete? Lots.

Even if you're a layman, you might have experienced NP-Completeness in the form of Minesweeper, as Ian Stewart explains. But for programmers, I'd argue the most well known NP-completeness problem is the travelling salesman problem.

Given a number of cities and the costs of travelling from any city to any other city, what is the least-cost round-trip route that visits each city exactly once and then returns to the starting city?

The brute-force solution -- trying every possible permutation between the cities -- might work for a very small network of cities, but this quickly becomes untenable. Even if we were to use theoretical CPUs our children might own, or our children's children. What's worse, every other algorithm we come up with to find an optimal path for the salesman has the same problem. That's the common characteristic of NP-complete problems: they are **exercises in heuristics and approximation**, as illustrated by this xkcd cartoon:

What do *expert* programmers do when faced by an intractable problem? **They cheat**. And so should you! Indeed, some of the modern approximations for the Travelling Salesman Problem are *remarkably* effective.

Various approximation algorithms, which quickly yield good solutions with high probability, have been devised. Modern methods can find solutions for extremely large problems (millions of cities) within a reasonable time, with a high probability of being just 2-3% away from the optimal solution.

Unfortunately, not all NP-complete problems have good approximations. But for those that do, I have to wonder: if we can get so close to an optimal solution by cheating, does it really matter if there's no known algorithm to produce *the* optimal solution? If I've learned nothing else from NP-complete problems, I've learned this: **sometimes coming up with clever cheats can be more interesting than searching in vain for the perfect solution**.

Consider the First Fit Decreasing algorithm for the NP-complete Bin Packing problem . It's not perfect, but it's incredibly simple and fast. The algorithm is so simple, in fact, it is regularly demonstrated at time management seminars. Oh, *and* it guarantees that you will get within 22% of the perfect solution every time. Not bad for a lousy cheat.

So what's *your* favorite NP-complete cheat?

[advertisement] Peer code review without meetings, paperwork, or stopwatches? No wonder Code Collaborator won the Jolt Award.

- ABC
- actual solution
- Alan Turing
- also randomized approximation algorithms
- Amazon
- AMD
- Anthony Scian
- approximate solution
- approximate solutions
- approximating algorithms
- approximation algorithm
- approximation algorithm
- approximation algorithms
- approximation algorithms
- Australia
- Bill Weiss
- Bobby Smith
- brute force algorithm
- brute force algorithm
- brute-force solution
- C
- C++
- choices various data structures and algorithms
- Complexity classes
- Computational complexity theory
- computer chips
- CookâLevin theorem
- cryptographic algorithms
- Dorit Hochbaum
- electronics
- favorite algorithm
- favorite algorithm
- Fit Decreasing algorithm
- gas money
- generic algorithm
- generic algorithm
- generic solution
- Genetic algorithm
- given solution
- good approximating algorithm
- good approximating algorithm
- Huber Heights
- Ian Stewart
- Intel
- Jeff Atwood
- Kevin Bacon
- known algorithm
- Mathematics
- National Institute of Standards and Technology
- non trivial web site
- NP
- NP-complete
- NP-hard
- nVidia
- optimization algorithms
- optimization algorithms
- Optimization problem
- P = NP problem
- P-complete
- paint designs
- performance-critical applications
- polynomial order algorithm
- polynomial order algorithm
- probabilistic polynomial-time algorithm
- probabilistic polynomial-time algorithm
- problem solutions
- randomized approximation algorithms
- real software
- Reduction
- Roberta Smith
- semiconductor
- software development
- software engineering
- software engineering definition
- software engineering defintion
- software writers
- stupid mistakes that cause our software
- Sweden
- Theoretical computer science
- Thomas Smith
- Tom Smith
- TSP
- using approximation algorithms
- web developer
- web programming
- wonderful real world argument tha plagues software development
- _software engineering_