MPI_Scatter and MPI_Allgather

Question

Okay, so here is another question related to my previous post MPI_Broadcast using vectors

I want to scatter a matrix (4x4) in such a way that each process receives one row (total of 4 processes). I am using vectors which need to be resized and a bit of playing around. It worked well when using arrays but with vectors I can't get the desired output.

updated code (Minimal)

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <cmath>
#include <chrono>
#include <cmath>
#include <iomanip>
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include"mpi.h"

using namespace std;



const int num_rows1 = 4, num_rows2 = 4, num_cols1 = 4, num_cols2 = 4;
const int root = 0;
int i, j, k;
vector<vector<int> > matrix1(num_rows1, vector <int>(num_cols1));
vector<vector<int> > matrix2(num_rows2, vector <int>(num_cols2));
vector<vector<int> > result(num_rows1, vector <int>(num_cols1));
int finale[num_rows1][num_cols2];
vector<vector<int> > transpose_mat(num_cols2, vector <int>(num_rows2));
vector<int> column1(num_rows1);
vector<int> column2(num_cols2);
double start_time, end_time;
int * column3 = new int[];


//Function working with the multiplication

vector<int> mult(vector<vector<int> > A, vector<int> B)
{
//Multiplication

    for (int i = 0; i < num_rows1; ++i)
    {
        int sum = 0;
        for (int j = 0; j < num_cols1; ++j)
        {
            sum += A[i][j] * B[j];
        }

        column1.push_back(sum);
    }


    return column1;
}


//Function generating random matrices
vector<vector<int>> generate_matrix(int nrow, int ncol)
{

    vector<vector<int>> matrix(nrow, vector <int>(ncol));

    for (int i = 0; i < nrow; ++i)
    {
        for (int j = 0; j < ncol; ++j)
        {
            matrix[i][j] = (15 *rand() / RAND_MAX - 3);
        }
    }



    return matrix;
}


//function taking the transpose
vector<vector<int>>transpose(vector<vector<int> > matrix , int nrow, int ncol)
{

    //Transpose of matrix 2
    for (i = 0; i < nrow; ++i)
        for (j = 0; j < ncol; ++j)
        {
            transpose_mat[j][i] = matrix2[i][j];
        }

    cout << "Transpose " << endl;

    for (int i = 0; i < num_rows2; ++i)
    {
        for (int j = 0; j < num_cols2; ++j)
        {
            cout << transpose_mat[i][j] << "     ";
        }
        cout << endl;
    }

    return transpose_mat;
}


//main function
int main(int argc, char *argv[])
{


    MPI_Status status;
    MPI_Request request;
    int tag = 1;
    int rank;
    int world_size;    //Number of processes

    // Initialize the MPI environment
    MPI_Init(NULL, NULL);

    // Get the rank of the process
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);

    // Get the name of the processor
    char processor_name[MPI_MAX_PROCESSOR_NAME];
    int name_len;
    MPI_Get_processor_name(processor_name, &name_len);

    // Get the number of processes
    MPI_Comm_size(MPI_COMM_WORLD, &world_size);


    if (rank == root)
    { 

        //Filling
        matrix1 = generate_matrix(num_rows1, num_cols1);


        for (int i = 0; i < num_rows1; ++i)
        {
                MPI_Bcast(&matrix1[i][0], num_rows1, MPI_INT, root, MPI_COMM_WORLD);

        }
    }

    else if (rank == 1)
    {
        srand(time(NULL));
        //Filling
        matrix2 = generate_matrix(num_rows2, num_cols2);

    transpose_mat = transpose(matrix2, num_rows2, num_cols2);

    }

    if (rank > root)
    {

    int size = matrix1.size();
    result.resize(size);
    for (int i = 0; i < size; i++){
        result[i].resize(size);
    }

    for (int i = 0; i < size; ++i)
    {
        MPI_Bcast(&result[i][0], size, MPI_INT, root, MPI_COMM_WORLD);

    }

    }

    int size1 = transpose_mat.size();
    column2.resize(size1);

    //Scattering the transposed matrix

            for (j = 0; j < num_rows2; ++j)
            {

    MPI_Scatter(&transpose_mat[0][j], size1*size1 / world_size, MPI_INT, &column2[j], size1*size1 / world_size, MPI_INT, 1, MPI_COMM_WORLD);
            }


     cout << "The scattered data at process " << rank << " is: " << endl;

    for (int j = 0; j < num_cols2; ++j)
        {
            cout << column2[j] << endl;
        }


    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Finalize();

    return 0;

}

In the updated PNG one can see that the first two rows of the matrix are scattered. The first one being received by Process 0 and the second row by Process 2. Why do Process 1 and Process 3 don't give the desired reault. Updated PNG