二维数组

1. 一个二维数组，每一行从左到右递增， 每一列从上到下递增。判断数组中是否含有该整数。
2. 求二维子数组和的最大值（任意维度子矩阵，固定维度2×2子矩阵）。
3. 矩阵原地转置(n×n方阵，m×n矩阵)。

1、思路：（详细参考：http://justjavac.iteye.com/blog/1310178）

　　剑指offer中提供的时间复杂度是O(m+n)，如果考虑将线性二分查找的思想用在矩阵二分查找中，速度可能会有提升。

　　

　　假设查找17，第一次比较10，然后比较25，然后比较13，返回元素13，这时候再递归查找13左下角的矩阵和右上角的矩阵就可以了（红色椭圆部分）；如果是查找9，第一次比较10，然后比较4，然后比较6，返回元素6，这时候递归查找6左下角的矩阵和右上角矩阵（绿色椭圆部分）。

int binsearch(int value, int *a, int n, int m1, int n1, int m2, int n2)
{
    int begin_m1 = m1, begin_n1 = n1, end_m2 = m2, end_n2 = n2;
    int left_result = 0,  right_result = 0;
    int i = (m1+m2)/2, j = (n1+n2)/2;
    if (a == NULL)
        return 0;
    if (value < *(a+m1*n+n1) || value > *(a+m2*n+n2))
        return 0;
    else if (value == *(a+m1*n+n1) || value == *(a+m2*n+n2))
        return 1;

    while ((i!=m1 || j!=n1) && (i!=m2 || j!=n2)){
        if ( value == *(a+i*n+j) )
            return 1;
        else if ( value < *(a+i*n+j) ){
            m2 = i;
            n2 = j;
            i = (i+m1)/2;
            j = (j+n1)/2;
        }
        else{
            m1 = i;
            n1 = j;
            i = (i+m2)/2;
            j = (j+n2)/2;
        }
    }
      
    //search left & right
    if ( i<end_m2 )
        left_result = binsearch(value, a, n, i+1, begin_n1, end_m2, j);
    if ( j<end_n2 )
        right_result = binsearch(value, a, n, begin_m1, j+1, i, end_n2);
    if (left_result | right_result )
        return 1;
    else
        return 0;
}

 

2、思路：

　　任意维度子矩阵：如果我们将连续k行的元素纵向相加，并对相加后所得的数列求连续最大和，则此连续最大和就是一个行数为k的最优子矩阵！

#include <iostream>

int RowSum(int matrix[][5], int m, int n, int col)
{
    int total = 0, k;
    for (k = m; k <= n; k++)
        total += matrix[k][col];
    return total;
}

int MaxMatrixSum(int matrix[][5], int rows, int cols)
{
    int maxSum = 0x80000000;
    int curSum, rowSum;
    int ele, i, j, col;

    for (i = 0; i < rows; i++)
    {
        for (j = i; j < rows; j++)
        {
            curSum = RowSum(matrix, i, j, 0);
            rowSum = RowSum(matrix, i, j, 0);
            for (col = 1; col < cols; col++)
            {
                ele = RowSum(matrix, i, j, col);
                if (curSum < 0)
                    curSum = ele;
                else
                    curSum += ele;
                if (curSum > rowSum)
                    rowSum = curSum;
            }
            if (rowSum > maxSum)
                maxSum = rowSum;
        }                    
    }
    return maxSum;
}

int main()
{
    int matrix[][5] = {{1, -2, 0, 3, -4}, {2, -3, 4, -5, 1}, {1, -1, 5, 3, 0}};
    int result = MaxMatrixSum(matrix, 3, 5);
    printf("result: %d", result);
}

　　固定维度子矩阵：

int GetMaxMatrix(int** matrix, int& row, int& col) 
{ 
    int rowNum, colNum; 

    int sum=-(1<<31), temp = 0; 

    for (int i = 0; i < row - 1; i++) 
    { 
        for (int j = 0; j < col - 1; j++) 
        { 
            temp += (matrix[i][j] + matrix[i][j+1]);  
            temp += (matrix[i+1][j] + matrix[i+1][j+1]); 

            if (temp > sum) 
            { 
                sum = temp; 
                rowNum = i; 
                colNum = j; 
            } 
            temp = 0; 
        } 
    } 
    row=rowNum; 
    col=colNum; 

    return sum; 
} 

 

3、思路：

　　方阵请参考：http://blog.csdn.net/friendan/article/details/8821591

void Transpose(int arr[ROW][COL])  
{  
    int temp;  
    for (int i=0;i<ROW;i++)  
    {  
        for(int j=i;j<COL;j++)  
        {  
            temp=arr[i][j];  
            arr[i][j]=arr[j][i];  
            arr[j][i]=temp;  
        }  
    }  
}  

　　矩阵请参考：http://www.qushichao.com/archives/47.html

　　m×n矩阵用一维数组表示，关键是找到下标数字的移动环。一维数组中的下标移动可以通过二维数组的转置规则求得。

void transpose(int *a, int m, int n){
   int flag = (m > n) ? n : m;
   for(int i = 1; i < flag; i++){
       int tmp = a[i];
       int position = i;
       while(true){
           int row = position / m;
           int column = position % m;
           int posToMove = column * n + row;
           if(posToMove == i){
               a[position] = tmp;
               break;
           }

           a[position] = a[posToMove];
           position = posToMove;
       }
   }
}