title: The subsets-sum problem and the solvability of NP-complete problems
body: <p>I was reading about the subset-sums problem when I came up with what appears to be a general-purpose algorithm for solving it:</p>
  
  <pre><code>(defun subset-contains-sum (set sum)
      (let ((subsets) (new-subset) (new-sum))
          (dolist (element set)
              (dolist (subset-sum subsets)
                  (setf new-subset (cons element (car subset-sum)))
                  (setf new-sum (+ element (cdr subset-sum)))
                  (if (= new-sum sum)
                      (return-from subset-contains-sum new-subset))
                  (setf subsets (cons (cons new-subset new-sum) subsets)))
              (setf subsets (cons (cons element element) subsets)))))
  </code></pre>
  
  <p>"set" is a list not containing duplicates and "sum" is the sum to search subsets for. "subsets" is a list of cons cells where the "car" is a subset list and the "cdr" is the sum of that subset. New subsets are created from old ones in O(1) time by just cons'ing the element to the front.</p>
  
  <p>I am not sure what the runtime complexity of it is, but appears that with each element "sum" grows by, the size of "subsets" doubles, plus one, so it appears to me to at least be quadratic.</p>
  
  <p>I am posting this because my impression before was that NP-complete problems tend to be intractable and that the best one can usually hope for is a heuristic, but this appears to be a general-purpose solution that will, assuming you have the CPU cycles, always give you the correct answer. How many other NP-complete problems can be solved like this one?</p>