2. 程式人生 > >遺傳演算法解決推箱子問題

遺傳演算法解決推箱子問題

阿新 • • 發佈：2018-10-31

遺傳演算法

遺傳演算法（Genetic Algorithm）是一類借鑑生物界的進化規律（適者生存，優勝劣汰遺傳機制）演化而來的隨機化搜尋方法。最早聽說這個演算法是在一門公選課上，當時瞭解的還包括蟻群演算法等。總之，這種演算法通過模擬自然界物種的繁衍，來尋找適宜生存的種群，達到尋找相對優解的過程。這種方法可以很好的避免我們的演算法找到區域性最優解之後就停滯不前。

推箱子問題

推箱子相比大家都玩過，在地圖上，玩家控制小人把地圖上的箱子推到指定的位置。這個問題看似十分簡單，但當地圖變得十分大，箱子非常多的時候，這個問題實際上並不好解決。本文旨在使用遺傳演算法，自動求解推箱子問題，雖然從實際效果來看，不甚理想，可改進的地方很多，但是也可看作對遺傳演算法和數學建模的一次很好的初級實踐。

本文推箱子地圖的表示參考這個網站：http://sokoban.cn/ 裡面推箱子的問題都十分有趣，可以嘗試一下。

遺傳演算法的流程

圖片來自超詳細的遺傳演算法解析

下面，我們根據演算法流程，逐步求解該問題。

遺傳演算法求解推箱子問題

（1）編碼

我們定義0代表向上，1代表向下，2代表向左，3代表向右。因此給定一個數組，便可確定玩家的所有動作。

（2）推箱子問題環境程式設計

根據上文關於推箱子地圖的定義，@代表玩家，#代表牆，-代表空地，·代表目標點，$代表箱子。為方便起見，目標點我直接通過一個靜態陣列宣告。

----#####----------
----#---#----------
----##--#----------
--###--###---------
--#--#-#-#---------
###################
#-------##----$-.$#
#-------##
 
[email protected]$#
#####---##----$-.$#
--------###########
----#######--------

上面為我們這次測試用的地圖（極其簡單）。

target_points = [[6, 16], [6, 17], [7, 16], [7, 17], [8, 16], [8, 17]]

# 讀取推箱子地圖
def read_to_matrix():
    matrix = []
    f = open("test.txt")
    line = f.readline()
    while line:
        matrix_line = []
        for char in line:
            matrix_line.append(char)
        matrix.append(matrix_line)
        line = f.readline()
    np.array(matrix)
    f.close()
    return matrix


# 尋找玩家位置
def find_person(matrix):
    for i in range(0, 11):
        for j in range(0, 19):
            if matrix[i][j] == '@':
                return i, j
    return -1, -1


# 計算箱子到目標點的最近曼哈頓距離
def calculate_points(matrix):
    points = 0
    for i in range(0, 11):
        for j in range(0, 19):
            if matrix[i][j] == '$':
                distances = []
                for point in target_points:
                    distance = abs(i - point[0]) + abs(j - point[1])
                    distances.append(distance)
                points = points + min(distances)
    return points


# 移動
def move(matrix, direction):
    if direction == 0:
        if up(matrix):
            return True
        return False
    elif direction == 1:
        if down(matrix):
            return True
        return False
    elif direction == 2:
        if left(matrix):
            return True
        return False
    elif direction == 3:
        if right(matrix):
            return True
        return False


def up(matrix):
    i, j = find_person(matrix)
    if i > 0:
        up_i = i - 1
        if matrix[up_i][j] == '-' or matrix[up_i][j] == '.':
            matrix[i][j] = '-'
            matrix[up_i][j] = '@'
            return True
        elif matrix[up_i][j] == '#':
            return False
        elif matrix[up_i][j] == '$':
            if up_i > 0:
                box_up = up_i - 1
                if matrix[box_up][j] == '-' or matrix[box_up][j] == '.':
                    matrix[i][j] = '-'
                    matrix[up_i][j] = '@'
                    matrix[box_up][j] = '$'
                    return True
                else:
                    return False
            else:
                return False
    else:
        return False


def down(matrix):
    i, j = find_person(matrix)
    if i < 10:
        down_i = i + 1
        if matrix[down_i][j] == '-' or matrix[down_i][j] == '.':
            matrix[i][j] = '-'
            matrix[down_i][j] = '@'
            return True
        elif matrix[down_i][j] == '#':
            return False
        elif matrix[down_i][j] == '$':
            if down_i < 10:
                box_down = down_i - 1
                if matrix[box_down][j] == '-' or matrix[box_down][j] == '.':
                    matrix[i][j] = '-'
                    matrix[down_i][j] = '@'
                    matrix[box_down][j] = '$'
                    return True
                else:
                    return False
            else:
                return False
    else:
        return False


def left(matrix):
    i, j = find_person(matrix)
    if j > 0:
        left_j = j - 1
        if matrix[i][left_j] == '-' or matrix[i][left_j] == '.':
            matrix[i][j] = '-'
            matrix[i][left_j] = '@'
            return True
        elif matrix[i][left_j] == '#':
            return False
        elif matrix[i][left_j] == '$':
            if left_j > 0:
                box_left = left_j - 1
                if matrix[i][box_left] == '-' or matrix[i][box_left] == '.':
                    matrix[i][j] = '-'
                    matrix[i][left_j] = '@'
                    matrix[i][box_left] = '$'
                    return True
                else:
                    return False
            else:
                return False
    else:
        return False


def right(matrix):
    i, j = find_person(matrix)
    if j < 18:
        right_j = j + 1
        if matrix[i][right_j] == '-' or matrix[i][right_j] == '.':
            matrix[i][j] = '-'
            matrix[i][right_j] = '@'
            return True
        elif matrix[i][right_j] == '#':
            return False
        elif matrix[i][right_j] == '$':
            if right_j < 18:
                box_left = right_j + 1
                if matrix[i][box_left] == '-' or matrix[i][box_left] == '.':
                    matrix[i][j] = '-'
                    matrix[i][right_j] = '@'
                    matrix[i][box_left] = '$'
                    return True
                else:
                    return False
            else:
                return False
    else:
        return False


#根據陣列移動
def sequence_move(move_array, matrix):
    for direction in move_array:
        if move(matrix, direction):
            continue
        else:
            move_array.remove(direction)
    return calculate_points(matrix)

（3）確定程式所用引數

change_rate = 0.05        #變異率
expel_rate = 0.5          #淘汰率
initial_length = 10       #初始移動步數
max_length = 50           #最大移動步數
add_step = 10             #每次增加的步長
max_epoch = 2000          #最大迭代次數
sample = 100              #種群數量
mix_length = 3            #基因混合長度
animals = []

（4）初始化種群

class Animal:
    def __init__(self, move_array, points):
        self.move_array = move_array
        self.points = points


#初始化種群
for i in range(0,sample):
    change_matrix = read_to_matrix()
    move_array = []
    for j in range(0,initial_length):
        move_array.append(random.randint(0,3))
    points = sequence_move(move_array,change_matrix )
    animals.append(Animal(move_array,points))
animals.sort(key=lambda x:x.points,reverse=False)

（5）計算種群適應度

我們定義適應度函式為所有箱子到最近目標點的曼哈頓距離，當該距離為0時，我們可以確定所有的箱子到達目標點，遊戲成功。

其實在上述初始化種群的過程中，計算種群適應度已經完成，這個函式上面已經出現過了。函式如下：

# 計算箱子到目標點的最近曼哈頓距離
def calculate_points(matrix):
    points = 0
    for i in range(0, 11):
        for j in range(0, 19):
            if matrix[i][j] == '$':
                distances = []
                for point in target_points:
                    distance = abs(i - point[0]) + abs(j - point[1])
                    distances.append(distance)
                points = points + min(distances)
    return points

（6）選擇淘汰

這裡我們採用最最簡單的淘汰辦法（其實這樣不大好），直接根據淘汰率，選擇適應度最差的個體淘汰。

因此排序之後，直接：

animals = animals[0:50]

（7）變異

根據變異率，隨機的進行變異，考慮到這是一個不斷增長的序列，因此也要有一定機率隨機增加染色體的基因。

# 變異
def variation(animals):
    for animal in animals:
        if animal.points!=0:
            for m in range(0,len(animal.move_array)):
                ret = random.random()
                if ret<change_rate:
                    animal.move_array[m] = random.randint(0,3)
                elif ret<2*change_rate and len(animal.move_array)<max_length:
                    animal.move_array.insert(m,random.randint(0,3))
    return animals

（8）複製

根據mix_length，隨機選擇父本或母本的基因繼承，考慮到這是一個不斷增長的序列，在不超過最大序列長度限制的前提下，每次隨機在尾部增加幾位。

# 複製
def hybridize(parents):
    child = []
    father = parents[0]
    mather = parents[1]
    i = 0
    while i < len(father.move_array)-mix_length and i < len(mather.move_array)-mix_length:
        flag =  random.randint(0,1)
        if flag == 0:
            for j in range(0,mix_length):
                child.append(father.move_array[i+j])
        else:
            for j in range(0,mix_length):
                child.append(mather.move_array[i+j])
        i = i+mix_length
    if len(child)<max_length:
        for k in range(0,add_step):
            child.append(random.randint(0,3))
    return child

（9）迴圈往復

#種群迭代
for k in range(0,max_epoch):
    animals = animals[0:50]
    animals = variation(animals)    #變異
    for n in range(0,50):
        change_matrix = read_to_matrix()
        # 交配增殖
        parents = random.sample(animals, 2)
        child_array = hybridize(parents=parents)
        points = sequence_move(child_array,change_matrix)
        animals.append(Animal(child_array,points))
    animals.sort(key=lambda x: x.points,reverse=False)
    print(animals[0].points)
    if animals[0].points==0:
        print(animals[0].move_array)
        break

具體程式碼見我的github:genetic-algorithm

參考

超詳細的遺傳演算法解析

十分鐘搞懂遺傳演算法

相關推薦

遺傳演算法解決推箱子問題

遺傳演算法 遺傳演算法（Genetic Algorithm）是一類借鑑生物界的進化規律（適者生存，優勝劣汰遺傳機制）演化而來的隨機化搜尋方法。最早聽說這個演算法是在一門公選課上，當時瞭解的還包括蟻群演算法等。總之，這種演算法通過模擬自然界物種的繁衍，來尋找適宜生存的種群，達到尋找相

人工智慧-遺傳演算法解決推箱子問題現實

由於各種原因，可能存在諸多不足，歡迎斧正！ 一、研究背景    推箱子游戲中的路徑查詢問題—給定一方格，求兩點最短距離。    傳統求兩點最短路徑的演算法有：      1.通用的搜尋演算法      2.解決無負權邊的帶權有向圖的單源最短路問題的Dijkstra演算

遺傳演算法解決尋路問題——Python描述

概要 我的上一篇寫遺傳演算法解決排序問題，當中思想借鑑了遺傳演算法解決TSP問題，本質上可以認為這是一類問題，就是這樣認為：尋找到一個序列X，使F（X）最大。 詳解介紹 排序問題：尋找一個序列，使得這個序列的逆序對的倒數最大。 TSP問題：尋找一個序列，使得這個序列的總路徑長的倒數最大。 這兩個問題

數學建模 of python(用遺傳演算法解決TSP問題)

吉吉： 在這個問題中，我們的個體就是一條一條的路線了，其目的就是找到一條總距離最短的路線。基本步驟與前兩篇文章基本類似，不過在本問題中，我們用城市路線中每個城市的經緯度來表示個體(城市路線)的DNA。 在產生後代的過程中，需要注意的是，因為我們的個體是路線，所以不能將兩個

matlab手寫遺傳演算法解決一元函式最值問題（例項）

問題：找出y=x4-4x3+3x+5 （xÎ[0,6]）在[0,6]之間的最小值。 思路：用33位0，1變數來編碼x,3位編碼整數，30位編碼小數。理論上30位編碼小數可以將最小值對應的x精確到小數點後九位. 下面是我解決這個問題所有的函式，複製就可以運行了，不明白可以私

遺傳演算法解決TSP旅行商問題（附：Python實現）

前言 我先囉嗦一下：不是很喜歡寫計算智慧的演算法，因為一個演算法就要寫好久。前前後後將近有兩天的時間。 好啦，現在進入正題。 巡迴旅行商問題(TSP)是一個組合優化方面的問題，已經成為測試組合優化新演算法的標準問題。應用遺傳演算法解決 TSP 問題，首先對訪問

遺傳演算法解決單變數函式值得優化問題

      最近稍微學習一下智慧演算法的設計，就滿Internet搜尋，最終發現遺傳演算法是大家學習最多的，也是在各個領域內進行函式優化，解析解求解過程中很重要的一種方法！ 學習遺傳演算法，首先為了上手較快，我推薦大家先使用Matlab，這個工具進行矩陣分析有應用，真的很管

初學遺傳演算法解決tsp問題(C++)

前言 斷斷續續學遺傳到現在快一個禮拜了，之前一直在看思想，死想活想，始終不敢去自己程式碼實現。 今天硬著頭皮開始寫，寫不下去就找博文看，總算是初步的實現了，邁出了智慧演算法學習的第一小步，心情不可謂不激動。 好吧，說正經的。 tsp&

使用遺傳演算法解決多變數函式優化問題！

        很多朋友在碰到多變數值優化的問題的時候不能很好的將問題轉化，利用有效編碼的方法將解的個數，解的編碼很好的很合理的進行設計，因此不能利用遺傳演算法進行問題的求解！        其實，簡單的來說，就是將多個變數的數值編碼編排進去，進行組合，只需要增長基因個體的

遺傳演算法解決TSP問題

讀了原作者mylovestart用遺傳演算法實現的tsp問題，學習了ga演算法。 但發現原作者mylovestart的jiaopei()函式寫的有問題，交叉後要確保每個城市有且僅走了一次，修改了jiaopei()的程式碼如下： //交配,對每個染色體產生交配概率,滿足交配

遺傳演算法解決TSP問題實現以及與最小生成樹的對比

摘要： 本實驗採用遺傳演算法實現了旅行商問題的模擬求解，並在同等規模問題上用最小生成樹演算法做了一定的對比工作。遺傳演算法在計算時間和佔用記憶體上，都遠遠優於最小生成樹演算法。 程式採用Microsoft visual studio 2008 結合MFC基本對話方塊類庫開發。32位windows 7系統下除

遺傳演算法解決揹包問題

//總體思想與之前的相似，評價函式就是物品的價值之和，但要注意一旦物品的重量大於揹包的重量，那麼該條染色體的倖存概率為0 //基因就是每一個物品是否選擇，這裡預設有10條染色體在比較，並且每一條染色體上的第i個基因就是代表第i個物品是否選擇 //突變就是隨機選擇的染色體的隨

物流路徑規劃用遺傳演算法解決例項

網上有很多關於遺傳演算法的教程，但基本千篇一律。這次物流課做了一個跟路徑規劃相關的案例，拿出來與大家分享。 先貼案例。案例摘自《企業物流管理》。 《 R&T批發公司》 R&T批發公司給全印度的零售商批發日用商品。公司在全國有很

遺傳演算法解決路線規劃問題（Vehicle Routing Problem based on GA）

I.問題描述 車輛路徑問題（Vehicle Routing Problem,VRP），車輛路徑問題是一種組合優化問題，它由Dantzig 和 Ramser在1959年共同提出。VRP是指一定數量的客戶，各自有不同數量的貨物需求，配送中心向客戶提供貨物，由一個車隊負責分送貨物

遺傳演算法解決車輛路徑問題

車輛路徑問題車輛路線問題（VRP）最早是由Dantzig和Ramser於1959年首次提出，它是指一定數量的客戶，各自有不同數量的貨物需求，配送中心向客戶提供貨物，由一個車隊負責分送貨物，組織適當的行車路線，目標是使得客戶的需求得到滿足，並能在一定的約束下，達到諸如路程最短、

遺傳演算法解決迷宮尋路問題（Java實現）

1.什麼是遺傳演算法？ 就個人理解，遺傳演算法是模擬神奇的大自然中生物“優勝劣汰”原則指導下的進化過程，好的基因有更多的機會得到繁衍，這樣一來，隨著繁衍的進行，生物種群會朝著一個趨勢收斂。而生物繁衍過程中的基因雜交和變異會給種群提供更好的基因序列，這樣種群的繁

C語言編寫遺傳演算法解決TSP旅行商問題

最近在上計算智慧的課，老師剛剛教了遺傳演算法，佈置了用遺傳演算法解決TSP的問題的作業，於是經過幾小時的奮戰，終於編寫完成。 首先先對TSP問題進行分析。TSP問題，也就是旅行商問題，題目的大題內容是 一位旅行商，要遍遊N座城市（城市數量記為NUM_CITY）, 已知每兩座

【搞搞演算法】用遺傳演算法解決多目標規劃問題_論文閱讀筆記

這是2014年4月在其他部落格寫的，轉帖到CSDN的部落格上。 許老師給了很多多目標GA的論文，全英文讀起來比較慢，用Google翻譯+靈格斯詞典解決了詞彙問題，理解起來並不是很難，這也是GA演算法的特點——演算法本身容易理解，演算法知識不全的人（比如我）也能比較快地運用

MATLAB（1）基於遺傳演算法解決最優化問題及相應的MATLAB遺傳工具箱使用

     對於取最小值的最優化問題，遺傳演算法借鑑生物遺傳現象使具有一定數量的候選解的種群向更好的解進化，該方法是通過種群進化，使得適應度函式代入估計引數後達到最值來得到最優解。借鑑生物種群的進化，遺傳演算法先隨機產生一組初始解，作為初始種群，以數值解為例，這些解都是通過二進位制程式碼儲存在計算機中，類似於染

【高階演算法】遺傳演算法解決3SAT問題（C++實現）

1 SAT問題描述 命題邏輯中合取正規化 (CNF) 的可滿足性問題 (SAT)是當代理論電腦科學的核心問題, 是一典型的NP 完全問題.在定義可滿足性問題SAT之前，先引進一些邏輯符號。 一個 SAT 問題是指: 對於給定的 CNF 是否存在一