Найти вероятность существования пути в графе между заданными точками

#include <iostream>
#include <vector>
#include <fstream>
#define M 4
#define P 0.1
 
using namespace std;
int graph[M][M]={
    {0,1,1,1},
    {1,0,0,0},
    {1,0,0,1},
    {1,0,1,0}
};
bool matrix[M][M]={0};
 
int count_paths(){
    int elements=0;
    for(int i=0;i<M;i++)
        for(int j=0;j<M;j++)
            if(graph[i][j])
                elements++;
    return elements/2;
}
 
vector<int>get_nodes(int node, int g[M][M]){
    vector<int> nodes;
    int j=0;
    for(int i=node;j<M;j++)
    {
        if(g[i][j])
            nodes.push_back(j);
    }
    return nodes;
}
 
float result=0;
void res(int path_size,int etc){
    result+=pow(P,path_size)*pow((1-P),etc);    
}
 
bool is_element(vector<int> nodes,int element){
    for(vector<int>::iterator it=nodes.begin(); it != nodes.end(); ++it)
    {
        if(*it==element)
            return true;
    }
    return false;
}
 
vector<int> used;
bool poisk(int from, int to, int g[M][M]){//, vector<int>&path){
    if(from==to)
    {
        used.erase(used.begin(),used.end());
        return 1;
    }
    else{
        vector<int> nodes=get_nodes(from,g);//все смежные вершины нужной вершины
        used.push_back(from);
        for(vector<int>::iterator it=nodes.begin(); it != nodes.end(); ++it)
        {
            if(is_element(nodes,*it) && !is_element(used,*it))
            {
                if(poisk(*it,to,g))//,path))
                    return 1;
            }
        }
    }
    return 0;
}
 
void clear(){
    for(int i=0;i<M;i++)
        for(int j=0;j<M;j++)
            matrix[i][j]=0;
}
ofstream ofs ("test.txt", std::ofstream::out);
void show(int g[M][M]){
    for(int i = 0 ; i < M; i++){
        for(int j = 0;j < M; j++)
            cout<<g[i][j];
        cout<<endl;
    }
    cout<<endl;
}
int cp=0;
 
void gen(int X, int Y, int from, int to, int g[M][M]){
    for(int i = X ; i < M; i++)
        for(int j = Y;j < M; j++){
            if(g[i][j] == 1 && j>i)//мы идем по ребрам графа
            {
                g[i][j] = 0;
                if(poisk(from,to,g))
                    cp++;
                else{}
                show(g);
                if(j+1<M && i<M)
                    gen(i,j+1,from,to,g);//считаем если ребра нет
                else if(i+1<M && j>=M){
                    gen(i+1,0,from,to,g);//считаем если ребра нет
                }
 
                g[i][j] = 1;
                if(j+1<M && i<M)
                    gen(i,j+1,from,to,g);//считаем если ребро есть
                else if(i+1<M && j>=M){
                    gen(i+1,0,from,to,g);//считаем если ребро есть
                }
 
            }
        }
}
 
int main(){
    int copy[M][M];
    for(int i=0;i<M;i++)
        for(int j=0;j<M;j++)
            copy[i][j] = graph[i][j];
    gen(0,0,0,3,copy);
    ofs.close();
    return 0;
}

void gen(int X, int Y, int from, int to, int g[M][M]){
    bool f1 = true;
    for(int i = X ; i < M; i++){
        for(int j = Y;j < M; j++){
            if(g[i][j] == 1 && j>i && f1)//мы идем по ребрам графа
            {
                f1=false;
                g[i][j] = 0;
                if(poisk(from,to,g)){//главный подсчет
                    probab_way += probabulity(g);
                    cp++;
                }
                bool flag1 = true, flag2 = true;
                if(j+1<M && i<M){
                    flag1=false;
                    gen(i,j+1,from,to,g);//считаем если ребра нет
                }
                else if(i+1<M  && flag1){
                    gen(i+1,0,from,to,g);//считаем если ребра нет
                }
                g[i][j] = 1;
                if(j+1<M && i<M){
                    gen(i,j+1,from,to,g);//считаем если ребро есть
                    flag2 = false;
                }
                else if(i+1<M && flag2){
                    gen(i+1,0,from,to,g);//считаем если ребро есть
                }
            }
        }
    }
}