/// <summary>
        /// returns graph sample from super graph whith k size
        /// </summary>
        /// <param name="super"></param>
        /// <param name="k"></param>
        /// <returns></returns>
        public Graph GetRandomSubgraphESU(Graph super, int k)
        {
            if (k <= 2)
                throw new ArgumentOutOfRangeException();

            Graph sub = new Graph();
            Random rand = new Random();
            int nonNeighborCount = 0;
            sub.AddVertice(super.Vertices[rand.Next(super.Vertices.Count)]);
            while (sub.Vertices.Count < k)
            {
                Vertice vert = sub.Vertices[rand.Next(sub.Vertices.Count)];
                System.Threading.Thread.Sleep(2);
                List<Vertice> nhood = Graph.GetVerticesNeighborhood(super, sub, vert);
                if (nhood.Count != 0)
                {
                    Vertice vertice = nhood[rand.Next(nhood.Count)];
               //         if (vert.index < vertice.index)
               //         {
                        nonNeighborCount = 0;
                        Edge edge = new Edge(vertice.index, vert.index);
                        sub.AddVertice(vertice);
                        sub.AddEdge(edge);
              //          }
              //          else
              //          {
              //              nonNeighborCount++;
              //              if (nonNeighborCount == 5)
             //                   return null;
             //           }

                }
                else
                {
                    nonNeighborCount++;
                    if (nonNeighborCount == 5)
                        return null;
                }

            }
            int verticeIndex = 0;
            Dictionary<int, int> edges = new Dictionary<int, int>();
            foreach (Vertice vertice in sub.Vertices)
            {
                edges[vertice.index] = verticeIndex;
                vertice.index = verticeIndex;
                verticeIndex++;
            }
            sub.changeEdeVerticeIndex(edges);
            if (sub.Edges.Count == 1)
            {
                int edg = sub.Edges.Count;
            }
            return sub;
        }
 /// <summary>
 /// returns true if givens graphs are isomorph false otherwise
 /// </summary>
 /// <param name="A"></param>
 /// <param name="B"></param>
 /// <returns></returns>
 public static bool AreIsomorph(Graph A, Graph B)
 {
     int mismatchCount = 0;
     Sign[,] ASignMatrix = GetSignMatrix(A);
     Sign[,] BSignMatrix = GetSignMatrix(B);
     int[,] AFrequencyMatrix = GetFrequencyMatrix(ASignMatrix);
     int[,] BFrequencyMatrix = GetFrequencyMatrix(BSignMatrix);
     if (AFrequencyMatrix.Length != BFrequencyMatrix.Length)
         return false;
     bool breakFor = false;
     for (int i = 0; i < AFrequencyMatrix.GetLength(0); i++)
     {
         for (int j = 0; j < AFrequencyMatrix.GetLength(1); j++)
         {
             if (AFrequencyMatrix[i,j] != BFrequencyMatrix[i,j])
             {
                 mismatchCount++;
                 breakFor = false;
                 for (int i1 = i; i1 < AFrequencyMatrix.GetLength(0); i1++)
                 {
                     for (int j1 = j + 1; j1 < AFrequencyMatrix.GetLength(1); j1++)
                         if (AFrequencyMatrix[i,j] == BFrequencyMatrix[i1,j1])
                         {
                             SwitchRowsInFrequencyMatrix(ref BFrequencyMatrix, i, i1);
                             SwitchColumnsInFrequencyMatrix(ref BFrequencyMatrix, j1, j);
                             mismatchCount--;
                             breakFor = true;
                             break;
                         }
                     if (breakFor)
                     {
                         break;
                     }
                 }
             }
         }
     }
     if (mismatchCount == 0)
     {
         return true;
     }
     return false;
 }
        /// <summary>
        /// returns graph sample from super graph whith k size
        /// </summary>
        /// <param name="super"></param>
        /// <param name="k"></param>
        /// <returns></returns>
        public Graph GetRandomSubgraphESA(Graph super, int k)
        {
            if (k <= 2)
                throw new ArgumentOutOfRangeException();

            Graph sub = new Graph();
            Random rand = new Random();

            sub.AddEdge(super.Edges[rand.Next(super.Edges.Count)]);
            int nonNeighborCount = 0;
            while (sub.Vertices.Count < k)
            {
                System.Threading.Thread.Sleep(2);
                List<Edge> nhood = Graph.GetEdgesNeighborhood(super, sub);
                if (nhood.Count != 0)
                {
                    nonNeighborCount = 0;
                    sub.AddEdge(nhood[rand.Next(nhood.Count)]);
                }
                else
                {
                    nonNeighborCount++;
                    if (nonNeighborCount == 5)
                        return null;
                }

            }
            int verticeIndex = 0;
            Dictionary<int, int> edges = new Dictionary<int, int>();
            foreach(Vertice vertice in sub.Vertices)
            {
                edges[vertice.index] = verticeIndex;
                vertice.index = verticeIndex;
                verticeIndex++;
            }
            sub.changeEdeVerticeIndex(edges);
            if (sub.Edges.Count == 1)
            {
                int edg = sub.Edges.Count;
            }
            return sub;
        }
예제 #4
0
        private static void GraphTest()
        {
            var graph = new Graph(9);

            graph.AddEdge(0, 1, 4);
            graph.AddEdge(0, 7, 8);
            graph.AddEdge(1, 2, 8);
            graph.AddEdge(1, 7, 11);
            graph.AddEdge(2, 3, 7);
            graph.AddEdge(2, 5, 4);
            graph.AddEdge(2, 8, 2);
            graph.AddEdge(7, 8, 7);
            graph.AddEdge(7, 6, 1);
            graph.AddEdge(6, 8, 6);
            graph.AddEdge(6, 5, 2);
            graph.AddEdge(3, 4, 9);
            graph.AddEdge(3, 5, 14);
            graph.AddEdge(5, 4, 10);

            //graph.AddEdge(0, 1, 1);
            //graph.AddEdge(0, 7, 2);
            //graph.AddEdge(1, 2, 3);
            //graph.AddEdge(1, 7, 4);
            //graph.AddEdge(2, 3, 5);
            //graph.AddEdge(2, 5, 2);
            //graph.AddEdge(2, 8, 4);
            //graph.AddEdge(7, 8, 3);
            //graph.AddEdge(7, 6, 8);
            //graph.AddEdge(6, 8, 1);
            //graph.AddEdge(6, 5, 2);
            //graph.AddEdge(3, 4, 1);
            //graph.AddEdge(3, 5, 1);
            //graph.AddEdge(5, 4, 6);

            graph.PrintGraph();

            var startV = 0;

            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("Begin Deep First Travle");
            Console.ResetColor();

            graph.DFTravel(startV);

            Console.WriteLine();
            Console.WriteLine();

            startV = 0;
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("Begin Deep First Travle");
            Console.ResetColor();

            graph.BFTravel(startV);

            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine("Find shortest path, starting node: ");
            var start = 0;

            graph.FindShortPath(start, 4);
        }
 private static int GetTentativeDistance(Graph graph, Vertice v1, Vertice v2)
 {
     if (v1 == v2)
         return 0;
     if (graph.Contains(new Edge(v1.index, v2.index)))
         return 1;
     return int.MaxValue;
 }
        private static Graph GetPairGraph(Graph graph, Vertice u, Vertice v)
        {
            List<List<Vertice>> paths = GetDijkstraShortestPaths(graph, u);
            List<Vertice> shortestPathUV = paths[v.index];

            Graph pairUV = new Graph();
            if (shortestPathUV != null)
            {
                foreach (Vertice current in shortestPathUV)
                {
                    pairUV.Vertices.Add(current);
                    foreach (Edge edge in graph.Edges)
                    {
                        if (edge.v1 == current.index || edge.v2 == current.index)
                        {
                            pairUV.AddEdge(edge);
                        }
                    }
                }
            }

            return pairUV;
        }
 private static int GetCollaterialSign(Graph graph, Edge e)
 {
     if (graph.Contains(e))
         return 1;
     return -1;
 }
        //Collaterial and Pair graphs
        private static Graph GetCollaterialGraph(Graph graph, Edge e)
        {
            if (!graph.Contains(e))
                return graph;

            Graph collaterial = new Graph();

            collaterial.Vertices = graph.Vertices;

            foreach (Edge current in graph.Edges)
            {
                if (current != e)
                    collaterial.Edges.Add(current);
            }

            return collaterial;
        }
 //Procedure 3.3
 public static void GetSignMatrixAndCanonicalForm(Graph graph, ref Sign[,] matrix, ref Sign[,] canonical)
 {
     matrix = GetSignMatrix(graph);
     canonical = GetCanonicalForm(matrix);
 }
        public static Sign[,] GetSignMatrix(Graph graph)
        {
            Sign[,] signMatrix = new Sign[graph.Vertices.Count, graph.Vertices.Count];

            foreach (Vertice v1 in graph.Vertices)
            {
                foreach (Vertice v2 in graph.Vertices)
                {
                    Sign sign = new Sign();
                    int i = graph.Vertices.IndexOf(v1);
                    int j = graph.Vertices.IndexOf(v2);
                    Graph collaterial = GetCollaterialGraph(graph, new Edge(v1.index, v2.index));
                    List<List<Vertice>> collPaths = GetDijkstraShortestPaths(collaterial, v1);
                    sign.binarySign = GetCollaterialSign(graph, new Edge(v1.index, v2.index));
                    if (collPaths[j] != null && collPaths[j].Count != 0)
                    {
                        sign.collDistance = collPaths[j].Count - 1;
                    }
                    Graph pair = GetPairGraph(graph, v1, v2);
                    sign.pairNumEdges = pair.Edges.Count;
                    sign.pairNumVertices = pair.Vertices.Count;
                    signMatrix[i, j] = sign;
                }
            }
            return signMatrix;
        }
        //Dijkstra's shortest paths
        public static List<List<Vertice>> GetDijkstraShortestPaths(Graph graph, Vertice vSource)
        {
            int[] distances = new int[graph.Vertices.Count];
            bool[] visited = new bool[graph.Vertices.Count];
            visited[vSource.index] = true;

            foreach (Vertice vOuter in graph.Vertices)
                distances[vOuter.index] = GetTentativeDistance(graph, vOuter, vSource);

            while (true)
            {
                int iMin = GetMinimumUnvisitedIndex(distances, visited);
                visited[iMin] = true;

                foreach (Vertice vCurrent in graph.Vertices)
                {
                    if (visited[vCurrent.index] == false)
                    {
                        if (GetTentativeDistance(graph, graph.Vertices[iMin], vCurrent) == int.MaxValue)
                            continue;

                        distances[vCurrent.index] = Math.Min(distances[iMin] + GetTentativeDistance(graph, graph.Vertices[iMin], vCurrent), distances[vCurrent.index]);
                    }
                }

                bool finished = true;
                for (int i = 0; i < visited.Length; i++)
                {
                    if (visited[i] == false && distances[i] != int.MaxValue)
                    {
                        finished = false;
                        break;
                    }
                }
                if (finished)
                    break;
            }

            var shortestPaths = new List<List<Vertice>>();

            foreach (Vertice vCurrent in graph.Vertices)
            {
                Vertice vTemp = vCurrent;
                shortestPaths.Add(new List<Vertice>());
                shortestPaths[vCurrent.index].Insert(0, vCurrent);
                if (distances[vCurrent.index] == int.MaxValue)
                {
                    shortestPaths[vCurrent.index] = null;
                    continue;
                }
                if (vCurrent == vSource)
                {
                    shortestPaths[vCurrent.index].Add(vSource);
                    continue;
                }

                while (true)
                {
                    foreach (Edge eCurrent in graph.Edges)
                    {
                        if (eCurrent.v1 == vTemp.index && distances[eCurrent.v2] == distances[vTemp.index] - 1)
                        {
                            shortestPaths[vCurrent.index].Insert(0, graph.Vertices[eCurrent.v2]);
                            vTemp = graph.Vertices[eCurrent.v2];
                            break;
                        }
                        else if (eCurrent.v2 == vTemp.index && distances[eCurrent.v1] == distances[vTemp.index] - 1)
                        {
                            shortestPaths[vCurrent.index].Insert(0, graph.Vertices[eCurrent.v1]);
                            vTemp = graph.Vertices[eCurrent.v1];
                            break;
                        }
                    }
                    if (vTemp == vSource)
                    {
                        break;
                    }
                }
            }
            return shortestPaths;
        }
        public static int GetCollaterialDistanceAndPairGraph(Graph graph, Vertice u, Vertice v,  //Procedure 3.2
            ref Graph pair)
        {
            Graph collaterial = GetCollaterialGraph(graph, new Edge(u.index, v.index));
            List<List<Vertice>> shortestPathsU = GetDijkstraShortestPaths(collaterial, u);
            List<List<Vertice>> shortestPathsV = GetDijkstraShortestPaths(collaterial, v);
            pair = GetPairGraph(graph, u, v);

            int collaterialUVDistance = shortestPathsU[graph.Vertices.IndexOf(v)].Count - 1;
            return collaterialUVDistance;
        }
        /// <summary>
        /// create and returns graph in data from given BAContainer type graph
        /// </summary>
        /// <param name="graph"></param>
        /// <returns></returns>
        public static Graph reformatToOurGraghFromBAContainer(SortedDictionary<int, List<int>> neighbourship)
        {
            Graph newGraph = new Graph();
            bool[,] matrix = new bool[neighbourship.Count, neighbourship.Count];

            List<int> list = new List<int>();

            for (int i = 0; i < neighbourship.Count; i++)
            {

                list = neighbourship[i];
                newGraph.Vertices.Add(new Vertice(i));
                for (int j = 0; j < list.Count; j++)
                    newGraph.Edges.Add(new Edge(i, list[j]));
            }

            return newGraph;
        }
 /// <summary>
 /// returns sub graph neighbors vertices in super graph
 /// </summary>
 /// <param name="super"></param>
 /// <param name="sub"></param>
 /// <returns></returns>
 public static List<Vertice> GetVerticesNeighborhood(Graph super, Graph sub,Vertice subVertice)
 {
     List<Vertice> nhood = new List<Vertice>();
     foreach (Edge e in super.Edges)
             if (subVertice.index == e.v1 && !sub.Contains(e))
             {
                 nhood.Add(new Vertice(e.v2));
             }
             else if (subVertice.index == e.v2 && !sub.Contains(e))
             {
                 nhood.Add(new Vertice(e.v1));
             }
     return nhood;
 }
 /// <summary>
 /// returns sub graph neighbors edges in super graph
 /// </summary>
 /// <param name="super"></param>
 /// <param name="sub"></param>
 /// <returns></returns>
 public static List<Edge> GetEdgesNeighborhood(Graph super, Graph sub)
 {
     List<Edge> nhood = new List<Edge>();
     foreach (Vertice v in sub.Vertices)
         foreach (Edge e in super.Edges)
             if (e.v1 == v.index || e.v2 == v.index && !sub.Contains(e))
                 nhood.Add(e);
     return nhood;
 }
        public static Graph createGraphFromFile()
        {
            //Protein-Protein Network
            Graph graph = new Graph();

            for (int i = 0; i < 2114; i++)
            {
                graph.AddVertice(new Vertice(i));
            }

            StreamReader reader = new StreamReader("NDYeast.net");
            string line = reader.ReadLine();
            while (line != null)
            {
                if (line[0] == '*')
                {
                    line = reader.ReadLine();
                    continue;
                }

                string[] tokens = line.Split(' ');
                int edge1Index = Convert.ToInt32(tokens[0]);
                for (int i = 1; i < tokens.Length; i++)
                {
                    graph.AddEdge(new Edge(edge1Index - 1, Convert.ToInt32(tokens[i]) - 1));
                }
                line = reader.ReadLine();
            }
            reader.Close();
            return graph;
        }