using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Console.WriteLine("Введите количество вершин графа:");
        int n = int.Parse(Console.ReadLine());
        int[,] matrix = new int[n, n];

        Console.WriteLine("Введите отношения вершин (для остановки ввода введите -1):");
        bool stopInput = false;

        while (!stopInput)
        {
            string input = Console.ReadLine();
            if (input == "-1")
            {
                stopInput = true;
                break;
            }

            string[] vertices = input.Split(' ');
            int vertex1 = int.Parse(vertices[0]) - 1;
            int vertex2 = int.Parse(vertices[1]) - 1;
            matrix[vertex1, vertex2] = 1;
        }

        Console.WriteLine("Матрица смежности:");
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                Console.Write(matrix[i, j] + " ");
            }
            Console.WriteLine();
        }


        Console.WriteLine("Возведение матрицы в степень:");
        int[,] poweredMatrix = matrix;
        int power = 1;
        int tactCount = 1;
        while (!IsZeroMatrix(poweredMatrix, n))
        {
            Console.WriteLine("A в степени " + power + ":");
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    Console.Write(poweredMatrix[i, j] + " ");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
            poweredMatrix = MultiplyMatrices(poweredMatrix, matrix, n);
            power++;

            tactCount++;
        }

        List<int> zeroOrderElements = FindZeroOrderElements(matrix, n);
        Console.Write("Элементы нулевого порядка: ");
        for (int i = 0; i < zeroOrderElements.Count; i++)
        {
            Console.Write("X" + (zeroOrderElements[i] + 1));
            if (i < zeroOrderElements.Count - 1)
            {
                Console.Write(", ");
            }
        }
        Console.WriteLine();

        List<int> inputElements = FindInputElements(matrix, n);
        Console.Write("Входные элементы: ");
        for (int i = 0; i < inputElements.Count; i++)
        {
            Console.Write("X" + (inputElements[i] + 1));
            if (i < inputElements.Count - 1)
            {
                Console.Write(", ");
            }
        }
        Console.WriteLine();

        List<int> outputElements = FindOutputElements(matrix, n);
        Console.Write("Выходные элементы: ");
        for (int i = 0; i < outputElements.Count; i++)
        {
            Console.Write("X" + (outputElements[i] + 1));
            if (i < outputElements.Count - 1)
            {
                Console.Write(", ");
            }
        }
        Console.WriteLine();

        List<int> hangingVertices = FindHangingVertices(matrix, n);
        if (hangingVertices.Count > 0)
        {
            Console.Write("Висящие вершины: ");
            for (int i = 0; i < hangingVertices.Count; i++)
            {
                Console.Write("X" + (hangingVertices[i] + 1));
                if (i < hangingVertices.Count - 1)
                {
                    Console.Write(", ");
                }
            }
            Console.WriteLine();
        }
        else
        {
            Console.WriteLine("Висящих вершин нет");
        }
        Console.WriteLine($"Количество тактов: {tactCount}");



        for (int startVertex = 0; startVertex < n; startVertex++)
        {
            int[] pathCounts = new int[n];
            FindAllPaths(matrix, startVertex, startVertex, 0, pathCounts);

            Console.WriteLine($"Пути из вершины X{startVertex + 1}:");
            for (int endVertex = 0; endVertex < n; endVertex++)
            {
                if (startVertex != endVertex)  // Исключаем пути из вершины в себя
                {
                    Console.WriteLine($"Количество путей до X{endVertex + 1}: {pathCounts[endVertex]}");
                }
            }
        }
        FindAllPathLengths(matrix, n);
    }

    static void FindAllPaths(int[,] matrix, int startVertex, int currentVertex, int pathLength, int[] pathCounts)
    {
        pathCounts[currentVertex] += 1;

        for (int nextVertex = 0; nextVertex < matrix.GetLength(0); nextVertex++)
        {
            if (matrix[currentVertex, nextVertex] == 1)
            {
                if (nextVertex == startVertex && pathLength > 0)
                {
                    // Найден цикл, игнорируем его
                    continue;
                }

                FindAllPaths(matrix, startVertex, nextVertex, pathLength + 1, pathCounts);
            }
        }
    }

    static List<int> FindZeroOrderElements(int[,] matrix, int n)
    {
        List<int> zeroOrderElements = new List<int>();

        for (int i = 0; i < n; i++)
        {
            bool isZeroOrder = true;

            for (int j = 0; j < n; j++)
            {
                if (matrix[i, j] != 0)
                {
                    isZeroOrder = false;
                    break;
                }
            }

            if (isZeroOrder)
            {
                zeroOrderElements.Add(i);
            }
        }

        return zeroOrderElements;
    }

    static List<int> FindInputElements(int[,] matrix, int n)
    {
        List<int> inputElements = new List<int>();

        for (int i = 0; i < n; i++)
        {
            bool isInput = true;

            for (int j = 0; j < n; j++)
            {
                if (matrix[j, i] != 0)
                {
                    isInput = false;
                    break;
                }
            }

            if (isInput)
            {
                inputElements.Add(i);
            }
        }

        return inputElements;
    }

    static List<int> FindOutputElements(int[,] matrix, int n)
    {
        List<int> outputElements = new List<int>();

        for (int i = 0; i < n; i++)
        {
            bool isOutput = true;

            for (int j = 0; j < n; j++)
            {
                if (matrix[i, j] != 0)
                {
                    isOutput = false;
                    break;
                }
            }

            if (isOutput)
            {
                outputElements.Add(i);
            }
        }

        return outputElements;
    }

    static int[,] MultiplyMatrices(int[,] matrix1, int[,] matrix2, int n)
    {
        int[,] result = new int[n, n];

        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                for (int k = 0; k < n; k++)
                {
                    result[i, j] += matrix1[i, k] * matrix2[k, j];
                }
            }
        }

        return result;
    }

    static bool IsZeroMatrix(int[,] matrix, int n)
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (matrix[i, j] != 0)
                {
                    return false;
                }
            }
        }

        return true;
    }

      static void FindAllPathLengths(int[,] matrix, int n)
    {
        for (int startVertex = 0; startVertex < n; startVertex++)
        {
            for (int endVertex = 0; endVertex < n; endVertex++)
            {
                if (startVertex != endVertex)
                {
                    int pathLength = 1;
                    int[,] resultMatrix = (int[,])matrix.Clone();

                    while (pathLength <= n)
                    {
                        int pathsCount = CountPaths(resultMatrix, startVertex, endVertex, pathLength);
                        if (pathsCount > 0)
                        {
                            Console.WriteLine($"Количество путей длиной {pathLength} из X{startVertex + 1} в X{endVertex + 1}: {pathsCount}");
                        }
                       
                        pathLength++;
                    }
                }
            }
        }
    }

    static int CountPaths(int[,] matrix, int startVertex, int endVertex, int pathLength)
    {
        if (pathLength == 1)
        {
            return matrix[startVertex, endVertex];
        }

        int pathsCount = 0;
        for (int i = 0; i < matrix.GetLength(0); i++)
        {
            if (matrix[startVertex, i] == 1)
            {
                pathsCount += CountPaths(matrix, i, endVertex, pathLength - 1);
            }
        }

        return pathsCount;
    }

    static List<int> FindHangingVertices(int[,] matrix, int n)
    {
        List<int> hangingVertices = new List<int>();

        for (int i = 0; i < n; i++)
        {
            bool isHanging = true;

            for (int j = 0; j < n; j++)
            {
                if (matrix[i, j] != 0)
                {
                    isHanging = false;
                    break;
                }
            }

            if (isHanging)
            {
                hangingVertices.Add(i);
            }
        }

        return hangingVertices;
    }
}
Допиши код , что если отсутствие ненулевых элементов на главной диагонали любой из
матриц свидетельствует о том, что в анализируемом документообороте
контуров нет, если нет котуров, то писать нетконтуров, а если есть, то писасть есть контуры