36 cube iterative solution

<?php

$colors = array(
         1 => 'R',
         2 => 'O',
         4 => 'Y',
         8 => 'G',
        16 => 'B',
        32 => 'P',
        false => 'X',
);

$used_towers = array_fill(0, 6, 0);

$cube = array(
        array(1,3,4,5,2,0),
        array(2,5,1,4,1,3), // note 'special' base at (2, 1) here
        array(0,1,3,2,5,4),
        array(5,4,0,3,0,2), // note 'special' base at (2, 3) here
        array(4,2,5,0,3,1),
        array(3,0,2,1,4,5),
);

$solution = array_fill(0, 6, array_fill(0, 6, false));


function solve_color($color) {
        global $solution, $used_towers, $colors, $cube;

        $orig = $solution;
        $failed = array( );

        $i = 0;
        $j = -1;
        while ($i <= 5) {
                // if we already have a piece in this space (via pre-reqs)
                // just skip it
                if (in_array($color, $orig[$i])) {
                        $i++;
                        $j = -1;
                        continue;
                }

                if ( ! isset($failed[$i])) {
                        $failed[$i] = array( );
                }

                do {
                        $j++;
                        $size = $cube[$i][$j];
                        // we've already tried this one, try the next space
                } while (in_array($size, $failed[$i]) && (5 > $j));

                // try putting a piece in the ith row in the last + 1 col
                if (test_color(($i * 6) + $j, $solution, $used_towers, $color, $size) && ! in_array($size, $failed[$i])) {
                        $solution[$i][$j] = $color;
                        $used_towers[$size] |= $color;
                        $i++;
                        $j = -1;
                        continue;
                }

                // something failed, go back a row and try a new piece
                if (5 <= $j) {
                        // backtrack until we find a row that didn't already have a piece in it
                        do {
                                $i--;
                        } while (in_array($color, $orig[$i]));

                        // find out what piece was used here
                        foreach ($solution[$i] as $j => $col) {
                                if ($color == $col) {
                                        $size = $cube[$i][$j];
                                        $failed[$i][] = $size;
                                        $used_towers[$size] ^= $color;
                                }
                        }

                        $solution[$i] = $orig[$i];
                        $j = -1;
                        continue;
                }
        }

        return $solution;
}


function solve_color_by_pieces($color, $solution, $used_towers, $continue_colors = false, $top = false) {
        global $colors, $cube;

        $orig = $solution;

        $sols = array( );
        while (32 >= $color) {
                $size = 0;

                while (6 >= count(filter_color($used_towers, $color)) && (5 >= $size)) {
                        if ($color & $used_towers[$size]) {
                                $size++;
                                continue;
                        }

                        // find ALL possible solutions for this size
                        for ($pos = 0; $pos < 36; ++$pos) {
                                if ($size != $cube[floor($pos / 6)][$pos % 6]) {
                                        continue;
                                }

                                if ( ! test_color($pos, $solution, $used_towers, $color, $size)) {
                                        continue;
                                }

                                // add to this solution path and continue...
                                $solution[floor($pos / 6)][$pos % 6] = $color;
                                $used_towers[$size] |= $color;
                                $return = ((6 > count(filter_color($used_towers, $color))) ? solve_color_by_pieces($color, $solution, $used_towers, $continue_colors) : array('SOLUTION' => $solution));
                                if ($return) {
                                        $sols[] = $return;
                                }

                                // remove this solution and continue searching this level
                                $solution[floor($pos / 6)][$pos % 6] = false;
                                $used_towers[$size] ^= $color;
                        }

                        break;
                }

                if ($top) {
                        unset($sols);
                        $sols = array( );
                }

                if ($continue_colors) {
                        $color << 1;
                }
                else {
                        break;
                }
        }

        return $sols;
}


// solve for yellow given the initial piece constraint
$color = 4;
$solution[1][2] = $color;
$size = $cube[1][2];
$used_towers[$size] |= $color;
echo solve_color_by_pieces($color, $solution, $used_towers);


// helper functions

function test_color($pos, $solution, $used_towers, $color, $size) {
        if (36 <= $pos) {
                return false;
        }

        // check if piece exists in solution at this location
        if (false !== $solution[floor($pos / 6)][$pos % 6]) {
                return false;
        }

        // check if tower of this size and color has already been used
        if ($color & $used_towers[$size]) {
                return false;
        }

        // check if tower has already been used in row or column:
        for ($i = 0; $i < 6; ++$i) {
                if ($color == $solution[floor($pos / 6)][$i]) {
                        return false;
                }

                if ($color == $solution[$i][$pos % 6]) {
                        return false;
                }
        }

        // special conditions for the two special towers
        if (array(1, 2) == (array(floor($pos / 6), $pos % 6)) && (4 != $color)) {
                return false;
        }

        if (array(3, 2) == (array(floor($pos / 6), $pos % 6)) && (2 != $color)) {
                return false;
        }

        return true;
}


function filter_color($used, $color) {
        foreach ($used as & $row) {
                $row = (bool) ($color & $row);
        }
        unset($row);

        return array_filter($used);
}


function find_sols($sols, $color) {
        foreach ($sols as $key => $sol) {
                if ('SOLUTION' === $key) {
                        foreach ($sol as $i => $row) {
                                foreach ($row as $j => $piece) {
                                        if ($color == $piece) {
                                                echo '$solution['.$i.']['.$j.'] = ';
                                        }
                                }
                        }
                        echo "<br>\n";
                }
                elseif (is_array($sol)) {
                        find_sols($sol, $color);
                }
        }
}