I always forget how to add code in blocks correctly, and the above didn’t work for me either. But if you look at the instructions here:

http://blogs.mathworks.com/videos/2008/08/18/puzzler-find-largest-connected-island/

Those seem to work (See post number 17 in the current blog comments.)

http://www.cise.ufl.edu/~davis/puzzle.c

Here’s my mexFunction solution. Note that the result is returned as a row vector (as Doug requested). It is not sorted (which was not in Doug’s specifications).

#include "mex.h"

void mexFunction
(
    int nargout,
    mxArray *pargout [ ],
    int nargin,
    const mxArray *pargin [ ]
)
{
    double *board, color, *result ;
    char *visited ;
    mwSignedIndex *queue, m, n, mn, i, k, head = 0, tail = 0, east, west,
        north, south, col ;

    if (nargin != 1 || nargout > 1)
    {
        mexErrMsgTxt ("Usage: s = puzzle(board)\n") ;
    }

    board = mxGetPr (pargin [0]) ;
    m = mxGetM (pargin [0]) ;
    n = mxGetN (pargin [0]) ;
    mn = m*n ;
    if (n == 0 || m == 0)
    {
        mexErrMsgTxt ("board cannot be empty") ;
    }

    visited = mxCalloc (m*n, sizeof (char)) ;
    queue = mxMalloc (m*n * sizeof (mwSignedIndex)) ;

    /* place the corner element in the breadth-first-search queue */
    head = 0 ;
    tail = 0 ;
    queue [tail++] = 0 ;
    visited [0] = 1 ;
    color = board [0] ;

    while (head = 0 && !visited [east] && board [east] == color)
        {
            queue [tail++] = east ;
            visited [east] = 1 ;
        }

        /* West neighbor */
        west = i+m ;
        if (west = 0 && north/m == col &&
            !visited [north] && board [north] == color)
        {
            queue [tail++] = north ;
            visited [north] = 1 ;
        }

        /* South neighbor */
        south = i+1 ;
        if (south/m == col && !visited [south] && board [south] == color)
        {
            queue [tail++] = south ;
            visited [south] = 1 ;
        }
    }

    /* return the result */
    pargout [0] = mxCreateDoubleMatrix (1, tail, mxREAL) ;
    result = mxGetPr (pargout [0]) ;
    for (k = 0 ; k < tail ; k++)
    {
        result [k] = queue [k] + 1 ;
    }

    mxFree (visited) ;
    mxFree (queue) ;
}

So with a larger matrix, the loop overhead in M (which is not JIT-ed when using a mexFunction) becomes neglible.

With a 100-by-100 board, Yi’s solution takes 22 seconds whereas a simple mexFunction implementation takes 14 seconds. Of that total time, the rand statement takes all the time. The mexFunction itself takes just 0.16 seconds.

So you really have to be careful when looking at performance comparisons. I suggest you try a larger board, and time just the puzzle solution, not the time to construct the board.

JIT is also different for different versions of MATLAB, which is probably one reason it is not well documented. TMW doesn’t want you writing code specifically for the JIT which is subject to change.

For example, I get completely different results for the relative timings of the solutions to this current puzzle than does Doug. I suspect he is using the latest version of MATLAB, while I am using 2007a.

JIT is one of things which are not well documented. You may search support website to get something to read.

Yi

Doug
Elapsed time is 2.849295 seconds.

Kenneth Eaton
Elapsed time is 1.535686 seconds.

Matt Fig
Elapsed time is 0.191490 seconds.

Sven final
Elapsed time is 0.506205 seconds.

Dimitry
Elapsed time is 0.492957 seconds.

Jos
Elapsed time is 0.272301 seconds.

Dimitry 2
Elapsed time is 0.187197 seconds.

Yi
Elapsed time is 0.305517 seconds.

Dimitri final
Elapsed time is 0.125054 seconds.

Yi final
Elapsed time is 0.147474 seconds.

Though, at this point the code seems to be “community” owned. This is impressive. I was just telling someone in the office that no matter how efficient you think your code is, there is someone out there that can make it a little faster!

-Doug

I think the reason for your code to be successful is due to the JIT acceleration. To achieve this, the code need to be as simple as possible. Any vectorization to get rid of the inner loop may deteriorate the performance.

Yi