int** flipAndInvertImage(int** image, int imageSize, int* imageColSize, int* returnSize, int** returnColumnSizes){
    int i, j, col;
    int **ret = (int **)malloc( sizeof(int *) * imageSize );        // (1)
    *returnColumnSizes = (int *)malloc( sizeof(int) * imageSize );  // (2)
    for(i = 0; i < imageSize; ++i) {
        col = imageColSize[i];                                      // (3)
        ret[i] = (int *)malloc( sizeof(int) * col );                // (4)
        (*returnColumnSizes)[i] = col;                              // (5)
        for(j = 0; j < col; ++j) {
            ret[i][j] = 1 - image[i][ col-1-j ];                    // (6)
        }
    }
    *returnSize = imageSize;                                        // (7)
    return ret;                                                     // (8)
}

输入：accounts = [[1,2,3],[3,2,1]]
输出：6
解释：
第 1 位客户的资产总量 = 1 + 2 + 3 = 6
第 2 位客户的资产总量 = 3 + 2 + 1 = 6
两位客户都是最富有的，资产总量都是 6 ，所以返回 6 。

输入：accounts = [[1,5],[7,3],[3,5]]
输出：10
解释：
第 1 位客户的资产总量
 = 6
第 2 位客户的资产总量
 = 10 
第 3 位客户的资产总量
 = 8
第 2 位客户是最富有的，资产总量是 10

int maximumWealth(int** accounts, int accountsSize, int* accountsColSize){
int i,j,col;
int arr[accountsSize];//用一个arr数组来接收每行和
memset(arr,0,accountsSize*sizeof(int));同时要对他初始化为0
int max;//定义max为最终最大返回值
for(i=0;i<accountsSize;i++)
{
    for(j=0;j<accountsColSize[i];j++)
    {
        arr[i]+=accounts[i][j];
    } 
}
max=arr[0];//max赋初值第一个元素
for(i=0;i<accountsSize;i++)
{
    if(max<arr[i])
    {
        max=arr[i];
    }
}
return max;
}

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** transpose(int** matrix, int matrixSize, int* matrixColSize, int* returnSize, int** returnColumnSizes)
{
int i,j,col;    
col=matrixColSize[0];//
int **ret=(int **)malloc(sizeof(int*)*col);      //ret的行数是matrix的列数
*returnColumnSizes=(int*)malloc(sizeof(int)*col);//*returnColumnSize返回的每行的个数是原二维数组的列数
*returnSize=col;      //返回的行数是原来的列数                        
for(i=0;i<col;i++)      
{          
    (*returnColumnSizes)[i]=matrixSize;//返回每行的列数是原来的行数
    ret[i]=(int *)malloc(sizeof(int)*matrixSize);
}
for(i=0;i<matrixSize;i++)
{    
    for(j=0;j<col;j++)
    {
        ret[j][i]=matrix[i][j];
    }
}
return ret;
}

void rotate(int** matrix, int matrixSize, int* matrixColSize){
int i=0;
int j=0;
int col;
int arr[matrixSize][matrixSize];//开辟一个arr二维数组，长度是matrixsize
for(i=0;i<matrixSize;i++)
{
    col=matrixColSize[i];       //col是每行的列数
for(j=0;j<col;j++)
{
    arr[j][col-1-i]=matrix[i][j];//因为是对matrix的i和j的遍历，所以matrix是[i][j],
                                   arr是规律是arr[j][col-1-i]
}
}
for(i=0;i<matrixSize;i++)
{
    col=matrixColSize[i];
    for(j=0;j<col;j++)
    {
        matrix[i][j]=arr[i][j];//arr是已经旋转之后的数组，同时因为要旋转，所以要对原来的数组进行改变，把arr赋给matrix
    }
}
return matrix;
}

int main()
{
  int i, j;
  int m = 3;
  int n = 3;
  int ret[10][10];
  memset(ret, 0, sizeof(ret));用memset内存函数对ret初始化为0
  int count = 1;
  for (i = 0; i < n / 2; i++)
  {
    //向右
    for (j = i; j < m - i; j++)
    {
      ret[i][j] = count++;
    }
    //向下
    for (j = i + 1; j < n - i; j++)
    {
      ret[j][m - 1 - i] = count++;
    }
    for (j = m - 2 - i; j >= i; j--)
    {
      ret[n - 1 - i][j] = count++;
    }
    for (j = n - 2 - i; j > i; j--)
    {
      ret[j][i] = count++;
    }
    if (n % 2 == 1)//假如n是奇数的话，中间还要填一个数
    {
      ret[n / 2][m / 2] = n * m;
    }
  }
  for (i = 0; i < n; i++)
  {
    for (j = 0; j < m; j++)
    {
      printf("%d ", ret[i][j]);
    }
    printf("\n");
  }