Exemplo n.º 1
0
        public void SetEdges(int[,] matr)
        {
            //adjacencyMatrix = matr;

            foreach (Node node in nodes)
            {
                node.edge.Clear();
            }

            for (int i = 0; i < matr.GetLength(0); i++)
            {
                for (int j = 0; j < matr.GetLength(1); j++)
                {
                    if (matr[i, j] != 0)
                    {
                        //nodes[i].edge.Resize(ref nodes[i].edge, 0);
                        Node.Edge edge = new Node.Edge();
                        //edge.length = matr[i,j];
                        edge.NumNode = j;
                        edge.color   = Color.Black;
                        edge.value   = matr[i, j];


                        if (i != j)
                        {
                            nodes[i].edge.Add(edge);

                            edge          = new Node.Edge();
                            edge.NumNode  = i;
                            edge.PrevNode = j;
                            edge.color    = Color.Black;
                            edge.value    = matr[i, j];
                            //edge.value = distance;

                            nodes[j].edge.Add(edge);
                        }
                        //else if (i == j)
                        //    nodes[i].edge.Add(edge);
                    }
                }
            }
        }
Exemplo n.º 2
0
        public void AddEdge(int n1, int n2, int distance)
        {
            if (!TestEdge(n1, n2))
            {
                int    dx = nodes[n2].x - nodes[n1].x;
                int    dy = nodes[n2].y - nodes[n1].y;
                double x  = dx * dx + dy * dy;
                x = Math.Pow(x, 0.5);
                int dist = Convert.ToInt32(x);
                int len  = nodes[n1].edge.Count;
                if (distance == -1)
                {
                    distance = dist;
                }
                //Array.Resize(ref nodes[n1].edge, len + 1);
                Node.Edge edge = new Node.Edge();

                edge.length   = dist;
                edge.NumNode  = n2;
                edge.color    = Color.Black;
                edge.value    = distance;
                edge.PrevNode = n1;
                nodes[n1].edge.Add(edge);

                len = nodes[n2].edge.Count;
                //Array.Resize(ref nodes[n2].edge, len + 1);
                edge = new Node.Edge();

                edge.length   = dist;
                edge.NumNode  = n1;
                edge.color    = Color.Black;
                edge.value    = distance;
                edge.PrevNode = n2;
                nodes[n2].edge.Add(edge);
            }
        }
Exemplo n.º 3
0
        private void FindCheepestWays1(Node node, List <Node.Edge> allEdges)     // алгоритм Прима для поиска
        {
            int visitedNodesCount = 0;

            foreach (Node tempNode in nodes)
            {
                if (tempNode.visit)
                {
                    visitedNodesCount++;
                }
            }

            if (visitedNodesCount == nodes.Count)
            {
                return;
            }

            node.visit = true;

            foreach (Node.Edge edge in node.edge)
            {
                if (!edge.visited)
                {
                    allEdges.Add(edge);
                }
            }

            visitedNodes.Add(node);

            if (allEdges.Count == 0)
            {
                return;
            }

            Node.Edge minEdge = allEdges[0];

            for (int i = 1; i < allEdges.Count; i++)
            {
                if (allEdges[i].value < minEdge.value)
                {
                    minEdge = allEdges[i];
                }
            }

            if (!nodes[minEdge.NumNode].visit)
            {
                minEdge.build = true;
            }

            List <Node.Edge> removedEdges = new List <Node.Edge>();

            foreach (Node.Edge edge in allEdges)
            {
                if (edge == minEdge)
                {
                    removedEdges.Add(edge);
                }
            }

            foreach (Node.Edge edge in removedEdges)
            {
                allEdges.Remove(edge);
            }

            allEdges.Remove(minEdge);

            minEdge.visited = true;
            FindCheepestWays1(nodes[minEdge.NumNode], allEdges);
        }