infoarena

ok[i][j] pt conditiile de existenta ( '.' -> 1, '#' -> -2 ) si 
b[i][j] - cea dinamica pe care o tot reactualizez cu un lee pentru fiecare paznic.

#define DEBUG 0
#define MAXSTACK 1000*1000
#include<fstream>
#include<cstdlib>
#if DEBUG==1
#include<iostream>
#endif

using namespace std;


class Point
{
public:
    short X, Y;

    Point() { X = Y = 0; }
    Point(short x, short y) { X = x; Y = y; }

    Point operator+ (Point a)
    {
        return Point(a.X + X, a.Y + Y);
    }
    Point operator- (Point a)
    {
        return Point(X - a.X, Y - a.Y);
    }
    Point* operator= (const Point* a)
    {
        this->X = a->X;
        this->Y = a->Y;
        return this;
    }

#if DEBUG==1
    friend ostream& operator<<(ostream& output, const Point &p)
    {
        output<<p.X<<","<<p.Y;
        return output;
    }
#endif
};

class PointStep : public Point
{
public:
    short Step;

    PointStep() { X = Y = 0; }
    PointStep(short x, short y) { X = x; Y = y; }
    PointStep(short x, short y, int step) { X = x; Y = y; Step = step; }
    PointStep(Point w, int step) { X = w.X; Y = w.Y; Step = step; }

    PointStep operator+ (PointStep a)
    {
        return PointStep(a.X + X, a.Y + Y);
    }

    Point operator+ (Point a)
    {
        return Point(a.X + X, a.Y + Y);
    }

    PointStep operator- (PointStep a)
    {
        return PointStep(X - a.X, Y - a.Y);
    }

    Point operator- (Point a)
    {
        return Point(a.X + X, a.Y + Y);
    }

    PointStep* operator= (const PointStep* a)
    {
        this->X = a->X;
        this->Y = a->Y;
        return this;
    }
};

const Point Directions[4] = {Point(0, -1), Point(1, 0), Point(0, 1), Point(-1, 0) };

int Map[260][260];
short MapSize;

PointStep Stack[MAXSTACK];
int StackSize, StackPos;


inline void Purge()
{
    for (int i = StackPos; i < StackSize; i++)
        Stack[i-StackPos] = Stack[i];

    StackPos = 0;
    StackSize -= StackPos;
}

inline void StackAdd(Point w, int step)
{
    Stack[StackSize++] = PointStep(w, step);

    if (StackSize >= MAXSTACK-2) Purge();
}

//**** Implementations of ReadFile / WriteFile
// ...
// ****

inline bool Okay (Point w, int pas)
{
    if (w.X < 0 || w.Y < 0 || w.X >= MapSize || w.Y >= MapSize) return false;
    if (Map[w.X][w.Y] == -1) return true;
    if (Map[w.X][w.Y] > pas) return true;

    return false;
}

void Lee()
{
    Point d;
    int pas = 0;

    while (StackPos < StackSize) {
        pas = Stack[StackPos].Step;
        for (int direction = 0; direction < 4; direction++)
        {
            d = Stack[StackPos] + Directions[direction];

            if (Okay(d, pas))
            {
                StackAdd(d, pas+1);
                Map[d.X][d.Y] = pas+1;
            }
        }

        StackPos++;
    }
}


int main()
{
    ReadFile("muzeu.in");
    Lee();
    WriteFile("muzeu.out");

    return 0;
}

#define DEBUG 0
#define MAXSTACK 1000*1000
#include<fstream>
#include<cstdlib>
#include<queue>
#if DEBUG==1
#include<iostream>
#endif

using namespace std;


class Point
{
public:
    short X, Y;

    Point() { X = Y = 0; }
    Point(short x, short y) { X = x; Y = y; }

    Point operator+ (Point a)
    {
        return Point(a.X + X, a.Y + Y);
    }
    Point operator- (Point a)
    {
        return Point(X - a.X, Y - a.Y);
    }
    Point* operator= (const Point* a)
    {
        this->X = a->X;
        this->Y = a->Y;
        return this;
    }

#if DEBUG==1
    friend ostream& operator<<(ostream& output, const Point &p)
    {
        output<<p.X<<","<<p.Y;
        return output;
    }
#endif
};

class PointStep : public Point
{
public:
    short Step;

    PointStep() { X = Y = 0; }
    PointStep(short x, short y) { X = x; Y = y; }
    PointStep(short x, short y, int step) { X = x; Y = y; Step = step; }
    PointStep(Point w, int step) { X = w.X; Y = w.Y; Step = step; }

    PointStep operator+ (PointStep a)
    {
        return PointStep(a.X + X, a.Y + Y);
    }

    Point operator+ (Point a)
    {
        return Point(a.X + X, a.Y + Y);
    }

    PointStep operator- (PointStep a)
    {
        return PointStep(X - a.X, Y - a.Y);
    }

    Point operator- (Point a)
    {
        return Point(a.X + X, a.Y + Y);
    }

    PointStep* operator= (const PointStep* a)
    {
        this->X = a->X;
        this->Y = a->Y;
        return this;
    }
};

const Point Directions[4] = {Point(0, -1), Point(1, 0), Point(0, 1), Point(-1, 0) };

int Map[260][260];
short MapSize;

queue<PointStep> Queue;

void ReadFile(char* fileName)
{
    char buffer[250];
    ifstream in (fileName);

    in>>MapSize;
    in.getline(buffer, 250, '\n');

    for (short x=0; x < MapSize; x++)
    {
        in.getline(buffer, 250, '\n');
        for (short y=0; y < MapSize; y++)
            switch (buffer[y])
            {
                case '#': Map[x][y] = -2; break;
                case 'P': Map[x][y] = 0; Queue.push(PointStep(x, y, 0)); break;
                default: Map[x][y] = -1; break;
            }
    }

    in.close();
}

void WriteFile(char* fileName)
{
    ofstream out (fileName);

    for (int x=0; x< MapSize; x++, out<<endl)
        for (int y=0; y<MapSize; y++)
            out<<Map[x][y]<<" ";
}

inline bool Okay (Point w, int pas)
{
    if (w.X < 0 || w.Y < 0 || w.X >= MapSize || w.Y >= MapSize) return false;
    if (Map[w.X][w.Y] == -1) return true;
    if (Map[w.X][w.Y] > pas) return true;

    return false;
}

void Lee()
{
    Point d;
    int pas = 0;

    while (!Queue.empty()) {
        PointStep temp = Queue.front();
        pas = temp.Step;
        for (int direction = 0; direction < 4; direction++)
        {
            d = temp + Directions[direction];

            if (Okay(d, pas))
            {
                Queue.push(PointStep(d, pas+1));
                Map[d.X][d.Y] = pas+1;
            }
        }

        Queue.pop();
    }
}


int main()
{
    ReadFile("muzeu.in");
    Lee();
    WriteFile("muzeu.out");

    return 0;
}

    for( i = 0 ; i <= k ; ++i )
    {
        c[0].x = p[i].r;
        c[0].y = p[i].t;
        for( g = 0 , ind = 0 ; g <= ind ; ++g )
...

for(i = 0; i <= k; i++) {
   c[i].x = p[i].r;
   c[i].y = p[i].t;
}
ind = k;

//Problema muzeu
#include<fstream>
#include<iostream>
using namespace std;
  
int a[251][251],i,j,ok,u,p,q[3][20001],c,d,y,sir[3][100000],maxi,l[251][251],n,k=0;
ifstream fin("muzeu.in");
ofstream g("muzeu.out");
  
void init()
  
{
       
     //citim datele din fisierul muzeu.in
     fin>>n;
   //  cout<<n;
     char c;
      for(i=1;i<=n;i++)
             for(j=1;j<=n;j++)
            { fin>>c;
             if (c=='.')
             { a[i][j]=1;
              l[i][j]=-1;
              }
             else if (c=='P') {a[i][j]=10;k++;sir[1][k]=i;sir[2][k]=j;}
                                else l[i][j]=-2;
                                }
             fin.close();
          
           
}
//instroduc linia c si col d in coada
void intr(int c,int d)
{
     u=u+1;
      if(u>20000)
       u=1;
         
       q[1][u]=c;
       q[2][u]=d;
} 
//extrag un element din coada
void extr(int &c,int &d)
{
     p=p+1;
     if(p>20000)
     p=1;
       
     c=q[1][p];
     d=q[2][p];
}
  
//algoritmul LEE
void lee(int x,int y)
{
     p=0;u=0;
     intr(x,y);
     while(p!=u)
    { extr(x,y);
     
   //vecinul de sus 
   //daca are inaltime mai mare si numarul de catarari mai mic atunci
   //actualizez numarul de catarari cu l[x][y]+1
     if(x>1)
       
      if(a[x-1][y]==1)
       if(l[x-1][y]>l[x][y]+1||l[x-1][y]==-1)
       {l[x-1][y]=l[x][y]+1;
       intr(x-1,y);
  
      }
       
     //
      if(x<n)
       if(a[x+1][y]==1)
        if(l[x+1][y]>l[x][y]+1||l[x+1][y]==-1)
        {l[x+1][y]=l[x][y]+1;
         intr(x+1,y);
   
         }
  
    if(y>1)
     if(a[x][y-1]==1)      
           if(l[x][y-1]>l[x][y]+1||l[x][y-1]==-1)
           {l[x][y-1]=l[x][y]+1;
                                  intr(x,y-1);
          
                                  }
    if(y<n)
     if(a[x][y+1]==1)
      if(l[x][y+1]>l[x][y]+1||l[x][y+1]==-1)
    {l[x][y+1]=l[x][y]+1;
    intr(x,y+1);
    
    }
      
}
  
}
void scriere()
{ 
  
             
        
      for(i=1;i<=n;i++)
             {g<<"\n";
                          for(j=1;j<=n;j++)
              g<<l[i][j]<<" ";}
     maxi=-1;
    //  for(i=1;i<=n;i++)
     //  for(j=1;j<=n;j++)
       // if(l[i][j]>maxi)
       // maxi=l[i][j];
    
}
int main()
{
   
    init();
    for(i=1;i<=k;i++)
     lee(sir[1][i],sir[2][i]);
      
     scriere();
    
    return 0;
}

while(!d.empty())
    {
        int x,y;
        x=d.front();d.pop_front();
        y=d.front();d.pop_front();
        lee(x,y);
        x=d.front();d.pop_front();
        y=d.front();d.pop_front();
        lee(x,y);
    }

while(!d.empty())
    {
        int x,y;
        x=d.front();d.pop_front();
        y=d.front();d.pop_front();
        lee(x,y);
    }

#include <fstream>
#define NV 4
#define Nmax 62500
using namespace std;
ifstream fin("muzeu.in");
ofstream fout("muzeu.out");
int a[252][252],n,k,p,u;
struct Pct{int x,y;};
Pct c[Nmax];
int dx[NV] = {-1,0,1,0};
int dy[NV] = {0,1,0,-1};

void citire();
void Lee();
void afisare();

int main()
{
    citire();
    Lee();
    afisare();
    return 0;
}

void citire()
{
    int i,j;
    char sir[252];
    fin>>n;
    fin.get();
    for(i=1; i<=n; i++)
    {
        fin.getline(sir,252);
        for(j=1; j<=n; j++)
        {
            if(sir[j-1]=='.')
                a[i][j]=-1;
            else if(sir[j-1]=='#')
                a[i][j]=-2;
            else
            {
                a[i][j]=0;
                c[u].x=i;
                c[u++].y=j;
            }
        }
    }
}

void Lee()
{
    Pct B,C;
    u--;
    int i;
    while(p<=u)
    {
        B.x=c[p].x;
        B.y=c[p].y;
        p++;
        for(i=0; i<NV; i++)
        {
            C.x=B.x+dx[i];
            C.y=B.y+dy[i];
            if(a[C.x][C.y]==-1)
            {
                a[C.x][C.y]=a[B.x][B.y]+1;
                u++;
                c[u].x=C.x;
                c[u].y=C.y;

            }
        }
    }
}

void afisare()
{
    int i,j;
    for(i=1; i<=n; i++)
    {
        for(j=1; j<=n; j++)
            if(a[i][j]<0)
                fout<<a[i][j]<<" ";
            else
                fout<<" "<<a[i][j]<<" ";
        fout<<"\n";
    }
}