Question

I have an array:

$data = array(
  1 => array(
    "time" => 1,
    "parent" => array(4)
  ),
  2 => array(
    "time" => 3,
    "parent" => array(4, 5)
  ),
  3 => array(
    "time" => 2,
    "parent" => array(6)
  ),
  4 => array(
    "time" => 1,
    "parent" => array(6)
  ),
  5 => array(
    "time" => 1,
    "parent" => array(4)
  ),
  6 => array(
    "time" => 1,
    "parent" => array()
  )
);

Key is the ID of an element, parent is an array of elements, which refers to element id and time is just an integer.

This is an illustrated example of a given array:

Schema

The integer on the bottom-left is the “id” and the integer in the middle is “time”.

My goal here is find the most time-consuming path of this array. In the given example, the path would be 2->5->4->6 (id wise) resulting in 6 “time” overall. It looks pretty easy on paper, however I can’t really seem to code an algorythm to get the elements of the most time-consuming path. I would appreciate any kind of help.

I think the algorythm should be kind of bruteforce-ish and check through all of the options available. Thus with the given array it would go like:

1 -> 4 -> 6 = 3
2 -> 4 -> 6 = 5
2 -> 5 -> 4 -> 6 = 6 
3 -> 6 = 3
4 -> 6 = 2
5 -> 4 -> 6 = 3

Thanks in advance.

Answer 1

Note that this will only work if there are no loops in the array.

// Note: built this in the SO editor, might have bugs
$cached = [];
$arrays = []; // Do this yourself

function get_path($num) {
    global $arrays, $cached;
    if (isset($cached[$num])) return $cached[$num];

    $array = $arrays[$num];
    $maxtime = $array['time'];
    $bestpath = array($num);
    foreach ($array['parent'] as $i) {
        $path = get_path($i);
        if ($path['time']+$array['time'] > $maxtime) {
            $maxtime = $path['time'] + $array['time'];
            $bestpath = array_merge(array($num),$path['path']);
        }
    }

    $cached[$num] = array('path' => $bestpath, 'time' => $maxtime);
    return $cached[$num];
}

var_dump(get_path(5));

Not really a bruteforce way, should be close enough to O(n). The basic idea is that you just cache the paths it can take.

Note: I used a bit of C-style syntax here, but ideally you wouldn’t actually write the code like this