Optimization 和茱莉亚一起解谜

我正在尝试使用Julia来解决常见的游戏15难题，使用Julia使用*算法。我对这门语言很陌生，我的风格可能很像C。当我尝试以下代码时，我的内存不足。我不确定这是否与在我的结构中使用指针样式有关，还是与糟糕的设计有关

struct Node
    parent
    f::Int64
    board::Array{Int64,1}
end

function findblank(A::Array{Int64,1})
    x = size(A,1)
    for i = 1:x
        if A[i] == x
            return i
        end
    end
    return -1
end

function up(A::Array{Int64,1})
    N = size(A,1)
    Nsq = isqrt(N)
    blank = findblank(A)
    B = copy(A)
    if blank / Nsq <= 1
        return nothing
    end
    B[blank-Nsq],B[blank] = B[blank],B[blank-Nsq]
    return B
end

function down(A::Array{Int64,1})
    N = size(A,1)
    Nsq = isqrt(N)
    blank = findblank(A)
    B = copy(A)
    if (blank / Nsq) > (Nsq -1)
        return nothing
    end
    B[blank+Nsq],B[blank] = B[blank],B[blank+Nsq]
    return B
end

function left(A::Array{Int64,1})
    N = size(A,1)
    Nsq = isqrt(N)
    blank = findblank(A)
    B = copy(A)
    if (blank % Nsq) == 1
        return nothing
    end
    B[blank-1],B[blank] = B[blank],B[blank-1]
    return B
end

function right(A::Array{Int64,1})
    N = size(A,1)
    Nsq = isqrt(N)
    blank = findblank(A)
    B = copy(A)
    if (blank % Nsq) == 0
        return nothing
    end
    B[blank+1],B[blank] = B[blank],B[blank+1]
    return B
end

function manhattan(A::Array{Int64,1})
    N = size(A,1)
    Nsq = isqrt(N)
    r = 0
    for i in 1:N
        if (A[i]==i || A[i]==N)
            continue
        end
        row1 = floor((A[i]-1) / Nsq)
        col1 = (A[i]-1) % Nsq
        row2 = floor((i-1) / Nsq)
        col2 = (i-1) % Nsq
        r+= abs(row1 - row2) + abs(col1 - col2)
    end
    return r
end  

# start = [1,2,3,4,5,6,7,9,8]
# start = [6,5,4,1,7,3,9,8,2] #26 moves
start = [7,8,4,11,12,14,10,15,16,5,3,13,2,1,9,6] # 50 moves
goal = [x for x in 1:length(start)]
# println("The manhattan distance of $start is  $(manhattan(start))")
g = 0
f = g + manhattan(start)
pq = PriorityQueue()
actions = [up,down,left,right]
dd = Dict{Array{Int64,1},Int64}()
snode = Node(C_NULL,f,start)
enqueue!(pq,snode,f)
pos_seen = 0
moves = 0
while (!isempty(pq))
    current = dequeue!(pq)
    if haskey(dd,current.board)
        continue
    else
        push!(dd, current.board =>current.f)
    end
    if (current.board == goal)
        while(current.board != start)
            println(current.board)
            global moves +=1
            current = current.parent[]
        end
        println(start)
        println("$start solved in $moves moves after looking at $pos_seen positions")
        break
    end
    global pos_seen+=1
    global g+=1
    for i in 1:4
        nextmove = actions[i](current.board)
        if (nextmove === nothing || nextmove == current.board || haskey(dd,nextmove))
            continue
        else
            global f = g+manhattan(nextmove)
            n = Node(Ref(current),f,nextmove)
            enqueue!(pq,n,f)
        end
    end
end
println("END")

struct节点
父母亲
f:：Int64
线路板：：数组{Int64,1}
结束
函数findblank（A:：数组{Int64,1}）
x=尺寸（A，1）
对于i=1:x
如果A[i]==x
返回i
结束
结束
返回-1
结束
函数up（A：：数组{Int64,1}）
N=尺寸（A，1）
Nsq=isqrt（N）
blank=findblank（A）
B=副本（A）
如果为空/Nsq（Nsq-1）
一无所获
结束
B[blank+Nsq]，B[blank]=B[blank]，B[blank+Nsq]
返回B
结束
函数左（A:：数组{Int64,1}）
N=尺寸（A，1）
Nsq=isqrt（N）
blank=findblank（A）
B=副本（A）
如果（空白%Nsq）==1
一无所获
结束
B[blank-1]，B[blank]=B[blank]，B[blank-1]
返回B
结束
函数权限（A:：数组{Int64,1}）
N=尺寸（A，1）
Nsq=isqrt（N）
blank=findblank（A）
B=副本（A）
如果（空白%Nsq）==0
一无所获
结束
B[blank+1]，B[blank]=B[blank]，B[blank+1]
返回B
结束
函数（A:：数组{Int64,1}）
N=尺寸（A，1）
Nsq=isqrt（N）
r=0
因为我在1:N
if（A[i]==i | A[i]==N）
持续
结束
第1行=楼层（（A[i]-1）/Nsq）
col1=（A[i]-1）%Nsq
第2行=楼层（（i-1）/Nsq）
col2=（i-1）%Nsq
r+=abs（第1列-第2列）+abs（第1列-第2列）
结束
返回r
结束
#开始=[1,2,3,4,5,6,7,9,8]
#开始=[6,5,4,1,7,3,9,8,2]#26步
开始=[7,8,4,11,12,14,10,15,16,5,3,13,2,1,9,6]#50步
目标=[x代表x在1:length（开始）]
#println（“曼哈顿距离$start为$（曼哈顿（start））”）
g=0
f=g+曼哈顿（起点）
pq=优先级队列（）
动作=[上、下、左、右]
dd=Dict{Array{Int64,1}，Int64}（）
snode=节点（C_NULL，f，start）
排队！（pq，斯诺德，f）
pos_seen=0
移动=0
而（！isempty（pq））
当前=出列！（pq）
如果haskey（dd，当前板）
持续
其他的
推（dd，current.board=>current.f）
结束
如果（current.board==目标）
while（current.board！=开始）
println（当前线路板）
全局移动+=1
当前=当前。父项[]
结束
println（开始）
println（“$start solved in$moves moves，在查看$pos\u seed positions后）
打破
结束
全局位置+=1
全局g+=1
因为我在1:4
nextmove=操作[i]（当前板）
if（nextmove==nothing | | nextmove==current.board | | haskey（dd，nextmove））
持续
其他的
全球f=g+曼哈顿（下一个移动）
n=节点（参考（当前），f，下一个移动）
排队！（pq，n，f）
结束
结束
结束
println（“结束”）

Whoah。不，这不是惯用的Julia代码：D一旦错误被修复，如果你愿意的话，我很乐意指出改进之处。这看起来像是我的家庭作业，而不是实际的Julia问题。我同意这不是惯用的Julia代码。所以对于这类问题来说，这不是一个好地方。我的建议是把它缩小到一个问题，而不是“如何做家庭作业”啊，好的。明白了。其实不是家庭作业…只是努力学习语言。我的最后一个解决方案是C++，所以我猜它会显示出来。需要学习一些这个惯用的朱莉娅……而且所采取的观点不是这个问题的立足之地。哇。不，这不是惯用的Julia代码：D一旦错误被修复，如果你愿意的话，我很乐意指出改进之处。这看起来像是我的家庭作业，而不是实际的Julia问题。我同意这不是惯用的Julia代码。所以对于这类问题来说，这不是一个好地方。我的建议是把它缩小到一个问题，而不是“如何做家庭作业”啊，好的。明白了。其实不是家庭作业…只是努力学习语言。我的最后一个解决方案是C++，所以我猜它会显示出来。需要学习一些这个惯用的Julia…，而这一点并不是这个问题的立足之地。