群体智能算法-黏菌寻找食物最优路线行为模拟

昨天看了一个视频（http://www.tudou.com/programs/view/4QmfLMMBZBg） 讲的就是黏菌 寻找食物时候会构造一个强大的网络。

如下图

通过对黏菌行为的观察。我想通过一个分布式的群体算法来模拟黏菌的行为，来实现最优路径的寻找。

目前实现了简单的行为模拟。 主要有两个方面

1、黏菌的扩张行为。 

首先定义了一个生命力值来模拟。在黏菌的位置，生命力是最强的。随着黏菌的扩张，扩张的边缘的生命力会递减。黏菌会不断的扩张。

2、食物的获取

在这里假设，黏菌的扩张部分只能吸收食物，但不能将食物转换成能量。犹如人体一样，只有胃能够消化食物，将食物转换成能量供人体吸收。

假设黏菌的核心才能将食物转换成能量，其他部分只能是吸收传递能量。

那么表现为能量的传输为从生命力低的地方传送到生命力高的地方，也就只有在黏菌的初始位置。

程序模拟

1、黏菌的各个部分只能从其周围的部分获取到信息。也只能与周围的部分进行信息交流，以及食物的传递。

目前只简单的用数组来演示。没有做界面演示。

首先说明下 数组中的含义【生命力，食物含量，食物传送数量统计】

其中黏菌的初始位置在【10,0,0】处，食物防在图中的【0,5000,0】

源代码如下

package main

import (

    "fmt"

    "sync"

    "time"

)

func main() {

    for {

        select {}

    }

}

var max_x int = 10

var max_y int = 10

var AllPart []Parts

type Parts []*Part

var lock *sync.RWMutex

func Print() {

    tick := time.Tick(1 * time.Second)

    for {

        select {

        case <-tick:

            fmt.Println("-------------------------------------------------")

            lock.Lock()

            for y := 0; y < max_y; y++ {

                for x := 0; x < max_x; x++ {

                    fmt.Printf("%d,%d,%d\t", AllPart[y][x].en, AllPart[y][x].food, AllPart[y][x].countfood)

                }

                fmt.Println()

            }

            lock.Unlock()

        }

    }

}

func init() {

    lock = &sync.RWMutex{}

    AllPart = make([]Parts, max_y, max_y)

    for y := 0; y < max_y; y++ {

        AllPart[y] = Parts(make([]*Part, max_x, max_x))

    }

    for y := 0; y < max_y; y++ {

        for x := 0; x < max_x; x++ {

            AllPart[y][x] = NewPart(x, y)

        }

    }

    AllPart[8][3].en = 10

    AllPart[8][3].ismother = true

    AllPart[3][8].food = 5000

    AllPart[3][8].isfood = true

    for y := 0; y < max_y; y++ {

        for x := 0; x < max_x; x++ {

            go AllPart[y][x].run()

        }

    }

    go Print()

}

type Part struct {

    x    int

    y    int

    en   int

    food int

    countfood int

    ismother bool

    isfood   bool

}

func NewPart(x, y int) *Part {

    p := Part{x, y, 0, 0, 0, false, false}

    return &p

}

func getEn(x, y int) int {

    if x < 0 || y < 0 {

        return -1

    }

    if x >= max_x || y >= max_y {

        return -1

    }

    return AllPart[y][x].en

}

func (p *Part) run() {

    tick := time.Tick(1 * time.Second)

    for !p.ismother {

        select {

        case <-tick:

            func() {

                lock.RLock()

                defer lock.RUnlock()

                max_node := 0

                maxcount := 0

                other := make(map[*Part]int)

                getmax := func(xi, yi int) {

                    en := getEn(xi, yi)

                    if en > p.en {

                        maxcount++

                        other[AllPart[yi][xi]] = en

                    }

                    if en > max_node {

                        max_node = en

                    }

                }

                getmax(p.x-1, p.y-1)

                getmax(p.x, p.y-1)

                getmax(p.x+1, p.y-1)

                getmax(p.x-1, p.y)

                getmax(p.x+1, p.y)

                getmax(p.x-1, p.y+1)

                getmax(p.x, p.y+1)

                getmax(p.x+1, p.y+1)

                if max_node > p.en {

                    p.en = max_node - 1

                }

                if p.en == 0 || p.food <= 0 || maxcount <= 0 {

                    return

                }

                food := p.food

                if p.isfood {

                    food = 8

                }

                avf := food / maxcount

                for k, _ := range other {

                    k.food += avf

                    p.countfood += avf

                    p.food -= avf

                }

            }()

        }

    }

}

龚浩华

qq 29185807 （月牙寂）

2015年3月20日15:16:47

初稿