如何编写一个方案程序使用n和sum作为参数，并显示可以求和的所有数字（从1到n）？像这样：
（找10 10）
（（10） （9,1） （8,2） （7,3） （7,2,1） （6,4） （6,3,1） （5,4,1） （5,3,2） （4,3,2,1））
我找到了一个：
(define (find n sum)
(cond ((<= sum 0) (list '()))
((<= n 0) '())
(else (append
(find (- n 1) sum)
(map (lambda (x) (cons n x))
(find (- n 1) (- sum n)))))))
但它效率低下，我想要一个更好的。谢谢。
答案 0 :(得分：2)
您正在寻找的算法称为integer partition。我在my blog处有几个实现。
编辑：奥斯卡因为我的不完整答案而恰当地嘲笑我。作为忏悔，我提供了这个答案，希望澄清一些事情。
我喜欢奥斯卡对流的使用 - 作为我应该SRFI-41的作者。但扩大powerset只是为了抛弃大部分结果似乎是解决问题的一种落后方式。我喜欢GoZoner答案的简单性，但不是它的低效率。
让我们从GoZoner的答案开始，我在下面重复一些小的改动：
(define (fs n s)
(if (or (<= n 0) (<= s 0)) (list)
(append (if (= n s) (list (list n))
(map (lambda (xs) (cons n xs))
(fs (- n 1) (- s n))))
(fs (- n 1) s))))
这将生成输出集列表：
> (fs 10 10)
((10) (9 1) (8 2) (7 3) (7 2 1) (6 4) (6 3 1) (5 4 1) (5 3 2) (4 3 2 1))
该函数的一个简单变体产生计数而不是集合列表，这将成为本答案其余部分的重点：
(define (f n s)
(if (or (<= s 0) (<= n 0)) 0
(+ (if (= n s) 1
(f (- n 1) (- s n)))
(f (- n 1) s))))
这是该函数的示例运行，包括我的古老和慢速家用计算机上的计时：
> (f 10 10)
10
> (time (f 100 100)
(time (f 100 ...))
no collections
1254 ms elapsed cpu time
1435 ms elapsed real time
0 bytes allocated
444793
那很慢;虽然它适用于小输入，但评估(f 1000 1000)是不可容忍的，因为算法是指数的。问题与天真的斐波纳契算法相同;重复计算相同的子问题。
该问题的常见解决方案是记忆。幸运的是，我们正在使用Scheme进行编程，这样可以很容易地将memoization封装在宏中：
(define-syntax define-memoized
(syntax-rules ()
((_ (f args ...) body ...)
(define f
(let ((results (make-hash hash equal? #f 997)))
(lambda (args ...)
(let ((result (results 'lookup (list args ...))))
(or result
(let ((result (begin body ...)))
(results 'insert (list args ...) result)
result)))))))))
我们使用hash tables中的Standard Prelude和universal hash function中的blog。然后编写函数的memoized版本是一件简单的事情：
(define-memoized (f n s)
(if (or (<= s 0) (<= n 0)) 0
(+ (if (= n s) 1
(f (- n 1) (- s n)))
(f (- n 1) s))))
不是很漂亮吗？唯一的变化是在函数的定义中添加了-memoized;所有参数和函数体都是一样的。但性能大大提高：
> (time (f 100 100))
(time (f 100 ...))
no collections
62 ms elapsed cpu time
104 ms elapsed real time
1028376 bytes allocated
444793
这是一个数量级的改进，几乎没有任何努力。
但这不是全部。由于我们知道问题具有“最优子结构”，因此我们可以使用动态编程。 Memoization从上到下工作，并且必须暂停当前的递归级别，计算（直接或通过查找）较低级别的解决方案，然后在当前递归级别中恢复计算。另一方面，动态编程自下而上工作，因此子解决方案在需要时始终可用。这是我们函数的动态编程版本：
(define (f n s)
(let ((fs (make-matrix (+ n 1) (+ s 1) 0)))
(do ((i 1 (+ i 1))) ((< n i))
(do ((j 1 (+ j 1))) ((< s j))
(matrix-set! fs i j
(+ (if (= i j)
1
(matrix-ref fs (- i 1) (max (- j i) 0)))
(matrix-ref fs (- i 1) j)))))
(matrix-ref fs n s)))
我们使用了matrix functions的Standard Prelude。这比仅仅将-memoized添加到现有函数更有用，但是收益是运行时间的另一个数量级减少：
> (time (f 100 100))
(time (f 100 ...))
no collections
4 ms elapsed cpu time
4 ms elapsed real time
41624 bytes allocated
444793
> (time (f 1000 1000))
(time (f 1000 ...))
3 collections
649 ms elapsed cpu time, including 103 ms collecting
698 ms elapsed real time, including 132 ms collecting
15982928 bytes allocated, including 10846336 bytes reclaimed
8635565795744155161506
我们已经从1254ms变为4ms，这是一个相当惊人的改进范围;最终的程序在时间和空间上都是O（ ns ）。您可以在 http://programmingpraxis.codepad.org/Y70sHPc0运行该计划，该计划包含blog中的所有库代码。
作为特殊奖励，这是define-memoized宏的另一个版本。它使用a-lists而不是散列表，所以它比上面给出的版本慢得多，但是当底层计算很耗时，而你只想要一种简单的方法来改进它时，这可能正是你所需要的：
(define-syntax define-memoized
(syntax-rules ()
((define-memoized (f arg ...) body ...)
(define f
(let ((cache (list)))
(lambda (arg ...)
(cond ((assoc `(,arg ...) cache) => cdr)
(else (let ((val (begin body ...)))
(set! cache (cons (cons `(,arg ...) val) cache))
val)))))))))
对于那些刚刚学习Scheme的人来说，这是一个很好的使用准引用和=>子句中的cond运算符。我不记得我写这个功能的时候了 - 我已经把它放了好几年了 - 但是当我只需要一个快速而肮脏的记忆并且不用担心哈希时，它已经省了很多次表和通用哈希函数。
答案 1 :(得分：0)
这与integer partition问题或subset sum问题类似，但不完全相同。这不是整数分区问题，因为整数分区允许重复的数字（这里我们只允许在范围内出现每个数字）。
虽然它更类似于子集求和问题（可以通过动态编程来或多或少地解决），但是需要调整解决方案以生成添加到给定的所有可能的数字子集。数字，而不仅仅是该问题的原始表述中的一个子集。可以使用Scheme实现动态编程解决方案，但它会有点麻烦，除非使用矩阵库或类似的东西来实现可变表。
这是另一种可能的解决方案，这次生成范围[1, n]的{{3}}并依次检查每个子集以查看总和是否增加了预期值。不过，它仍然是一种蛮力的方法：
; helper procedure for generating a list of numbers in the range [start, end]
(define (range start end)
(let loop ((acc '())
(i end))
(if (< i start)
acc
(loop (cons i acc) (sub1 i)))))
; helper procedure for generating the power set of a given list
(define (powerset set)
(if (null? set)
'(())
(let ((rest (powerset (cdr set))))
(append (map (lambda (element) (cons (car set) element))
rest)
rest))))
; the solution is simple using the above procedures
(define (find n sum)
(filter (lambda (s) (= sum (apply + s)))
(powerset (range 1 n))))
; test it, it works!
(find 10 10)
=> '((1 2 3 4) (1 2 7) (1 3 6) (1 4 5) (1 9) (2 3 5) (2 8) (3 7) (4 6) (10))
<强>更新
之前的解决方案将产生正确的结果，但它在内存使用方面效率低下，因为它会生成整个功率集列表，即使我们只对某些子集感兴趣。在Racket Scheme中，如果我们使用惰性序列，我们可以做得更好并仅根据需要生成值（但请注意 - 第一个解决方案仍然更快！）：
; it's the same power set algorithm, but using lazy streams
(define (powerset set)
(if (stream-empty? set)
(stream '())
(let ((rest (powerset (stream-rest set))))
(stream-append
(stream-map (lambda (e) (cons (stream-first set) e))
rest)
rest))))
; same algorithm as before, but using lazy streams
(define (find n sum)
(stream-filter (lambda (s) (= sum (apply + s)))
(powerset (in-range 1 (add1 n)))))
; convert the resulting stream into a list, for displaying purposes
(stream->list (find 10 10))
=> '((1 2 3 4) (1 2 7) (1 3 6) (1 4 5) (1 9) (2 3 5) (2 8) (3 7) (4 6) (10))
答案 2 :(得分：0)
除非您处理(= n s)案例，否则您的解决方案通常正确无误。这是一个解决方案：
(define (find n s)
(cond ((or (<= s 0) (<= n 0)) '())
(else (append (if (= n s)
(list (list n))
(map (lambda (rest) (cons n rest))
(find (- n 1) (- s n))))
(find (- n 1) s)))))
> (find 10 10)
((10) (9 1) (8 2) (7 3) (7 2 1) (6 4) (6 3 1) (5 4 1) (5 3 2) (4 3 2 1))
我不会声称它特别有效 - 它不是尾递归，也不会记忆结果。这是一个表现结果：
> (time (length (find 100 100)))
running stats for (length (find 100 100)):
10 collections
766 ms elapsed cpu time, including 263 ms collecting
770 ms elapsed real time, including 263 ms collecting
345788912 bytes allocated
444793
>