banjalukaforum.com

#include <fstream>
#include <iostream>
#include <cstdlib>
using namespace std;

int main() {
    ifstream fin("ZGRADA.IN");
    ofstream fout("ZGRADA.OUT");
    long n,s;
    fin>>n;
    fin>>s;
    fin.close();
   
    if (n==1) {// nema komsija
       fout<<"nema susjeda";
       fout.close();
       fin.close();
       return 0;
   }
   
    // donji
    if (s>n)
       fout << s-n << endl;
       
    // gornji
    if (s<=n*n-n)
       fout << s+n << endl;   
   
    // lijevi
    if ((s-1)%n != 0)
       fout << s-1 << endl;
   
    // desni
    if (!(s%n)==0)
       fout << s+1 << endl;
       
    fout.close();
    return 0;   
}

import os
import shutil

ime = raw_input("Ime zadatka> ").lower()

cd="test"
for p,ds,fs in os.walk(cd,topdown=False):
    for f in [r.lower() for r in fs]:
        if not f.startswith(ime):
            continue
        if not f[:-1].endswith(".in"):
            continue
        shutil.copyfile(os.path.join(cd,f),ime+".in")
        print "______________%s______________" % (f)
        print "testniprimjer>"
        os.system(ime+".exe")
        o = file(os.path.join(cd,ime+".ou"+f[-1]))   # test
        print o.read()
        o.close()
        print "izlazprograma>"
        o = file(ime+".out")        # program
        print o.read()
        o.close()
        print "----------------------------------"
       
raw_input("KraJ >enter<")

#include <fstream>
#include <queue>

using namespace std;

#define MAX 50

int V[MAX][MAX];   // cvorovi grafa
bool E[MAX][MAX][4];// ivice grafa
int B[MAX][MAX];   // kojem bloku pripada ovo polje?

// 0 - lijevo, 1-gore, 2-desno, 3-dole
// true-ime zid, false-nema zida

int m,n;

void ulaz() {
   // pravi graf od ulaznog fajla
   ifstream fin("zamak.in");
   fin>>m>>n;
   int i,j,t;
   for (i=0; i<m; i++)
      for (j=0; j<n; j++) {
         B[i][j]=-1;   // ne pripada ni jednom
         fin>>t;
         V[i][j]=t;
         E[i][j][0] = (t>>3)>0;
         E[i][j][1] = (t>>2)>0;
         E[i][j][2] = (t>>1)>0;
         E[i][j][3] = (t> 0);
      }      
   fin.close();
}
vector <int> blokovi;

void fill() {
   // radi fill algoritam nad grafom (vrsta BFS-a)
   int blok=-1;
   int i,j;
   while (true) {
      int zblok = blok;
      // nadji slijedeci blok
      for (i=0; i<m, zblok==blok; i++)
         for (j=0; j<n, zblok==blok; j++)
            if (V[i][j] == 0)
               blok++;
      if (blok==zblok)
         break;
      
      bool loop;
      int size=1;
      V[i][j]=size;
      B[i][j]=blok;
      do {
         loop=false;
         for (i=0; i<m; i++)
            for (j=0; j<n; j++)
               if (B[i][j]==blok && V[i][j]==size)   {
                  if (!E[i][j][0]   && V[i][j-1]==0) {
                     loop = true;
                     B[i][j-1]=blok;
                     V[i][j-1]=size+1;
                  }
                  if (!E[i][j][1]   && V[i-1][j]==0) {
                     loop = true;
                     B[i-1][j]=blok;
                     V[i-1][j]=size+1;
                  }
                  if (!E[i][j][2]   && V[i][j+1]==0) {
                     loop = true;
                     B[i][j+1]=blok;
                     V[i][j+1]=size+1;
                  }
                  if (!E[i][j][3]   && V[i+1][j]==0) {
                     loop = true;
                     B[i+1][j]=blok;
                     V[i+1][j]=size+1;
                  }
               }
         size++;
      } while (loop);
      blokovi.push_back(size-1);
   }   
}

void izlaz() {
   ofstream fout("zamak.out");
   int maximum = (-2147483647 - 1);
   int maxkol = 0;
   int maxred = 0;
   int maxzid = 0;
   
   for (int i=0; i<m; i++)
      for (int j=0; j<n; j++)   {
         int mblok = B[i][j];   // kome pripada (i,j)
         int pblok;   // kome pripada blok pored (i,j)
         int z;      // zbir velicina blokova
         
         if (j<n-1) {
            pblok = B[i][j+1];   // desno
            if (E[i][j][2] && pblok!=mblok) {
               z = blokovi[mblok] + blokovi[pblok];
               if (z>maximum) {
                  maxred=i;
                  maxkol=j;
                  maxzid=3;
                  maximum=z;
               }
            }
         }
         
         if (i<m-1) {
            pblok = B[i+1][j];   // dole
            if (E[i][j][3] && pblok!=mblok) {
               z = blokovi[mblok] + blokovi[pblok];
               if (z>maximum) {
                  maxred=i;
                  maxkol=j;
                  maxzid=4;
                  maximum=z;
               }
            }   
         }
      }
   fout<<maxkol<<' '<<maxred<<' '<<maxzid<<endl;
   fout.close();
}

int main() {
   ulaz();
   fill();
   izlaz();   
   return 0;
}