Insule

Arhipelagul RGB este format din insule care aparţin ţărilor R, G şi B.Putem reprezenta harta arhipelagului ca o matrice cu N linii şi M coloane cu elemente din mulţimea {0, 1, 2, 3} astfel:

  • un element egal cu 0 reprezintă o zonă acoperită de apă

  • un element egal cu 1 reprezintă o zonă de pământ aparţinând unei insule din ţara R

  • un element egal cu 2 reprezintă o zonă de pământ aparţinând unei insule din ţara G

  • un element egal cu 3 reprezintă o zonă de pământ aparţinând unei insule din ţara B

Se consideră că două elemente ale matricei sunt vecine dacă ele au aceeaşi valoare şi fie sunt consecutive pe linie, fie sunt consecutive pe coloană. Două elemente aparţin aceleiaşi insule dacă ele sunt vecine sau dacă se poate ajunge de la un element la celălalt pe un drum de-a lungul căruia oricare două elemente consecutive sunt vecine.
Pentru a încuraja relaţiile de colaborare dintre ţările R şi G, se doreşte construirea unui pod care să unească o insulă aparţinând ţării R de o insulă aparţinând ţării G. Podul trebuie să respecte următoarele condiţii:

  • să înceapă pe o zonă cu apă consecutivă pe linie sau coloană cu o zonă aparţinând ţării R;

  • să se termine pe o zonă cu apă consecutivă pe linie sau coloană cu o zonă aparţinând ţării G;

  • să traverseze numai zone acoperite cu apă;

  • oricare două elemente consecutive ale podului trebuie să fie vecine;

  • lungimea podului să fie minimă (lungimea podului este egală cu numărul de elemente traversate de pod).

Dată fiind harta arhipelagului să se determine câte insule aparţin fiecărei ţări, precum şi lungimea minimă a unui pod care să satisfacă condiţiile din enunt.

Date de intrare

Fişierul de intrare insule.in conţine pe prima linie numerele naturale N şi M, separate prin spaţiu. Pe următoarele n linii este descrisă harta arhipelagului. Pe fiecare dintre aceste n linii sunt scrise câte m valori din mulţimea {0, 1, 2, 3}; valorile nu sunt separate prin spaţii.

Date de ieșire

Fişierul de ieşire insule.out va conţine o singură linie pe care vor fi scrise patru numere naturale separate prin spaţii NR NG NB Lg, unde NR reprezintă numărul de insule aparţinând ţării R, NG numărul de insule aparţinând ţării G, NB numărul de insule aparţinând ţării B, iar Lg lungimea minimă a podului.

Restricții si precizări

  • 1 ≤ N,M ≤ 100

  • Se garantează că pe hartă există cel puţin un element 1, un element 2 şi un element 0.

  • Se acordă 40% din punctaj pentru determinarea corectă a numărului de insule din fiecare ţară; se acordă punctaj integral pentru rezolvarea corectă a tuturor cerinţelor.

  • Începutul şi sfârşitul podului pot să coincidă.

  • Pentru datele de test există întotdeauna soluţie.

Exemplu

Heading 1

Implementare

#include <iostream>

#include <fstream>

#define Max 999999999

using namespace std;

 

ifstream f ("insule.in");

ofstream g ("insule.out");

int k,m,n,i,j,nl,nc,a[105][105],in,sf,K,K1,K2;

char sir[100];

const int dl[]= {-1,0,1,0};

const int dc[]= {0,1,0,-1};

struct lee

{

    int l,c;

} c[100001],u;

int b[105][105];

void fill (int x,int y,int k)

{

    if(b[x][y] == k)

    {

        b[x][y] = -k;

        fill(x,y+1,k);

        fill(x+1,y,k);

        fill(x-1,y,k);

        fill(x,y-1,k);

    }

}

void bordare()

{

    for(i = 0; i <= n+1; i++)

        a[0][i] = a[n+1][i] = -1;

    for(i = 0; i <= m+1; i++)

        a[i][0] = a[i][m+1] = -1;

}

void cerinta1()

{

    for(i = 1; i <= n; i++)

        for(j = 1; j <= m; j++)

        {

            if(b[i][j] == 1)

            {

                K++;

                k = 1;

                fill(i,j,k);

            }

            else if(b[i][j] == 2)

            {

                K1++;

                k = 2;

                fill(i,j,k);

            }

            else if(b[i][j] == 3)

            {

                K2++;

                k = 3;

                fill(i,j,k);

            }

        }

    g<<K<<" "<<K1<<" "<<K2<<" ";

}

void cerinta2()

{

    while(in <= sf)

    {

        u=c[in];

        for(i = 0; i < 4; i++)

        {

            nl = u.l + dl[i];

            nc = u.c + dc[i];

            if((a[nl][nc] > a[u.l][u.c] + 1 && b[u.l][u.c] != -2)||(b[nl][nc] == -2 && a[u.l][u.c] + 1  > 2&&b[u.l][u.c] != -2))

            {

                a[nl][nc] = a[u.l][u.c] + 1;

                c[++sf].l = nl;

                c[sf].c = nc;

                if(b[nl][nc] == -2 && a[nl][nc] > 2)

            {

                in=sf+2;

                break;

            }

            }

        }

        in++;

    }

    g<<a[nl][nc]-2;

}

int main()

{

    f >> n >> m;

    for(i = 1; i <= n; i++)

    {

        f >> sir;

        for(j = 0; j < m; j++)

        {

            a[i][j+1] = b[i][j+1] = sir[j] - 48;

            if(a[i][j+1] == 1)

            {

                c[++sf].l = i;

                c[sf].c = j+1;

                a[i][j+1] = 1;

            }

            else

            if(a[i][j+1] == 3)

                a[i][j+1] = -1;

            else

                a[i][j+1] = Max;

        }

    }

    bordare();

    cerinta1();

    cerinta2();

    return 0;

}