10

对于大学,我必须实现一种算法,为给定的边长和特定的总和创建所有可能的幻方。对于 n=3,算法按预期工作。但是当一段时间后为 n=4 生成所有幻方时,我的内存不足。任务描述中已经提到了这个问题。我已经尝试优化 a 代码,但它仍然无法正常工作。所以我希望有人能给我一些建议。

我的基本想法是:首先我生成所有可能的行,我可以使用给定的数字,然后我试图以一种完全满足幻方限制的方式组合这些行。这是通过回溯发生的。我认为问题是在makeRows存储所有行之后消耗太多内存的函数。

如果您需要我可以提供的代码的更多解释!

magicSquare(N, Value) ->
    Squares = buildSquare(N, makeRows(N, N*N, Value, N)),
    io:fwrite("Squares ready"), io:fwrite("~n"),
    Result = lists:filter(fun(X) -> testsquare(X, N, Value) end, Squares),
    io:write(length(Result)),
    Result.

buildSquare(0, _) -> [[]];
buildSquare(Rows, AvailableRows) ->
    [ [X|L] || L <- buildSquare(Rows-1, AvailableRows), X <- AvailableRows, onlyUniqueNumbers(lists:flatten([X|L]))].

onlyUniqueNumbers(List) -> erlang:length(List) == sets:size(sets:from_list(List)).

%produces all possible rows with a dimension of Fields and the Numbers from 1 to Numbers and the right sum for each row
makeRows(0,_,_,_) -> [[]];
makeRows(Fields, Numbers, Value, TargetLength) ->
    [ [X|L] || X <- makeRows(Fields-1, Numbers, Value, TargetLength), L <- lists:seq(1,Numbers), checkRow([X|L], TargetLength, Value)].

checkRow(Row, Length, Value) when length(Row) < Length -> true;
checkRow(Row, Length, Value) ->
    Sum = lists:sum(Row),
    if Sum == Value -> true;
    true -> false
    end.

testsquare(Square, N, Value) -> checkAllDiagonal(Square, Value) andalso checkAllHorizontal(Square, Value) andalso checkAllVertical(Square, N, Value).

checkAllHorizontal([H|T], Value) ->
    case checkHorizontal(H, Value, 0) of
        true -> checkHorizontal(lists:nth(1, T), Value, 0);
        false -> false
    end;
checkAllHorizontal([], Value) -> true.

checkHorizontal([H|T], Value, Summe) -> checkHorizontal(T, Value, Summe + H);
checkHorizontal([], Value, Summe) when Summe == Value -> true;
checkHorizontal([], Value, Summe) -> false.

checkAllVertical(Square, N, Value) -> checkAllVertical(Square, N, Value, 1).
checkAllVertical(Square, N, Value, Column) ->
    if
        Column > N -> true;
        true ->
            case checkVertical(Square, Value, 0, Column) of
                true -> checkAllVertical(Square, N, Value, Column + 1);
                false -> false
            end
    end.

checkVertical([], Value, Summe, Column) when Summe == Value -> true;
checkVertical([], Value, Summe, Column) -> false;
checkVertical([H|T], Value, Summe, Column) -> checkVertical(T, Value, Summe + lists:nth(Column, H), Column).

checkAllDiagonal(Square, Value) ->
    case checkDiagonal(Square, Value, 0, 1,1) of
        true -> case checkDiagonal(Square, Value, 0, length(lists:nth(1, Square)),-1) of
                            true -> true;
                            false -> false
                        end;
        false -> false
    end.

checkDiagonal([H|T], Value, Summe, Position, Richtung) -> checkDiagonal(T, Value, Summe + lists:nth(Position, H), Position + Richtung, Richtung);
checkDiagonal([], Value, Summe, Position, Richtung) when Summe == Value -> true;
checkDiagonal([], Value, Summe, Position, Richtung) -> false.

好的,我尝试在计算过程的早期添加对行和正方形的检查。以下是修改后的功能。

buildSquare(0, _, _, _) -> [[]];
buildSquare(Rows, AvailableRows, RowLength, Value) ->
    [ [X|L] || L <- buildSquare(Rows-1, AvailableRows, RowLength, Value), X <- AvailableRows, validateSquare([X|L], RowLength, Value)].

checkOnlyUniqueNumbers(List) -> erlang:length(lists:flatten(List)) == sets:size(sets:from_list(lists:flatten(List))).

validateSquare(List, RowLength, Value) when length(List) == RowLength -> testsquare(List, RowLength, Value) andalso checkOnlyUniqueNumbers(List);
validateSquare(List, _,_) -> checkOnlyUniqueNumbers(List).

%produces all possible rows with a dimension of Fields and the Numbers from 1 to Numbers
makeRows(0,_,_,_) -> [[]];
makeRows(Fields, Numbers, Value, TargetLength) ->
    [ [X|L] || L <- makeRows(Fields-1, Numbers, Value, TargetLength), X <- lists:seq(1,Numbers), checkRow([X|L], TargetLength, Value)].

%Checks if the sum of the row is Value when the row has the needed length Length
checkRow(Row, Length, _) when length(Row) < Length -> checkOnlyUniqueNumbers(Row);
checkRow(Row, _, Value) ->
    Sum = lists:sum(Row),
    Sum == Value andalso checkOnlyUniqueNumbers(Row).
4

2 回答 2

9

嗯,erlang 并不懒惰,所以

magicSquare(N, Value) ->
    Squares = buildSquare(N, makeRows(N, N*N, Value, N)),

当使用参数 4 和 34 调用时,尝试使用它们之间从 1 到 16(包括)的所有数字来构建四行的所有 3121348608 个可能组合的列表,每行总和为 34。

即使每个方格只占用 16 个字节(每个单元格一个),也需要大约 48GB 的​​内存,这还不包括列表开销。

你的算法可以用一种懒惰的语言工作——尽管速度很慢。但是在非惰性语言中,您需要越来越早地进行修剪,或者选择完全不同的算法。

您可以测试垂直线和对角线是否有机会求和已经在 中的目标值buildSquare,这可能会将内存需求推低到足以适合 4×4 幻方的内存(但我不太相信) . 如果您只构建(N-1)×N网格并从垂直总和计算最后一行,这将减少Squares另一个因子的大小N!,这将有更好的机会与早期的修剪一起适应内存(对于N == 4,而不是真正的更大的)。N

但是你应该重组你的算法以尽早使用约束。假设您检查第一行1 2 15 16。然后你知道1左列下面的三个数字,以及主对角线上剩下的三个数字的总和必须是 33。所以你需要从{ 3,4,5,6,7,8,9,10,11,12,13,14}总和到 66 中选择一组六个数字。这些选择并不多六个数,因为其中最大的六个加起来只有 69,所以你有

6, 10, 11, 12, 13, 14
7,  9, 11, 12, 13, 14
8,  9, 10, 12, 13, 14

只有三种可能。底角的两个数字也受右列和主要东北对角线的约束。将这些约束一起考虑进一步限制了搜索空间。

如果你按顺序考虑可能的方块,一个接一个的顶行,并且不存储候选者[你可以存储神奇的 4×4 方块,它们不会太多],你可以找到所有小方块内存,并且如果您以一种好的方式处理约束,甚至相对较快。

于 2012-12-13T13:31:48.533 回答
0

我有一个可能会有所帮助的方向。我几乎让它工作了,但在接下来的几天里将无法花任何时间在它上面。

首先,我相信这个问题是 NP 完全问题,这表明随着输入大小线性增加,您将使用指数内存或时间。

无论如何,这是我的方法:

  1. 如果您的幻方涉及数字 1..N,您将为这些 N 数字创建所有排列。毕竟,magicSquare(3,15) 将是 1..15 所有可能排列的子集

  2. 诀窍是如果它所代表的所有行的总和不等于幻数,则在生成每个排列时删除它。通过这种方式,您不会存储所有排列,只存储那些非常有希望的排列,从而避免指数记忆(但不是指数时间)。换句话说,与生成每个排列一致,只有当它可能是一个幻方时才保存它。我使用列表推导在生成器上使用限定符创建排列,该生成器进行了测试以确保所有行正确求和

  3. 我的测试函数采用了一个指示行长度的参数(在这种情况下为 3),并且能够检查 [8,1,6,3,5,7,4,9,2] 的排列并确定每一行(每个子列表 1-3、4-6,7-9 总和为 15。
  4. 在获得至少每一行总和为幻数的排列之后,然后过滤其余的 MN 标准。

顺便说一句,确保您创建排列的算法是尾递归的。

再一次,这似乎对我有用(除非它不是;)),但我已经离开我的电脑几天了。

希望这会有所帮助。

于 2012-12-23T18:17:35.970 回答