算法笔记-分支界限法

　　（1）广度优先

　　   说明： 

      　　　　

　　代码：

<?php

$arr = [
    'A' => [
        'B' => [
            'D' => ['H', 'I'],
            'E' => ['J'],
            'F',
        ],
        'C' => ['G'],
    ],
];

//直接用数组遍历
//print_R(bfsArr($arr));


//先将数组转成树, 再遍历
//$tree = current(buildTree($arr));
//$queue = [$tree->val];
//print_r(bfsObj([$tree]));


function bfsArr($queue) {
    static $res;
    $val = key($queue);
    $out = array_shift($queue);
    if (is_array($out)) {
        $res[] = $val;
        $queue = array_merge($queue, $out);
    } else {
        $res[] = $out;
    }
    
    if (!empty($queue)) {
        bfsArr($queue);
    }
    return $res;
}

function bfsObj($queue) {
    static $res;
    $out = array_shift($queue);
    $res[] = $out->val;
    $queue = array_merge($queue, $out->nodes);
    
    if (!empty($queue)) {
        bfsObj($queue);
    }
    return $res;
}


function buildTree($arr) {
    $ret = array();
    if (is_array($arr)) {
        foreach ($arr as $k => $v) {
            if (is_numeric($k)) {
                $tree = nodeFactory($v);
            } else {
                $tree = nodeFactory($k);
                $tree->nodes = buildTree($v);  
            }
            $ret[] = $tree;
        }
    } else {
        return nodeFactory($arr);
    }
    return $ret;
}


function nodeFactory($val) {
    $node = new stdClass();
    $node->val = $val;
    $node->nodes = array();
    return $node;
}

　　（2）0-1背包

　　   说明： 

 　　代码：

<?php
$weights = [2, 5, 4, 2];
$values = [6, 3, 5, 4];
$limit = 10;
print_r( bfs());

function bfs($queue = []) {
    static $res;
    global $values;
    
    $node = (array)array_shift($queue);
    $val = celSum($node, $values);
    $res[$val][] = $node;
    $queue = array_merge($queue, childNodes($node));
    
    if (!empty($queue)) {
        bfs($queue);
    }
    ksort($res);
    return end($res);
}

function childNodes($node) {
    global $weights, $values, $limit;
    static $maxVal;
    
    $childNodes = array();
    $nextKey = count($node);
    if (!isset($values[$nextKey])) {
        return array();
    }
    
    //剩余的都装进去的价值
    $fill = array_fill($nextKey, count($weights) - $nextKey, 1);
    $allIn = array_merge($node, $fill);
    $allInVal = celSum($allIn, $values);
    if ($allInVal < $maxVal) {
        return array();
    }
    
    //当前总重量
    $weight = celSum($node, $weights);
    $value = celSum($node, $values);
    
    if ($weight + $weights[$nextKey] <= $limit) {
        $childNodes[] = array_merge($node, [$nextKey => 1]);
        $value += $values[$nextKey];
    }
    $childNodes[] = array_merge($node, [$nextKey => 0]);
    
    //更新最优值
    $maxVal = max($value, $maxVal);
    
    return $childNodes;
}


function celSum($queue, $values) {
    $sum = 0;
    foreach ($queue as $k => $v) {
        $sum += $v * $values[$k];
    }
    return $sum;
}

　（3）旅行商问题

　　   说明： 

　　　　

　　代码：

<?php
$map = [
    [0, 15, 30, 5],
    [15, 0, 6, 12],
    [30, 6, 0, 3],
    [4, 12, 3, 0],
];

$p = [1, 2, 3, 4];      //表示4个景点
$begin = [1];
print_r(bfs([$begin]));

function bfs($queue) {
    static $res;
    $node = array_shift($queue);
    $childs = childNodes($node);
    empty($childs) && $res[celSum($node)][] = $node;
    $queue = array_merge($queue, $childs);
    
    if (!empty($queue)) {
        bfs($queue);
    }
    krsort($res);
    return end($res);
}

function childNodes($node) {
    global $p;
    $remaind = array_diff($p, $node);
    $childNodes = array();    
    foreach ($remaind as $v) {
        $childNodes[] = array_merge($node, [$v]);
    }
    return $childNodes;
}

function celSum($queue) {
    $distance = 0;
    foreach ($queue as $k => $p) {
        if (isset($queue[$k + 1])) {
            $distance += distance($queue[$k], $queue[$k + 1]);
        }
    }
    return $distance;
}

function distance($p1, $p2) {
    global $map;
    return $map[$p1 - 1][$p2 - 1];
}

　（4）最优工程布线

　　   说明： 

　　　　　　

　　 代码：

<?php
$map = [
    [0, 0, 0, 0, 0, -1],
    [0, 0, -1, 0, 0, 0],
    [0, 0, 0, -1, -1, 0],
    [0, -1, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0],
];

$a = [1, 0];
$b = [3, 5];

print_r(bfs([[$a]]));

function bfs($queue) {
    global $b;
    static $res = array();
    $path = array_shift($queue);
    $nextPath = searchPath($path);
    
    //找到目标点
    if (in_array($b, $nextPath)) {
        array_push($path, $b);
        array_push($res, $path);
        $nextPath = [];
    }
    
    foreach ($nextPath as & $v) {
        $v = array_merge($path, [$v]);
    }
    $queue = array_merge($queue, $nextPath);
    
    //硬跑太吃内存了, 这里作个优化
    $queue = array_filter($queue, 'isContinue');
    $queue && bfs($queue);
    return $res;
}

function searchPath($path) {
    global $map;
    
    //上下左右四个点
    $end = end($path);
    $nodes = [
        [$end[0] + 1, $end[1]],
        [$end[0] - 1, $end[1]],
        [$end[0], $end[1] + 1],
        [$end[0], $end[1] - 1],
    ];
    return array_filter($nodes, function ($node) use ($path, $map){
        return isset($map[$node[0]][$node[1]]) && $map[$node[0]][$node[1]] === 0 && !in_array($node, $path);
    });
}

function isContinue($path) {
    //用于记录从出发点开始到其他点的最短距离
    static $min = array();
    $end = end($path);
    $len = count($path);
    $key = join('_', $end);
    
    if (isset($min[$key]) && $len > $min[$key]) {
        return false;
    } else {
        $min[$key] = $len;
        return true;
    }
}