DEFKIN

1
15 8 3
3 8
11 2
8 6
1
10 10 5
1 2
3 4
5 3
6 7
8 1
1
10 10 0
1
4 4 2 2 
2
1
100 69 6
4 8
15 45
23 32
36 63
17 29
30 66
1
15 8 2
1 1
1 8
1
15 8 2
1 1
2 8
3
10 10 5
1 2
3 4
5 3
6 7
8 1
10 10 0
100 69 6
4 8
15 45
23 32
36 63
17 29
30 66
1
1 1 1
1 1
1
8 8 1
8 8
2
8 7 2
4 5
5 4
1 8 1
1 7
1
17 9 3
3 8
2 4
5 10
1
13 11 6
3 3
2 1
2 2
2 7
8 5
8 4
1
13 11 0
3 3
2 1
2 2
2 7
8 5
8 4
1
10 10 5
1 2
3 4
5 3
6 6
8 1
1
10 10 0
1 2
3 4
5 3
6 7
8 1
1
10 10 1
1 2
1
100 69 6
4 8
15 45
23 32
36 63
17 29
30 69
1
100 69 6
4 8
15 45
23 32
36 69
17 29
30 69
1
100 69 6
4 8
15 45
23 32
36 69
17 29
30 70
1
5 6 2
1 1
2 3


1
15 8 2
3 8
8 6
1
20 8 6
11 2
5 6
15 3
14 4
8 3
7 5
1
20 8 6
11 2
5 6
15 3
12 2
8 3
7 5
1
20 12 6
11 2
5 6
15 11
12 2
8 3
7 12
1
15 8 0
1
40000 40000 6
4 8
15 45
23 32
36 69
17 29
30 70
1
15 8 3
3 8
10 2
8 6
1
40000 40000 0
4 8
15 45
23 32
36 69
17 29
30 70
1
20 12 6
11 2
5 6
15 11
12 2
8 3
7 12
1
10 10 1
1 2
1
20 8 6
11 2
5 6
15 3
12 2
8 3
7 5
//  Examen Final Práctico, Ejercicio 2.
//  José María Flores Escalera.
//  A01153458.

#include 

using namespace std;

//  Función que acomoda y une las partes de los arreglos menores.
void unir(int iArr[], int iInicio, int iMitad, int iFinal, int iNumTorres)
{
    int iIn = iInicio;
    int iJota = iMitad + 1;
    int iKa = iInicio;
    int iArrAux[iNumTorres];

    while((iIn <= iMitad) && (iJota <= iFinal))
    {
		if(iArr[iIn] <= iArr[iJota])
        {
			iArrAux[iKa] = iArr[iIn];
			iIn = iIn + 1;
        }
		else
        {
            iArrAux[iKa] = iArr[iJota];
            iJota = iJota + 1;
        }

        iKa = iKa + 1;
	}

    while(iIn <= iMitad)
    {
        iArrAux[iKa] = iArr[iIn];
        iKa = iKa + 1;
        iIn = iIn + 1;
    }

    while(iJota <= iFinal)
    {
        iArrAux[iKa] = iArr[iJota];
        iKa = iKa + 1;
        iJota = iJota + 1;
    }

    for(int iC = iInicio; iC <= iFinal; iC++)
    {
        iArr[iC] = iArrAux[iC];
    }
}

//  Función que hace el merge del arreglo.
void mergeSort(int iArr[], int iInicio, int iFinal, int iNumTorres)
{
    if(iInicio < iFinal)
    {
        int iMitad = (iInicio + iFinal) / 2;

        mergeSort(iArr, iInicio, iMitad, iNumTorres);
        mergeSort(iArr, iMitad + 1, iFinal, iNumTorres);

        unir(iArr, iInicio, iMitad, iFinal, iNumTorres);
    }
}

//Función para mostrar el arreglo.
void mostrarArr(int iArr[], int iTam)
{
	for (int iCont = 0; iCont < iTam; iCont++)
        cout << iArr[iCont] << " ";
	cout << endl;
}

//////////////////Programa Principal///////////////////////////
int main()
{
    int iRenglones, iColumnas, iTorres, iArrCoorX[51], iArrCoorY[51];
    int iMaxX, iMaxY, iTempX, iTempY, iResultado;

    cin >> iRenglones >> iColumnas >> iTorres;

    for (int iC = 0; iC < iTorres; iC++)
    {
        cin >> iArrCoorX[iC] >> iArrCoorY[iC];
    }

    //mostrarArr(iArrCoorX, iTorres);
    //mostrarArr(iArrCoorY, iTorres);

    mergeSort(iArrCoorX, 0, iTorres - 1, iTorres);
    mergeSort(iArrCoorY, 0, iTorres - 1, iTorres);

    //mostrarArr(iArrCoorX, iTorres);
    //mostrarArr(iArrCoorY, iTorres);

    iArrCoorX[iTorres] = iRenglones + 1;
    iArrCoorY[iTorres] = iColumnas + 1;

    iMaxX = iArrCoorX[0];
    iMaxY = iArrCoorY[0];

    for(int iC = 1; iC <= iTorres; iC++)
    {
        iTempX = iArrCoorX[iC] - iArrCoorX[iC - 1];
        if(iMaxX < iTempX)
        {
            iMaxX = iTempX;
        }


        iTempY = iArrCoorY[iC] - iArrCoorY[iC - 1];
        if(iMaxY < iTempY)
        {
            iMaxY = iTempY;
        }
    }

    //cout << iMaxX << " " << iMaxY << endl;

    iResultado = (iMaxX - 1) * (iMaxY - 1);

    cout << iResultado;

    return 0;
}
4
10 10 5
1 2
3 4
5 3
6 7
8 1
40000 40000 0
40000 40000 1
1 1
100 69 6
4 8
15 45
23 32
36 63
17 29
30 66
1
10 10 0
10 10 1
1 2
2
10 10 0
10 10 1
1 2
	
1
20 12 6
11 2
5 6
15 11
12 2
8 3
7 12
1
10 10 5
1 2
3 4
5 3
6 7
8 1
1
17 9 3
3 8
2 4
5 10
#14.	
1
20 8 6
11 2
5 6
15 3
14 4
8 3
7 5
0
1
12 10 0
1
10 10 1
5 5 
1
10 10 0
1
10 10 3
1 1 
4 4 
10 10
15 8 1
4 5
1
13 11 0
1
10 10 3
1 1 
4 4 
10 10
1
15 8 1
4 5
2
10 10 0
10 10 1
1 2