Задача E. Лабиринт

///----------------------------------------------------------------------------|
/// Задача E. Лабиринт
///----------------------------------------------------------------------------:
#include <iostream>
 
struct sTask
{   sTask()
    {   int n = 23; //std::cin >> n;
        int sample[46] = {
             0,  1,
             0,  2,
             0,  3,
             0,  9,
             1, 16,
             1, 17,
            16, 15,
            15, 14,
            15, 13,
            17, 21,
            17, 18,
            18, 19,
            18, 20,
             2,  4,
             2,  5,
             4,  6,
             4,  7,
             5,  8,
             3, 22,
             9, 23,
             9, 10,
            10, 11,
            10, 12 };
        
        int amroom = 24;
        int door_in_room[amroom] = {0};
    
        for(int i = 0; i < n*2; i += 2)
        {   door_in_room[sample[i]]++;
        }
    
        for(int i = 1; i < amroom; i++)
        {   if(door_in_room[i] == 0)
            {   foo(sample, door_in_room, n, i);
            }
        }
    }
 
    void foo(int* sam, int* door, int n, int i)
    {   int res = 1;
        std::cout << i << ":"; 
        do
        {   for(int j = 1; j < 2*n; j += 2)
                if(sam[j] == i)
                    i = sam[j-1];
            res *= door[i];
        }
        while(i != 0);
        std::cout << "\t " << " 1/" << res << "\n";
    }
};
 
///----------------------------------------------------------------------------|
/// Main.
///----------------------------------------------------------------------------:
int main()
{   
    sTask task;
    
    std::cin.get();
    return 0;
}

///----------------------------------------------------------------------------|
/// Задача E. Лабиринт
///----------------------------------------------------------------------------:
#include <iostream>
 
struct sTask
{   sTask()
    {   int n = 23; //std::cin >> n;
        int sample[46] = {
             0,  1,
             0,  2,
             0,  3,
             0,  9,
             1, 16,
             1, 17,
            15, 16, // 16, 15,
            15, 14,
            15, 13,
            17, 21,
            17, 18,
            18, 19,
            18, 20,
             2,  4,
             2,  5,
             4,  6,
             4,  7,
             5,  8,
             3, 22,
             9, 23,
             9, 10,
            10, 11,
            10, 12 };
        
        int amroom = n + 1;
        int door_in_room[amroom] = {0};
    
        for(int i = 0; i < n*2; i += 2)
        {   door_in_room[sample[i]]++;
        }
    
        for(int i = 1; i < amroom; i++)
        {   if(door_in_room[i] == 0)
            {   foo(sample, door_in_room, n, i);
            }
        }
    }
 
    void foo(int* sam, int* door, int n, int i)
    {   int res = 1;
        std::cout << i << ":"; 
        do
        {   for(int j = 1; j < 2*n; j += 2)
            {   if(sam[j] == i)
                {   i = sam[j-1];
                    goto m;
                }
            }
            std::cout << "\tKARAUL!!!: there is no door!\n";
            return;
m:   
            res *= door[i];
        }
        while(i != 0);
        std::cout << "\t " << " 1/" << res << "\n";
    }
};
 
///----------------------------------------------------------------------------|
/// Main.
///----------------------------------------------------------------------------:
int main()
{   
    sTask task;
    
    std::cin.get();
    return 0;
}

#include <fstream>
#include <iostream>
using namespace std;
 
struct node
{
    int     num;
    node*   parent;
    node*   child;
    node*   next;
};
 
struct room
{
    int     num;
    int     count;
    room*   next;
};
 
node* search(node* root, int in)
{
    node* child;
    node* temp;
    if (root->num == in)
        return root;
    else
    {
        child = root->child;
        if (child)
        {
            for (node* next = child; next; next = next->next)
            {
                temp = search(next, in);
                if ((unsigned int)temp > 1)
                    return temp;
            }
        }
        for(node* next=root->next; next; next=next->next)
        {
            temp = search(next, in);
            if ((unsigned int)temp > 1)
                return temp;
        }
        if (root->parent == nullptr)
            return nullptr;
        else
            return (node*)1;
    }
    return nullptr;
}
 
int insert(node* &root, int in, int out)
{
    node* branch;
    node* i;
    node* temp = new(node);
    temp->child = nullptr;
    temp->next = nullptr;
    if (!root)
    {
        temp->num = in;
        temp->parent = nullptr;
        root = temp;
        temp = new(node);
        root->child = temp;
        temp->child = nullptr;
        temp->next = nullptr;
        temp->parent = root;
        temp->num = out;
    }
    else 
    {
        branch = search(root, in);
        if (branch)
        {
            temp->num = out;
            temp->parent = branch;
            temp->next = nullptr;
            if (branch->child)
            {
                for (i = branch->child; i; branch = i, i = i->next);
                branch->next = temp;
            }
            else
            {
                branch->child = temp;
                temp->child = nullptr;
            }
        }
        else
            return 0;
    }
    return 1;
}
 
void CalcOneChild(node* current, room* &data, int count)
{
    node*   n;
    room*   r;
    room*   cr;
    int     cnt = 0;
    
 
    if (current->child)
    {
        for (node *n = current->child; n; n = n->next)
            cnt++;
        count *= cnt;
 
        for (n = current->child; n; n = n->next)
            CalcOneChild(n, data, count);
    }
    else
    {
        r = new room;
        r->count = count;
        r->next = nullptr;
        r->num = current->num;
        if (data == nullptr)
            data = r;
        else
        {
            for (cr = data; cr->next; cr = cr->next);
            cr->next = r;
        }
    }
}
 
void CalcRooms(node* root, room* &data)
{
    int count = 0;
    for (node *n = root->child; n; n = n->next)
        count++;
 
    for (node* current = root->child; current; current = current->next)
        CalcOneChild(current, data, count);
}
 
void Sort(room* data)
{
    if (data)
    {
        for (room* i = data; i->next; i = i->next)
        {
            for (room* j = i->next; j; j = j->next)
            {
                if (i->num > j->num)
                {
                    swap(i->count, j->count);
                    swap(i->num, j->num);
                }
            }
        }
    }
}
 
int main()
{
    ifstream    file;
    int         n, in, out;
    node*       root = nullptr;
    room*       data = nullptr;
 
    file.open("in.txt");
    file >> n;
    for (int i = 0; i < n; i++)
    {
        file >> in >> out;
        insert(root, in, out);
    }
    file.close();
 
    CalcRooms(root, data);
    
    Sort(data);
 
    for (room* r = data; r; r = r->next)
    {
        if (r->count == 1)
            cout << r->num << ": 1" << endl;
        else
            cout << r->num << ": 1/" << r->count << endl;
    }
}

int main()
{
    ifstream    file;
    int         n, in, out;
    node*       root = nullptr;
    room*       data = nullptr;
 
    file.open("in.txt");
    file >> n;
    for (int i = 0; i < n; i++)
    {
        file >> in >> out;
        if (!insert(root, in, out))
        {
            file.close();
            cout << "Incorrect data!" << endl;
            exit(1);
        }
    }
    file.close();
 
    CalcRooms(root, data);
    
    Sort(data);
 
    for (room* r = data; r; r = r->next)
    {
        if (r->count == 1)
            cout << r->num << ": 1" << endl;
        else
            cout << r->num << ": 1/" << r->count << endl;
    }
}