In an effort to be at least somewhat helpful, note that the question is not crystal-clear on whether the arrays are fixed or variant You're given two sizes; a column count (the width) and a row count (the height). Also note that this statement:

"In your program only refer to the integer array..."

is nonsense. there are 'cols' integer arrays, not one.

int rows, cols; // acquire rows and cols from wherever.

// create the row vector that will hold the column pointers.
//  this constitutes the first grey box above the main array.

int **rowsp = new int*[rows];


// for each slot we just allocated, set the value an allocation
//  of 'int' values. the list will be `cols` wide

for (int i=0;i<rows;)
    rowsp[i++] = new int[cols];


// thats both white boxes and the first grey box. rowsp points
//  to the allocated pointer array holding 'rows' pointers, each 
//  pointing to an int array hold 'cols' ints.

// now we make the two pointers that point at rowsp
int ***p1 = &rowsp;
int ***p2 = p1;

// and finally, setup s,t,u,v
int ****s = &p1;
int ****t = s;
int ****u = &p2;
int ****v = u;

Terrific, but reading the context of your question, this isn't right at all. According to the question, you have only four pointers to work with: {s,t,u,v} The must be declared of a type appropriate to allow us to build all the way to the end int arrays. Looking at the above (which is throw-way code at this point) we know we need four levels of indirection. So this time, we start with s,t,u, and v, working our way down.

int ****s = new int***; // p1 in the prior code
int ****t = s;          // points to the same p1

int ****u = new int***; // p2 in the prior code
int ****v = u;          // points to the same p2

Now we need to get our p1 and p2 pointing to a common pointer as well. This pointer will be the rowsp pointer in out code from above (which means when we're done s,t,u, and v all should have a path to it eventually)

*s = new int**;         // s-->p1-->rowsp, t-->p1-->rows
*u = *s;                // u-->p2-->rowsp, v-->p2-->rowsp

Now we need to allocate the actual rows vector, which will contain pointers to ints:

**s = new int*[rows];   // the integer pointer array.

And finally, populate this array with 'cols'-length int-arrays.

for (int i=0;i<cols;++i)
{
    *(**s+i) = new int[ cols ]();
    for (int j=0;j<cols;++j)
        *(*(**s+i)+j) = i+j; // <== beautiful dereference chain =P
}

If we did this right, the following should all point to the same thing:

cout << "**s = " << **s << endl;
cout << "**t = " << **t << endl;
cout << "**u = " << **u << endl;
cout << "**v = " << **v << endl;

I leave moving this madness to functions on your own dime. The entire code base from above appears below in one contiguous listing. You can also see it live on ideone.com:

#include <iostream>

using namespace std;

int main()
{
    static const int rows = 8; // yours would come from user input
    static const int cols = 9;

    int ****s = new int***; // s --> p1
    int ****t = s;          // t --> p1

    int ****u = new int***; // u --> p2
    int ****v = u;          // v --> p2

    *s = new int**;         // s-->p1-->rowsp, t-->p1-->rows
    *u = *s;                // u-->p2-->rowsp, v-->p2-->rowsp

    **s = new int*[rows];   // s --> p1 --> rowsp --> int*[rows]

    for (int i=0;i<rows;++i)
    {
        *(**s+i) = new int[ cols ];
        for (int j=0;j<cols;++j)
            *(*(**s+i)+j) = (i+j) % cols; // <== beautiful dereference chain =P
    }

    cout << "**s = " << **s << endl;
    cout << "**t = " << **t << endl;
    cout << "**u = " << **u << endl;
    cout << "**v = " << **v << endl << endl;;

    cout << "======= S =======" << endl;
    for (int i=0;i<rows;++i)
    {
        for (int j=0;j<cols;++j)
            cout << *(*(**s+i)+j) << ' ';
        cout << endl;
    }
    cout << endl;

    cout << "======= T =======" << endl;
    for (int i=0;i<rows;++i)
    {
        for (int j=0;j<cols;++j)
            cout << *(*(**t+i)+j) << ' ';
        cout << endl;
    }
    cout << endl;

    cout << "======= U =======" << endl;
    for (int i=0;i<rows;++i)
    {
        for (int j=0;j<cols;++j)
            cout << *(*(**u+i)+j) << ' ';
        cout << endl;
    }
    cout << endl;

    cout << "======= V =======" << endl;
    for (int i=0;i<rows;++i)
    {
        for (int j=0;j<cols;++j)
            cout << *(*(**v+i)+j) << ' ';
        cout << endl;
    }
    cout << endl;

    // delete rows.
    for (int i=0;i<rows;++i)
        delete [] *(**s+i);

    // delete row pointer array
    delete [] **s;

    // delete rowsp pointer
    delete *s;

    // and finally, delete s and u (or t and v)
    delete s;
    delete u;

    return 0;
}

Output (pointers will vary)

**s = 0x100103b60
**t = 0x100103b60
**u = 0x100103b60
**v = 0x100103b60

======= S =======
0 1 2 3 4 5 6 7 8 
1 2 3 4 5 6 7 8 0 
2 3 4 5 6 7 8 0 1 
3 4 5 6 7 8 0 1 2 
4 5 6 7 8 0 1 2 3 
5 6 7 8 0 1 2 3 4 
6 7 8 0 1 2 3 4 5 
7 8 0 1 2 3 4 5 6 

======= T =======
0 1 2 3 4 5 6 7 8 
1 2 3 4 5 6 7 8 0 
2 3 4 5 6 7 8 0 1 
3 4 5 6 7 8 0 1 2 
4 5 6 7 8 0 1 2 3 
5 6 7 8 0 1 2 3 4 
6 7 8 0 1 2 3 4 5 
7 8 0 1 2 3 4 5 6 

======= U =======
0 1 2 3 4 5 6 7 8 
1 2 3 4 5 6 7 8 0 
2 3 4 5 6 7 8 0 1 
3 4 5 6 7 8 0 1 2 
4 5 6 7 8 0 1 2 3 
5 6 7 8 0 1 2 3 4 
6 7 8 0 1 2 3 4 5 
7 8 0 1 2 3 4 5 6 

======= V =======
0 1 2 3 4 5 6 7 8 
1 2 3 4 5 6 7 8 0 
2 3 4 5 6 7 8 0 1 
3 4 5 6 7 8 0 1 2 
4 5 6 7 8 0 1 2 3 
5 6 7 8 0 1 2 3 4 
6 7 8 0 1 2 3 4 5 
7 8 0 1 2 3 4 5 6