有人看，没有人发言，难道这个方法行不通？？

这个我写过一个```还不错吧```不过呢```不好公开呀```哈哈！

下手的方式嘛```你不是已经说了吗，就你说的那三步啊```

一步一步完成就OK了```

有什么问题具体点呀

问题就是：
1、写出来的程序可能运行速度太慢，。。。
2、找不到那个二维矩阵。。。

既然你找不到二维矩阵怎么知道程序可能运行太慢呢？那个算法很简单的```我帖上来啊```

至于那个二维矩阵，其实就是一个一维字节数组```地址就不贴了```免得```

//
// 判断方块 A 与方块 B 是否可连通
//
// blocks 为方块一维字节数组首地址
//
bool Linkable( const BYTE *blocks, int blockARow, int blockACol, int blockBRow, int blockBCol )
{
    int i, j;

    //
    // 首先水平扫描
    //
    int minACol, minBCol, maxACol, maxBCol, minCol, maxCol;   
   
    // 确定扫描的左边界
    for ( minACol = blockACol; minACol >= 0; minACol-- )
        if ( ( blocks[ blockARow * MAP_COLS + minACol ] != 0 ) && ( minACol != blockACol ) )   
            break;
    minACol++;

    if ( minACol < blockBCol )
    {
        for ( minBCol = blockBCol; minBCol >= minACol; minBCol-- )
            if ( ( blocks[ blockBRow * MAP_COLS + minBCol ] != 0 ) && ( minBCol != blockBCol ) )   
                break;
        minBCol++;

        minCol = minBCol;
    }
    else
        minCol = minACol;

    // 确定扫描的右边界
    for ( maxACol = blockACol; maxACol < MAP_COLS; maxACol++ )
        if ( ( blocks[ blockARow * MAP_COLS + maxACol ] != 0 ) && ( maxACol != blockACol ) )   
            break;
    maxACol--;

    if ( maxACol > blockBCol )
    {
        for ( maxBCol = blockBCol; maxBCol <= maxACol; maxBCol++ )
            if ( ( blocks[ blockBRow * MAP_COLS + maxBCol ] != 0 ) && ( maxBCol != blockBCol ) )   
                break;
        maxBCol--;

        maxCol = maxBCol;
    }
    else
        maxCol = maxACol;

    // 判断在公共边界范围内是否存在可直接连通的列
    for ( i = minCol; i <= maxCol; i++ )
    {
        if ( ( blockARow - blockBRow <= 1 ) && ( blockARow - blockBRow >= -1 ) )
        {
            // 如果 blockA 与 blockB 为同一行或相邻行，则可直接连通
            return true;
        }
        else if ( blockARow < blockBRow )
        {   
            // blockA 在 blockB 上边
            for ( j = blockARow + 1; j < blockBRow; j++ )
                if ( blocks[ j * MAP_COLS + i ] != 0 )
                    break;

            if ( j == blockBRow )
                return true;
        }
        else
        {   
            // blockB 在 blockA 上边
            for ( j = blockBRow + 1; j < blockARow; j++ )
                if ( blocks[ j * MAP_COLS + i ] != 0 )
                    break;

            if ( j == blockARow )
                return true;
        }
    }

    //
    // 然后垂直扫描
    //
    int minARow, minBRow, maxARow, maxBRow, minRow, maxRow;   
   
    // 确定扫描的上边界
    for ( minARow = blockARow; minARow >= 0; minARow-- )
        if ( ( blocks[ minARow * MAP_COLS + blockACol ] != 0 ) && ( minARow != blockARow ) )   
            break;
    minARow++;

    if ( minARow < blockBRow )
    {
        for ( minBRow = blockBRow; minBRow >= minARow; minBRow-- )
            if ( ( blocks[ minBRow * MAP_COLS + blockBCol ] != 0 ) && ( minBRow != blockBRow ) )   
                break;
        minBRow++;

        minRow = minBRow;
    }
    else
        minRow = minARow;   

    // 确定扫描的下边界
    for ( maxARow = blockARow; maxARow < MAP_ROWS; maxARow++ )
        if ( ( blocks[ maxARow * MAP_COLS + blockACol ] != 0 ) && ( maxARow != blockARow ) )   
            break;
    maxARow--;

    if ( maxARow > blockBRow )
    {
        for ( maxBRow = blockBRow; maxBRow <= maxARow; maxBRow++ )
            if ( ( blocks[ maxBRow * MAP_COLS + blockBCol ] != 0 ) && ( maxBRow != blockBRow ) )   
                break;
        maxBRow--;

        maxRow = maxBRow;
    }
    else
        maxRow = maxARow;

    // 判断在公共边界范围内是否存在可直接连通的行
    for ( i = minRow; i <= maxRow; i++ )
    {
        if ( ( blockACol - blockBCol <= 1 ) && ( blockACol - blockBCol >= -1 ) )
        {
            // 如果 blockA 与 blockB 为同一列或相邻列，则可直接连通
            return true;
        }
        else if ( blockACol < blockBCol )
        {   
            // blockA 在 blockB 左边
            for ( j = blockACol + 1; j < blockBCol; j++ )
                if ( blocks[ i * MAP_COLS + j ] != 0 )
                    break;

            if ( j == blockBCol )
                return true;
        }
        else
        {   
            // blockB 在 blockA 左边
            for ( j = blockBCol + 1; j < blockACol; j++ )
                if ( blocks[ i * MAP_COLS + j ] != 0 )
                    break;

            if ( j == blockACol )
                return true;
        }
    }

    return false;
}

//
// 补充一下
//
上面函数中的确定扫描左右边界、上下边界是为了减少判断次数优化，由此多出来的代码是函数看起来很复杂，其实整个函数的思路很简单的，去掉优化部分的代码就很简单了。不要怕啊```觉得有用就仔细看看，不难的。呵呵