void FindZPercolation(bool ifFind, int x, int y, int z)
{
	for (int i = x; i < wide-1; i++)
		for (int j = y; j < linear-1; j++)
		{
			if (matrix[i][j][z])
			{
				if (matrix[i+1][j][z])	FindZPercolation(TRUE, i+1, j, z);
				if (matrix[i][j+1][z])	FindZPercolation(TRUE, i, j+1, z);
				if (z == height-1)
				{
					if (matrix[i][j][z] && ifFind)	v = TRUE;
					ExitThread(0);
				}
				if (matrix[i][j][z+1])	FindZPercolation(TRUE, i, j, z+1);
			}
		}
}

#include <stdafx.h>
#include <time.h>
#include <conio.h>
#include <iostream>		
#include <assert.h>
#include <stdlib.h>

using namespace std;	


class UnionFind
{
public:
	UnionFind( int max_labels );
	~UnionFind();

	int find( int x );
	int Union( int x, int y );
	int make_set();

	int getNumLabels() const { return m_nLabels; }


protected:
	int*	labels;
	int		m_nLabels;     // длина массива
};

// конструктор устанавливает структуры данных, необходимые находка объединение реализацией.
UnionFind::UnionFind( int max_labels )
{
	m_nLabels = max_labels;
	labels = new int[m_nLabels];
	labels[0] = 0;
}

// Деструктор освобождает память
UnionFind::~UnionFind()
{
	m_nLabels = 0;
	delete labels;
	labels = 0;
}


int UnionFind::find(int x)
{
	int y = x;
	while (labels[y] != y)
		y = labels[y];
	
	while (labels[x] != x) {
		int z = labels[x];
		labels[x] = y;
		x = z;
	}
	return y;
}

int UnionFind::Union(int x, int y)
{
	return labels[find(x)] = find(y);
}

// make_set creates новый эквивалентный класс и возвращение его метки
int UnionFind::make_set() 
{
	labels[0] ++;
	labels[labels[0]] = labels[0];
	return labels[0];
}

// End Union-Find implementation
// -------------------------------------------------------------------


class Matrix
{
public:
	Matrix( int nRows, int nCols, double p );
	~Matrix();

	int  hoshen_kopelman();
	void check_labelling();
	void perk (bool &v, bool &g);

	// Оператор ввода
	friend istream& operator>>( istream& stream, Matrix& m );
	// Оператор вывода
	friend ostream& operator<<( ostream& stream, const Matrix& m );

protected:
  int	m_nRows, m_nCols;
  int**	matrix;
  double probability;
  int total_clusters;
  bool vert;
  bool goriz;
};


Matrix::Matrix( int nRows, int nCols, double p ) :
	m_nRows( nRows ), m_nCols( nCols ), probability (p)
{
	matrix = (int **)calloc( nRows, sizeof(int*) );  // Функция calloc захватывает пространство для хранения массива
         // из n элементов, каждый длиной size байт. Каждый элемент инициализируется в 0
                   
	for( int i=0; i < nRows; i++ ) {
		matrix[i] = (int *)calloc( nCols, sizeof(int) );
		memset (matrix[i], 0, nCols*sizeof(int));
	}

	//заполнение матрицы
	int c1 = nRows*nCols*p; //число единиц
	int k1 = 0;
	int ofs_r, ofs_c;
	srand (time(NULL));
	while (k1<c1) {
		ofs_r = rand()%nRows;
		ofs_c = rand()%nCols;
		if (matrix[ofs_r][ofs_c]!=0) continue;
		matrix[ofs_r][ofs_c] = 1;
		k1++;
	}
	//--------------------
}

Matrix::~Matrix()
{
	for( int i=0; i < m_nRows; i++ )
		free( matrix[i] ); // освобождаем блок памяти
	free( matrix );
}

istream& operator>>( istream& stream, Matrix& m )
{
	for( int i=0; i < m.m_nRows; i++ )
		for( int j=0; j < m.m_nCols; j++ )
			stream >> m.matrix[i][j];

	return stream;
}


ostream& operator<<( ostream& stream, const Matrix& m )
{
	for( int i=0; i < m.m_nRows; i++ ) {
		for( int j=0; j < m.m_nCols; j++ ) {
			stream.width(3);
			stream << m.matrix[i][j];
		}
		stream << endl;
	}
	return stream;
}

#define max(a,b) (a>b?a:b)
#define min(a,b) (a>b?b:a)

// Label the clusters in "matrix". возвращает кол-во найденных кластеров.
int Matrix::hoshen_kopelman()
{
	UnionFind uf( m_nRows*m_nCols/2 );
	
	// просмотр матрицы 
	for( int i=0; i<m_nRows; i++ )
		for (int j=0; j<m_nCols; j++)
			if( matrix[i][j] ) {						// если занято...
				int up = (i==0 ? 0 : matrix[i-1][j]);   // смотрим вверх
				int left = (j==0 ? 0 : matrix[i][j-1]); // смотрим влево
				switch (!!up + !!left) {
				case 0:
					matrix[i][j] = uf.make_set();		// новый кластер
					break;
					
				case 1:									// часть существующего кластера
					matrix[i][j] = max(up,left);		// какой бы ни является отличным от нуля, помечен
					break;
					
				case 2:									// связываем 2 кластера
					matrix[i][j] = uf.Union(up, left);
					break;
				}
			}
			
	// примените перемаркирование к матрице

	
	int* new_labels = new int[uf.getNumLabels()]; // распределите массив, инициализированный, чтобы обнулить
	memset( new_labels, 0, sizeof(int)*uf.getNumLabels() );
	
	for(int i=0; i < m_nRows; i++)
		for (int j=0; j < m_nCols; j++)
			if (matrix[i][j]) {
				int x = uf.find(matrix[i][j]);
				if (new_labels[x] == 0) {
					new_labels[0]++;
					new_labels[x] = new_labels[0];
				}
				matrix[i][j] = new_labels[x];
			}
			
	total_clusters = new_labels[0];
	
	delete new_labels;
	return total_clusters;
}


void Matrix::perk (bool &v, bool &g) 
{
	vert = false;
	goriz = false;
	for (int i=1; i<=total_clusters; i++) {
		int mi; int mj = 0;
		bool f1 = false, f2 = false; //проверка на горизонтальную
		for (int mi=0; mi<m_nRows; mi++) { //просмотр первого и последнего столбца
			if (matrix[mi][0]==i) f1 = true;
			if (matrix[mi][m_nCols-1]==i) f2 = true;
		}
		if (f1 && f2) goriz = true;

		f1 = false, f2 = false; //проверка на вертикальную
		for (int mj=0; mj<m_nCols; mj++) { //просмотр первой и последней строки
			if (matrix[0][mj]==i) f1 = true;
			if (matrix[m_nRows-1][0]==i) f2 = true;
		}
		if (f1 && f2) vert = true;
		if (vert && goriz) break;
	}
	v = vert; g = goriz;
}

int main()
{
 	int m, n;
	int s; // счетчик прогонов для каждой вероятности
	int v1,g1, ob, od; // количество перколяций
	bool v, g;
	float pv1,pg1,pob1,pod1; // вероятности возникновения перколяций
	
	FILE *fp;


	cout<<"Vvedite kol-vo strok and colon"<<endl;
	cin >> m >> n;	// m = строки, n = стобцы
	if ((fp=freopen("percol.txt", "w", stdout)) == NULL)
   {
      printf("He удается открыть файл.\n");
      exit(1);
   }
	for (double p = 0.01; p<=1; p+=0.01) { //перебираем вероятности
		//if (p>0.99) p=1;
		s=0; v1=0; g1=0; ob=0; od=0;
		for (int k=0;k<10; k++){
						 
			Matrix matrix( m, n, p );
			// вывод вероятности
			cout<<"probability -  "<< p<< endl;

			// вывод матрицы
		//	cout << " --input-- \n" << matrix; 

			// поиск кластеров
			int clusters = matrix.hoshen_kopelman();

			// вывод результатов
			//cout << " --output-- \n" << matrix;

			
			matrix.perk (v, g);
			if(v==true) v1+=1; 
			if(g==true) g1+=1;
			if((v==true)&&(g==true)) ob+=1; // обе перколяции
			if((v==true)||(g==true)) od+=1; // хотя бы одна
			cout << "Vertical: " << (v?"yes":"no") <<";\nGorizontal: " << (g?"yes":"no") << endl<<endl;
			
			s+=1;
		}
		cout<<"kol-vo vertical perkolyaciy  "<< v1<<";\nKol-vo gorizontal perkolyaciy  " <<g1<<";\nKol-vo obeih perkolyaciy   "<<ob<<";\nHotya by odna perkolyaciya   "<<od<<endl;
		cout<< "kol-vo progonov dlya veroyatnosti  "<<p<<" -  "<<s<<endl<<endl;
		pv1=(float)v1/s;
		pg1=(float)g1/s;
		pob1=(float)ob/s;
		pod1=(float)od/s;
		cout<<"Veroyatnost' vozniknoveniya vertical perkolyacii  "<<pv1<<";\nVeroyatnost' vozniknoveniya gorizontal perkolyacii  "<<pg1<<";\nVeroyatnost' vozniknoveniya obeih perkolyaciy  "<<pob1<<";\nVeroyatnost' vozniknoveniya hotyaby odnoj perkolyacii  "<<pod1<<endl<<endl;
		
		cout<<"-------------------------------------------------------------"<<endl;
	}
		
	
	
	fclose(fp);
	getch();
	return 0;
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace txt2xml
{
    class Percolation
    {
        static byte[][][] Matrix;
        static int X, Y, Z;

        public static void Main()
        {
            Console.WriteLine("Введите длину (X): ");
            while (!int.TryParse(Console.ReadLine(), out X)) ;
            Console.WriteLine("Введите высоту (Y): ");
            while (!int.TryParse(Console.ReadLine(), out Y)) ;
            Console.WriteLine("Введите глубину (Z): ");
            while (!int.TryParse(Console.ReadLine(), out Z)) ;

            Matrix = new byte[Z][][]; //Создаем матрицу
            for (int z = 0; z < Z; z++)
            {
                Matrix[z] = new byte[Y][];
                for (int y = 0; y < Y; y++)
                    Matrix[z][y] = new byte[X];
            }

            Random Rand=new Random();

            int cntAll = 0, cntSome = 0, cntX = 0, cntY = 0, cntZ = 0;

            for (double Prob = 0.01; Prob <= 1.0; Prob += 0.01)
            {
                Console.WriteLine("Вероятность: {0}", Prob);

                for (int s = 0; s < 10; s++)
                {
                    for (int z = 0; z < Z; z++)
                        for (int y = 0; y < Y; y++)
                            for (int x = 0; x < X; x++)
                                Matrix[z][y][x] = (byte)(Rand.NextDouble() <= Prob ? 1 : 0);
                }

                bool HaveZ = FindZPercolation();
                bool HaveY = FindYPercolation();
                bool HaveX = FindXPercolation();

                if (HaveX) cntX++;
                if (HaveY) cntY++;
                if (HaveZ) cntZ++;
                if (HaveX && HaveY && HaveZ) cntAll++;
                if (HaveX || HaveY || HaveZ) cntSome++;

                Console.WriteLine("X: {0}\nY: {1}\nZ: {2}", HaveX ? "да" : "нет", HaveY ? "да" : "нет", HaveZ ? "да" : "нет");
            }

            Console.WriteLine("Статистика");
            Console.WriteLine("Кол-во перколяций по ширине: {0}", cntX);
            Console.WriteLine("\nКол-во перколяций по длине: {0}", cntY);
            Console.WriteLine("\nКол-во перколяций по высоте: {0}", cntZ);
            Console.WriteLine("\nКол-во всех перколяций: {0}", cntAll);
            Console.WriteLine("\nХотя бы одна перколяция: {0}", cntSome);
        }

        private static bool FindZPercolation()
        {
            const int Flag = 4;
            for (int y = 0; y < Y; y++)
                for (int x = 0; x < X; x++)
                {
                    int E = Matrix[0][y][x];
                    if (E != 0 && E != Flag)
                        if (TraverseZ(0, y, x))
                            return true;
                }
            return false;
        }

        private static bool FindYPercolation()
        {
            const int Flag = 3;
            for (int z = 0; z < Z; z++)
                for (int x = 0; x < X; x++)
                {
                    int E = Matrix[z][0][x];
                    if (E != 0 && E != Flag)
                        if (TraverseY(z, 0, x))
                            return true;
                }
            return false;
        }
        

        private static bool FindXPercolation()
        {
            const int Flag = 2;
            for (int z = 0; z < Z; z++)
                for (int y = 0; y < Y; y++)
                {
                    int E = Matrix[z][y][0];
                    if (E != 0 && E != Flag)
                        if (TraverseX(z, y, 0))
                            return true;
                }
            return false;
        }

        private static bool TraverseZ(int z, int y, int x)
        {
            const int Flag = 4;
            Matrix[z][y][x] = Flag;

            if (z == Z - 1) return true;
            else
            {
                byte E=Matrix[z + 1][y][x];
                if (E != 0 && E != Flag)
                    if (TraverseZ(z + 1, y, x))
                        return true;
            }

            if (y < Y - 1)
            {
                byte E = Matrix[z][y + 1][x];
                if (E != 0 && E != Flag)
                    if (TraverseZ(z, y + 1, x))
                        return true;
            }

            if (x < X - 1)
            {
                byte E = Matrix[z][y][x + 1];
                if (E != 0 && E != Flag)
                    if (TraverseZ(z, y, x + 1))
                        return true;
            }

            if (x > 0)
            {
                byte E = Matrix[z][y][x - 1];
                if (E != 0 && E != Flag)
                    if (TraverseZ(z, y, x - 1))
                        return true;
            }

            if (y > 0)
            {
                byte E = Matrix[z][y - 1][x];
                if (E != 0 && E != Flag)
                    if (TraverseZ(z, y - 1, x))
                        return true;
            }

            if (z > 0)
            {
                byte E = Matrix[z - 1][y][x];
                if (E != 0 && E != Flag)
                    if (TraverseZ(z - 1, y, x))
                        return true;
            }

            return false;
        }

        private static bool TraverseY(int z, int y, int x)
        {
            const int Flag = 3;
            Matrix[z][y][x] = Flag;

            if (y == Y - 1) return true;
            else
            {
                byte E = Matrix[z][y + 1][x];
                if (E != 0 && E != Flag)
                    if (TraverseY(z, y + 1, x))
                        return true;
            }

            if (z < Z - 1)
            {
                byte E = Matrix[z + 1][y][x];
                if (E != 0 && E != Flag)
                    if (TraverseY(z + 1, y, x))
                        return true;
            }
            
            if (x < X - 1)
            {
                byte E = Matrix[z][y][x + 1];
                if (E != 0 && E != Flag)
                    if (TraverseY(z, y, x + 1))
                        return true;
            }

            if (x > 0)
            {
                byte E = Matrix[z][y][x - 1];
                if (E != 0 && E != Flag)
                    if (TraverseY(z, y, x - 1))
                        return true;
            }

            if (z > 0)
            {
                byte E = Matrix[z - 1][y][x];
                if (E != 0 && E != Flag)
                    if (TraverseY(z - 1, y, x))
                        return true;
            }

            if (y > 0)
            {
                byte E = Matrix[z][y - 1][x];
                if (E != 0 && E != Flag)
                    if (TraverseY(z, y - 1, x))
                        return true;
            }

            return false;
        }

        private static bool TraverseX(int z, int y, int x)
        {
            const int Flag = 2;
            Matrix[z][y][x] = Flag;

            if (x == X - 1) return true;
            else
            {
                byte E = Matrix[z][y][x + 1];
                if (E != 0 && E != Flag)
                    if (TraverseX(z, y, x + 1))
                        return true;
            }

            if (y < Y - 1)
            {
                byte E = Matrix[z][y + 1][x];
                if (E != 0 && E != Flag)
                    if (TraverseX(z, y + 1, x))
                        return true;
            }

            if (z < Z - 1)
            {
                byte E = Matrix[z + 1][y][x];
                if (E != 0 && E != Flag)
                    if (TraverseX(z + 1, y, x))
                        return true;
            }

            if (x > 0)
            {
                byte E = Matrix[z][y][x - 1];
                if (E != 0 && E != Flag)
                    if (TraverseX(z, y, x - 1))
                        return true;
            }

            if (y > 0)
            {
                byte E = Matrix[z][y - 1][x];
                if (E != 0 && E != Flag)
                    if (TraverseX(z, y - 1, x))
                        return true;
            }

            if (z > 0)
            {
                byte E = Matrix[z - 1][y][x];
                if (E != 0 && E != Flag)
                    if (TraverseX(z - 1, y, x))
                        return true;
            }

            return false;
        }
    }
}

//#include <stdafx.h>
#include <time.h>
#include <conio.h>
#include <iostream>		
#include <assert.h>
#include <stdlib.h>

using namespace std;	


class UnionFind
{
public:
	UnionFind( int max_labels );
	~UnionFind();

	int find( int x );
	int Union( int x, int y, int z );
	int make_set();

	int getNumLabels() const { return m_nLabels; }


protected:
	int**	labels;
	int		m_nLabels;     // длина массива
};

// конструктор устанавливает структуры данных, необходимые находка объединение реализацией.
UnionFind::UnionFind( int max_labels )
{
	m_nLabels = max_labels;
	labels = new int[m_nLabels];
	labels[0][0] = 0;
}

// Деструктор освобождает память
UnionFind::~UnionFind()
{
	m_nLabels = 0;
	delete labels;
	labels = 0;
}


int UnionFind::find(int x)
{
	int y = x;
	while (labels[y] != y)
		y = labels[y];
	
	while (labels[x] != x) {
		int z = labels[x];
		labels[x] = y;
		x = z;
	}
	return y;
}

int UnionFind::Union(int x, int y, int z)
{
	return labels[find(x)] = find(y);
}

// make_set creates новый эквивалентный класс и возвращение его метки
int UnionFind::make_set() 
{
	labels[0][0] ++;
	labels[labels[0][0]] = labels[0][0];
	return labels[0][0];
}

// End Union-Find implementation
// -------------------------------------------------------------------


class Matrix
{
public:
	Matrix( int nRows, int nCols, int nWide, double p );
	~Matrix();

	int  hoshen_kopelman();
	void check_labelling();
	void perk (bool &v, bool &g, bool &d);

	// Оператор ввода
	friend istream& operator>>( istream& stream, Matrix& m );
	// Оператор вывода
	friend ostream& operator<<( ostream& stream, const Matrix& m );

protected:
  int	m_nRows, m_nCols, m_nWide;
  int***	matrix;
  double probability;
  int total_clusters;
  bool vert;
  bool goriz;
  bool diag;
};


Matrix::Matrix( int nRows, int nCols, int nWide, double p ) :
	m_nRows( nRows ), m_nCols( nCols ), m_nWide( nWide), probability (p)
{
	matrix = (int ***)calloc( nRows, sizeof(int**) );  // Функция calloc захватывает пространство для хранения массива
         // из n элементов, каждый длиной size байт. Каждый элемент инициализируется в 0
                   
	for( int i=0; i < nRows; i++ ) 
			matrix[i] = (int **)calloc( nCols, sizeof(int*) );
	
	for (int i = 0; i < nRows; i++)
		for (int j = 0; j < nCols; j++) {
			matrix[i][j] = (int *)calloc(nWide, sizeof(int) );
			memset (matrix[i][j], 0, nWide*sizeof(int));
		}


		
	//заполнение матрицы
	int c1 = nRows*nCols*nWide*p; //число единиц
	int k1 = 0;
	int ofs_r, ofs_c, ofs_w;
	srand (time(NULL));
	while (k1<c1) {
		ofs_r = rand()%nRows;
		ofs_c = rand()%nCols;
		ofs_w = rand()%nWide;
		if (matrix[ofs_r][ofs_c][ofs_w]!=0) continue;
		matrix[ofs_r][ofs_c][ofs_w] = 1;
		k1++;
	}
	//--------------------
}

Matrix::~Matrix()
{
	/*for( int i=0; i < m_nRows; i++ )
		free( matrix[i] ); // освобождаем блок памяти
	free( matrix );
	*/
	for (int i = 0; i < m_nRows; i++)
		for (int j = 0; j < m_nCols; j++)
			delete [] matrix[i][j];

	for (int i = 0; i < m_nRows; i++)
		delete [] matrix[i];

	delete [] matrix;
}

istream& operator>>( istream& stream, Matrix& m )
{
	for( int i=0; i < m.m_nRows; i++ )
		for( int j=0; j < m.m_nCols; j++ )
			for( int k=0; k < m.m_nWide; k++ )
				stream >> m.matrix[i][j][k];

	return stream;
}


ostream& operator<<( ostream& stream, const Matrix& m )
{
	for( int i=0; i < m.m_nRows; i++ ) {
		for( int j=0; j < m.m_nCols; j++ )
			for( int k=0; k < m.m_nWide; k++ )
				{
			stream.width(3);
			stream << m.matrix[i][j][k];
		}
		stream << endl;
	}
	return stream;
}

#define max(a,b) (a>b?a:b)
#define min(a,b) (a>b?b:a)

// Label the clusters in "matrix". возвращает кол-во найденных кластеров.
int Matrix::hoshen_kopelman()
{
	UnionFind uf( m_nRows*m_nCols*m_nCols/2 );
	
	// просмотр матрицы 
	for( int i=0; i<m_nRows; i++ )
		for (int j=0; j<m_nCols; j++)
			for( int k=0; j < m_nWide; k++ )
				if( matrix[i][j][k] ) {						// если занято...
					int up = (i==0 ? 0 : matrix[i-1][j][k]);   // смотрим вверх
					int left = (j==0 ? 0 : matrix[i][j-1][k]);// смотрим влево
					int vgl = (k==0 ? 0 : matrix[i][j][k-1]);
					switch (!!up + !!left) {
					case 0:
						matrix[i][j][k] = uf.make_set();		// новый кластер
						break;
					
					case 1:									// часть существующего кластера
						matrix[i][j][k] = max(up,left, vgl);		// какой бы ни является отличным от нуля, помечен
						break;
					
					case 2:									// связываем 2 кластера
						matrix[i][j][k] = uf.Union(up, left,vgl);
						break;
				}
			}
			
	// примените перемаркирование к матрице

	
	int* new_labels = new int[uf.getNumLabels()]; // распределите массив, инициализированный, чтобы обнулить
	memset( new_labels, 0, sizeof(int)*uf.getNumLabels() );
	
	for(int i=0; i < m_nRows; i++)
		for (int j=0; j < m_nCols; j++)
			for( int k=0; k < m_nWide; k++ )
				if (matrix[i][j][k]) {
					int x = uf.find(matrix[i][j][k]);
					if (new_labels[x] == 0) {
						new_labels[0]++;
						new_labels[x] = new_labels[0];
					}
					matrix[i][j][k] = new_labels[x];
				}
			
	total_clusters = new_labels[0];
	
	delete new_labels;
	return total_clusters;
}


void Matrix::perk (bool &v, bool &g, bool &d) 
{
	vert = false;
	goriz = false;
	diag = false;
	for (int i=1; i<=total_clusters; i++) {
		int mi = 0; int mj = 0; int mk = 0;
		bool f1 = false, f2 = false; //проверка на горизонтальную
		for (int mk=0; mk<m_nWide; mk++)
			for (int mi=0; mi<m_nRows; mi++) { //просмотр первого и последнего столбца
				if (matrix[mi][0][mk]==i) f1 = true;
				if (matrix[mi][m_nCols-1][mk]==i) f2 = true;
							}
		if (f1 && f2) goriz = true;

		f1 = false, f2 = false; //проверка на вертикальную
		for (int mk=0; mk<m_nWide; mk++)
			for (int mj=0; mj<m_nCols; mj++) { //просмотр первой и последней строки
				if (matrix[0][mj][0]==i) f1 = true;
				if (matrix[m_nRows-1][0][mk]==i) f2 = true;
			}
		if (f1 && f2) vert = true;

		f1 = false, f2 = false; //проверка на диагональную
		for (int mk=0; mk<m_nWide; mk++) { //просмотр первой и последней строки
			if (matrix[0][0][mk]==i) f1 = true;
			if (matrix[m_nRows-1][0][m_nWide]==i) f2 = true;
		}
		if (f1 && f2) diag = true;
		
		if (vert && goriz && diag) break;
	}
	v = vert; g = goriz; d = diag; 
}

int main()
{
 	int m, n, l;
	int s; // счетчик прогонов для каждой вероятности
	int v1,g1, d1, ob, od; // количество перколяций
	bool v, g, d;
	float pv1,pg1,pd1, pob1,pod1; // вероятности возникновения перколяций
	
	FILE *fp;


	cout<<"Vvedite dlinu, shirinu and vysota "<<endl;
	cin >> m >> n >>l ;	// m = строки, n = стобцы
	if ((fp=freopen("output.txt", "w", stdout)) == NULL)
   {
      printf("He удается открыть файл.\n");
      exit(1);
   }
	for (double p = 0.01; p<=1; p+=0.01) { //перебираем вероятности
		//if (p>0.99) p=1;
		s=0; v1=0; g1=0; d1=0; ob=0; od=0;
		for (int k=0;k<10; k++){
						 
			Matrix matrix( m, n, l, p );
			// вывод вероятности
			cout<<"probability -  "<< p<< endl;

			// вывод матрицы
		//	cout << " --input-- \n" << matrix; 

			// поиск кластеров
			int clusters = matrix.hoshen_kopelman();

			// вывод результатов
			//cout << " --output-- \n" << matrix;

			
			matrix.perk (v, g, d);
			if(v==true) v1+=1; 
			if(g==true) g1+=1;
			if(d==true) d1+=1;
			if((v==true)&&(g==true)&&(d==true)) ob+=1; // обе перколяции
			if((v==true)||(g==true)||(d==true)) od+=1; // хотя бы одна
			cout << "Vertical: " << (v?"yes":"no") <<";\nGorizontal: " << (g?"yes":"no") << endl<<endl;
			
			s+=1;
		}
		cout<<"kol-vo vertical perkolyaciy  "<< v1<<";\nKol-vo gorizontal perkolyaciy  " <<g1<<";\nKol-vo diagonal perkolyaciy  "<<d1<<";\nKol-vo obeih perkolyaciy   "<<ob<<";\nHotya by odna perkolyaciya   "<<od<<endl;
		cout<< "kol-vo progonov dlya veroyatnosti  "<<p<<" -  "<<s<<endl<<endl;
		pv1=(float)v1/s;
		pg1=(float)g1/s;
		pd1=(float)d1/s;
		pob1=(float)ob/s;
		pod1=(float)od/s;
		cout<<"Veroyatnost' vozniknoveniya vertical perkolyacii  "<<pv1<<";\nVeroyatnost' vozniknoveniya gorizontal perkolyacii  "<<pg1<<";\nVeroyatnost' vozniknoveniya diagonal perkolyacii  "<<pd1<<";\nVeroyatnost' vozniknoveniya obeih perkolyaciy  "<<pob1<<";\nVeroyatnost' vozniknoveniya hotyaby odnoj perkolyacii  "<<pod1<<endl<<endl;
		
		cout<<"-------------------------------------------------------------"<<endl;
	}
		
	
	
	fclose(fp);
	getch();
	return 0;
}

Вероятность: 0,29
X: нет
Y: нет
Z: нет
Вероятность: 0,3
X: нет
Y: нет
Z: да
Вероятность: 0,31
X: да
Y: нет
Z: да
Вероятность: 0,32
X: да
Y: да
Z: нет
Вероятность: 0,33
X: да
Y: да
Z: да

#include "stdafx.h"

#include <time.h>
#include <conio.h>
#include <iostream>		
#include <assert.h>
#include <stdlib.h>

using namespace std;	
int X, Y, Z;
int ***Matrix;
bool FindXPercolation();
bool FindYPercolation();
bool FindZPercolation();

bool TraverseX(int x, int y, int z);
bool TraverseY(int x, int y, int z);
bool TraverseZ(int x, int y, int z);

int main()
{
 	int X, Y, Z;
	int cntAll = 0, cntSome = 0, cntX = 0, cntY = 0, cntZ = 0; // количество перколяций
	float pv1,pg1,pd1, pob1,pod1; // вероятности возникновения перколяций
	int ***Matrix;
	
	FILE *fp;


	cout<<"Vvedite dlinu, vysotu and glubinu  "<<endl;
	cin >> X >> Y >>Z ;	// m = строки, n = стобцы
	if ((fp=freopen("output.txt", "w", stdout)) == NULL)
   {
      printf("He удается открыть файл.\n");
      exit(1);
   }
   // создаю matrix размерностью [X][Y][Z]
	Matrix = new int**[X];

	for (int i = 0; i < X; i++)
		Matrix[i] = new int*[Y];

	for (int i = 0; i < X; i++)
		for (int j = 0; j < Y; j++)
			Matrix[i][j] = new int[Z];

                        

            for (double p = 0.01; p <= 1.0; p += 0.01)
            {
				int k=0;  int cntAll = 0, cntSome = 0, cntX = 0, cntY = 0, cntZ = 0;
				// вывод вероятности
                cout<<"вероятность -  "<< p<< endl;
				// счетчик прогонов
                for (int s = 0; s < 10; s++)
				
                {
                    for (int x = 0; x < X; x++)
                        for (int y = 0; y < Y; y++)
                            for (int z = 0; z < Z; z++)
							{
                                double random = (double) rand() / RAND_MAX;
								if (random <= p) Matrix[x][y][z] = 1; else Matrix[x][y][z] = 0;
								}
                

                bool HaveX = FindXPercolation();
                bool HaveY = FindYPercolation();
                bool HaveZ = FindZPercolation();

                if (HaveX) cntX++;
                if (HaveY) cntY++;
                if (HaveZ) cntZ++;
                if (HaveX && HaveY && HaveZ) cntAll++;
                if (HaveX || HaveY || HaveZ) cntSome++;

               	cout << "по ширине  " << (HaveX?"yes":"no") <<";\nпо длине: " << (HaveY?"yes":"no") <<";\nпо высоте: " << (HaveZ?"yes":"no") << endl<<endl;
				k+=1;
				}
			
			
			cout<<"Кол-во перколяций по ширине:   "<< cntX<<";\nКол-во перколяций по длине:  " <<cntY<<";\nКол-во перколяций по высоте: "<<cntZ<<";\nКол-во всех перколяций:  "<<cntAll<<";\nХотя бы одна перколяция:  "<<cntSome<<endl;
		cout<< "kol-vo progonov dlya veroyatnosti  "<<p<<" -  "<<k<<endl<<endl;
		pv1=(float)cntX/k;
		pg1=(float)cntY/k;
		pd1=(float)cntZ/k;
		pob1=(float)cntAll/k;
		pod1=(float)cntSome/k;
		cout<<"Вероятность возникновения перколяции по ширине  "<<pv1<<";\nВероятность возникновения перколяции по длине "<<pg1<<";\nVВероятность возникновения перколяции по высоте  "<<pd1<<";\nВероятность возникновения всех перколяций  "<<pob1<<";\nВероятность возникновения хотя бы одной  "<<pod1<<endl<<endl;
		
		cout<<"-------------------------------------------------------------"<<endl;
			}
    fclose(fp);
	getch();
	return 0;
}



         bool FindXPercolation()
        {
            const int Flag = 4;
            for (int y = 0; y < Y; y++)
                for (int z = 0; z < Z; z++)
                {
                    int E = Matrix[0][y][z];
                    if (E != 0 && E != Flag)
                        if (TraverseX(0, y, z))
                            return true;
                }
            return false;
        }

         bool FindYPercolation()
        {
            const int Flag = 3;
            for (int x = 0; x < X; x++)
                for (int z = 0; z < Z; z++)
                {
                    int E = Matrix[x][0][Z];
                    if (E != 0 && E != Flag)
                        if (TraverseY(x, 0, z))
                            return true;
                }
            return false;
        }
        

         bool FindZPercolation()
        {
            const int Flag = 2;
            for (int x = 0; x < X; x++)
                for (int y = 0; y < Y; y++)
                {
                    int E = Matrix[x][y][0];
                    if (E != 0 && E != Flag)
                        if (TraverseX(x, y, 0))
                            return true;
                }
            return false;
        }

        bool TraverseX(int x, int y, int z)
        {
            const int Flag = 4;
            Matrix[x][y][y] = Flag;

            if (x == X - 1) return true;
            else
            {
                int E = Matrix[x + 1][y][z];
                if (E != 0 && E != Flag)
                    if (TraverseX(x + 1, y, z))
                        return true;
            }

            if (y < Y - 1)
            {
                int E = Matrix[x][y + 1][z];
                if (E != 0 && E != Flag)
                    if (TraverseX(x, y + 1, z))
                        return true;
            }

            if (z < Z - 1)
            {
                int E = Matrix[x][y][z + 1];
                if (E != 0 && E != Flag)
                    if (TraverseX(x, y, z + 1))
                        return true;
            }

            if (z > 0)
            {
                int E = Matrix[x][y][z - 1];
                if (E != 0 && E != Flag)
                    if (TraverseX(x, y, z - 1))
                        return true;
            }

            if (y > 0)
            {
                int E = Matrix[x][y - 1][z];
                if (E != 0 && E != Flag)
                    if (TraverseX(x, y - 1, z))
                        return true;
            }

            if (x > 0)
            {
                int E = Matrix[x - 1][y][z];
                if (E != 0 && E != Flag)
                    if (TraverseX(x - 1, y, z))
                        return true;
            }

            return false;
        }

        bool TraverseY(int x, int y, int z)
        {
            const int Flag = 3;
            Matrix[x][y][z] = Flag;

            if (y == Y - 1) return true;
            else
            {
                int E = Matrix[x][y + 1][z];
                if (E != 0 && E != Flag)
                    if (TraverseY(x, y + 1, z))
                        return true;
            }

            if (x < X - 1)
            {
                int E = Matrix[x + 1][y][z];
                if (E != 0 && E != Flag)
                    if (TraverseY(x + 1, y, x))
                        return true;
            }
            
            if (z < Z - 1)
            {
                int E = Matrix[x][y][z + 1];
                if (E != 0 && E != Flag)
                    if (TraverseY(x, y, z + 1))
                        return true;
            }

            if (z > 0)
            {
                int E = Matrix[x][y][z - 1];
                if (E != 0 && E != Flag)
                    if (TraverseY(x, y, z - 1))
                        return true;
            }

            if (x > 0)
            {
                int E = Matrix[x - 1][y][z];
                if (E != 0 && E != Flag)
                    if (TraverseY(x - 1, y, z))
                        return true;
            }

            if (y > 0)
            {
                int E = Matrix[x][y - 1][z];
                if (E != 0 && E != Flag)
                    if (TraverseY(x, y - 1, z))
                        return true;
            }

            return false;
        }

         bool TraverseZ(int x, int y, int z)
        {
            const int Flag = 2;
            Matrix[x][y][z] = Flag;

            if (z == Z - 1) return true;
            else
            {
                int E = Matrix[x][y][z + 1];
                if (E != 0 && E != Flag)
                    if (TraverseZ(x, y, z + 1))
                        return true;
            }

            if (y < Y - 1)
            {
                int E = Matrix[x][y + 1][z];
                if (E != 0 && E != Flag)
                    if (TraverseZ(x, y + 1, z))
                        return true;
            }

            if (x < X - 1)
            {
                int E = Matrix[x + 1][y][z];
                if (E != 0 && E != Flag)
                    if (TraverseZ(x + 1, y, z))
                        return true;
            }

            if (z > 0)
            {
                int E = Matrix[x][y][z - 1];
                if (E != 0 && E != Flag)
                    if (TraverseZ(x, y, z - 1))
                        return true;
            }

            if (y > 0)
            {
                int E = Matrix[x][y - 1][z];
                if (E != 0 && E != Flag)
                    if (TraverseZ(x, y - 1, z))
                        return true;
            }

            if (x > 0)
            {
                int E = Matrix[x - 1][y][z];
                if (E != 0 && E != Flag)
                    if (TraverseZ(x - 1, y, z))
                        return true;
            }

            return false;
        }
    

#include "stdafx.h"
#include <time.h>
#include <conio.h>
#include <iostream>		
#include <assert.h>
#include <stdlib.h>
using namespace std;	

int X, Y, Z;
int ***Matrix;

bool FindXPercolation();
bool FindYPercolation();
bool FindZPercolation();
bool TraverseX(int x, int y, int z);
bool TraverseY(int x, int y, int z);
bool TraverseZ(int x, int y, int z);

int main()
{
	int cntAll = 0, cntSome = 0, cntX = 0, cntY = 0, cntZ = 0; // количество перколяций	
	float pv1,pg1,pd1, pob1,pod1; // вероятности возникновения перколяций	
		
	FILE *fp;	
	cout<<"Vvedite dlinu, vysotu and glubinu  "<<endl;	cin >> X >> Y >>Z ;	// m = строки, n = стобцы	
	if ((fp=freopen("output.txt", "w", stdout)) == NULL)   
	{      
		printf("He удается открыть файл.\n");      
		exit(1);   
	}   
	// создаю matrix размерностью [X][Y][Z]	
	Matrix = new int**[X];	
	for (int i = 0; i < X; i++)		
		Matrix[i] = new int*[Y];	
	for (int i = 0; i < X; i++)		
		for (int j = 0; j < Y; j++)			
			Matrix[i][j] = new int[Z];                                    
	for (double p = 0.01; p <= 1.0; p += 0.01)
	{				
		int k=0;  
		int cntAll = 0, cntSome = 0, cntX = 0, cntY = 0, cntZ = 0;				
		// вывод вероятности                
		cout<<"вероятность -  "<< p<< endl;				
		// счетчик прогонов                
		for (int s = 0; s < 10; s++)				   
		{             
			for (int x = 0; x < X; x++)   
				for (int y = 0; y < Y; y++) 
					for (int z = 0; z < Z; z++)	
					{         
						double random = (double) rand() / RAND_MAX;		
						if (random <= p) Matrix[x][y][z] = 1; else Matrix[x][y][z] = 0;			
					}          
					bool HaveX = FindXPercolation(); 
					bool HaveY = FindYPercolation();    
					bool HaveZ = FindZPercolation(); 
					
					if (HaveX) cntX++;   
					if (HaveY) cntY++;    
					if (HaveZ) cntZ++; 
					if (HaveX && HaveY && HaveZ) cntAll++;   
					if (HaveX || HaveY || HaveZ) cntSome++;  
					cout << "по ширине  " << (HaveX?"yes":"no") <<";\nпо длине: " << (HaveY?"yes":"no") <<";\nпо высоте: " << (HaveZ?"yes":"no") << endl<<endl;	
					k+=1;	
		}							
		cout<<"Кол-во перколяций по ширине:   "<< cntX<<";\nКол-во перколяций по длине:  " <<cntY<<";\nКол-во перколяций по высоте: "<<cntZ<<";\nКол-во всех перколяций:  "<<cntAll<<";\nХотя бы одна перколяция:  "<<cntSome<<endl;
		cout<< "kol-vo progonov dlya veroyatnosti  "<<p<<" -  "<<k<<endl<<endl;
		pv1=(float)cntX/k;
		pg1=(float)cntY/k;
		pd1=(float)cntZ/k;	
		pob1=(float)cntAll/k;
		pod1=(float)cntSome/k;		
		cout<<"Вероятность возникновения перколяции по ширине  "<<pv1<<";\nВероятность возникновения перколяции по длине "<<pg1<<";\nVВероятность возникновения перколяции по высоте  "<<pd1<<";\nВероятность возникновения всех перколяций  "<<pob1<<";\nВероятность возникновения хотя бы одной  "<<pod1<<endl<<endl;	
		cout<<"-------------------------------------------------------------"<<endl;	
	}  
	fclose(fp);	
	getch();
	return 0;
}

bool FindZPercolation()
{
    const int Flag = 4;
    for (int y = 0; y < Y; y++)
        for (int x = 0; x < X; x++)
        {
            int E = Matrix[0][y][x];
            if (E != 0 && E != Flag)
                if (TraverseZ(0, y, x))
                    return true;
        }
    return false;
}

bool FindYPercolation()
    {
        const int Flag = 3;
        for (int z = 0; z < Z; z++)
            for (int x = 0; x < X; x++)
            {
                int E = Matrix[z][0][x];
                if (E != 0 && E != Flag)
                    if (TraverseY(z, 0, x))
                        return true;
            }
        return false;
    }
        

        bool FindXPercolation()
    {
        const int Flag = 2;
        for (int z = 0; z < Z; z++)
            for (int y = 0; y < Y; y++)
            {
                int E = Matrix[z][y][0];
                if (E != 0 && E != Flag)
                    if (TraverseX(z, y, 0))
                        return true;
            }
        return false;
    }

        bool TraverseZ(int z, int y, int x)
    {
        const int Flag = 4;
        Matrix[z][y][x] = Flag;

        if (z == Z - 1) return true;
        else
        {
            int E=Matrix[z + 1][y][x];
            if (E != 0 && E != Flag)
                if (TraverseZ(z + 1, y, x))
                    return true;
        }

        if (y < Y - 1)
        {
            int E = Matrix[z][y + 1][x];
            if (E != 0 && E != Flag)
                if (TraverseZ(z, y + 1, x))
                    return true;
        }

        if (x < X - 1)
        {
            int E = Matrix[z][y][x + 1];
            if (E != 0 && E != Flag)
                if (TraverseZ(z, y, x + 1))
                    return true;
        }

        if (x > 0)
        {
            int E = Matrix[z][y][x - 1];
            if (E != 0 && E != Flag)
                if (TraverseZ(z, y, x - 1))
                    return true;
        }

        if (y > 0)
        {
            int E = Matrix[z][y - 1][x];
            if (E != 0 && E != Flag)
                if (TraverseZ(z, y - 1, x))
                    return true;
        }

        if (z > 0)
        {
            int E = Matrix[z - 1][y][x];
            if (E != 0 && E != Flag)
                if (TraverseZ(z - 1, y, x))
                    return true;
        }

        return false;
    }

    bool TraverseY(int z, int y, int x)
    {
        const int Flag = 3;
        Matrix[z][y][x] = Flag;

        if (y == Y - 1) return true;
        else
        {
            int E = Matrix[z][y + 1][x];
            if (E != 0 && E != Flag)
                if (TraverseY(z, y + 1, x))
                    return true;
        }

        if (z < Z - 1)
        {
            int E = Matrix[z + 1][y][x];
            if (E != 0 && E != Flag)
                if (TraverseY(z + 1, y, x))
                    return true;
        }
            
        if (x < X - 1)
        {
            int E = Matrix[z][y][x + 1];
            if (E != 0 && E != Flag)
                if (TraverseY(z, y, x + 1))
                    return true;
        }

        if (x > 0)
        {
            int E = Matrix[z][y][x - 1];
            if (E != 0 && E != Flag)
                if (TraverseY(z, y, x - 1))
                    return true;
        }

        if (z > 0)
        {
            int E = Matrix[z - 1][y][x];
            if (E != 0 && E != Flag)
                if (TraverseY(z - 1, y, x))
                    return true;
        }

        if (y > 0)
        {
            int E = Matrix[z][y - 1][x];
            if (E != 0 && E != Flag)
                if (TraverseY(z, y - 1, x))
                    return true;
        }

        return false;
    }

    bool TraverseX(int z, int y, int x)
    {
        const int Flag = 2;
        Matrix[z][y][x] = Flag;

        if (x == X - 1) return true;
        else
        {
            int E = Matrix[z][y][x + 1];
            if (E != 0 && E != Flag)
                if (TraverseX(z, y, x + 1))
                    return true;
        }

        if (y < Y - 1)
        {
            int E = Matrix[z][y + 1][x];
            if (E != 0 && E != Flag)
                if (TraverseX(z, y + 1, x))
                    return true;
        }

        if (z < Z - 1)
        {
            int E = Matrix[z + 1][y][x];
            if (E != 0 && E != Flag)
                if (TraverseX(z + 1, y, x))
                    return true;
        }

        if (x > 0)
        {
            int E = Matrix[z][y][x - 1];
            if (E != 0 && E != Flag)
                if (TraverseX(z, y, x - 1))
                    return true;
        }

        if (y > 0)
        {
            int E = Matrix[z][y - 1][x];
            if (E != 0 && E != Flag)
                if (TraverseX(z, y - 1, x))
                    return true;
        }

        if (z > 0)
        {
            int E = Matrix[z - 1][y][x];
            if (E != 0 && E != Flag)
                if (TraverseX(z - 1, y, x))
                    return true;
        }

        return false;
    }