Ejemplo n.º 1
0
    void Start()
    {
        GameManager.Instance.score = 0;
        nodesGraph = new GrafoMA();
        nodesGraph.Initialization();
        int i = 0; // Lo creo afuera para saber cual es la posicion de ultimo vertice

        for (; i < NodeManager.Instance.vertex.Length; i++)
        {
            nodesGraph.AddVertex(NodeManager.Instance.vertex[i]);
        }

        for (int k = 0; k < NodeManager.Instance.edges.Count; k++)
        {
            nodesGraph.AddEdge(k, (int)NodeManager.Instance.edges[k].x, (int)NodeManager.Instance.edges[k].y, (int)NodeManager.Instance.edges[k].z);// Id, From, To, Weight.
        }

        NodeManager.Instance.nodesDictionary.TryGetValue(NodeManager.Instance.vertex[0], out nodeInternet);
        NodeManager.Instance.nodesDictionary.TryGetValue(NodeManager.Instance.vertex[i - 1], out nodeServer);
    }
Ejemplo n.º 2
0
    public string[] camino;              /* Camino encontrado por dijkstra */

    void Awake()
    {
        instance = this;

        // creo la estructura de grafos (estatica)
        grafoEst = new GrafoMA();
        // inicializo TDA
        grafoEst.InicializarGrafo();

        // vector de vértices
        int[] vertices = new int[nodosGrafo.Count];

        // agrego los vértices
        for (int i = 0; i < vertices.Length; i++)
        {
            vertices[i] = i + 1;
            grafoEst.AgregarVertice(vertices[i]);
        }

        // vector de aristas - vertices origen
        aristas_origen = new int[SetAristas.Count];
        // vector de aristas - vertices destino
        aristas_destino = new int[SetAristas.Count];
        // vector de aristas - pesos
        aristas_pesos = new int[SetAristas.Count];
        // carga de datos de aristas
        for (int i = 0; i < SetAristas.Count; i++)
        {
            aristas_origen[i]  = (int)SetAristas[i].x;
            aristas_destino[i] = (int)SetAristas[i].y;
            aristas_pesos[i]   = (int)SetAristas[i].z;
        }

        // agrego las aristas
        Debug.Log("\nAgregando las aristas");
        for (int i = 0; i < aristas_pesos.Length; i++)
        {
            grafoEst.AgregarArista(aristas_origen[i], aristas_destino[i], aristas_pesos[i]);
        }

        Debug.Log("\nListado de Etiquetas de los nodos");
        //for (int i = 0; i < grafoEst.Etiqs.Length; i++)
        //{
        //    if (grafoEst.Etiqs[i] != 0)
        //    {
        //        Debug.Log("Nodo: " + grafoEst.Etiqs[i].ToString());
        //    }
        //}

        Debug.Log("\nListado de Aristas (Inicio, Fin, Peso)");
        for (int i = 0; i < grafoEst.cantNodos; i++)
        {
            for (int j = 0; j < grafoEst.cantNodos; j++)
            {
                if (grafoEst.MAdy[i, j] != 0)
                {
                    // obtengo la etiqueta del nodo origen, que está en las filas (i)
                    int nodoIni = grafoEst.Etiqs[i];
                    // obtengo la etiqueta del nodo destino, que está en las columnas (j)
                    int nodoFin = grafoEst.Etiqs[j];
                    //Debug.Log(nodoIni.ToString() + ", " + nodoFin.ToString() + ", " + grafoEst.MAdy[i, j].ToString());
                }
            }
        }
    }
Ejemplo n.º 3
0
    public static void Dijkstra(GrafoMA grafo, int source)
    {
        // obtengo la matriz de adyacencia del TDA_Grafo
        int[,] graph = grafo.MAdy;

        // obtengo la cantidad de nodos del TDA_Grafo
        int verticesCount = grafo.cantNodos;

        // obtengo el indice del nodo elegido como origen a partir de su valor
        source = grafo.VertexToNode(source);

        // vector donde se van a guardar los resultados de las distancias entre
        // el origen y cada vertice del grafo
        distance = new int[verticesCount];

        bool[] shortestPathTreeSet = new bool[verticesCount];

        int[] nodos1 = new int[verticesCount];
        int[] nodos2 = new int[verticesCount];

        for (int i = 0; i < verticesCount; ++i)
        {
            // asigno un valor maximo (inalcanzable) como distancia a cada nodo
            // cualquier camino que se encuentre va a ser menor a ese valor
            // si no se encuentra un camino, este valor maximo permanece y es el
            // indica que no hay ningun camino entre el origen y ese nodo
            distance[i] = int.MaxValue;

            // seteo en falso al vector que guarda la booleana cuando se encuentra un camino
            shortestPathTreeSet[i] = false;

            nodos1[i] = nodos2[i] = -1;
        }

        // la distancia al nodo origen es 0
        distance[source] = 0;
        nodos1[source]   = nodos2[source] = grafo.Etiqs[source];

        // recorro todos los nodos (vertices)
        for (int count = 0; count < verticesCount - 1; ++count)
        {
            int u = MinimumDistance(distance, shortestPathTreeSet, verticesCount);
            shortestPathTreeSet[u] = true;

            // recorro todos los nodos (vertices)
            for (int v = 0; v < verticesCount; ++v)
            {
                // comparo cada nodo (que aun no se haya calculado) contra el que se encontro que tiene la menor distancia al origen elegido
                if (!shortestPathTreeSet[v] && Convert.ToBoolean(graph[u, v]) && distance[u] != int.MaxValue && distance[u] + graph[u, v] < distance[v])
                {
                    // si encontré una distancia menor a la que tenia, la reasigno la nodo
                    distance[v] = distance[u] + graph[u, v];
                    // guardo los nodos para reconstruir el camino
                    nodos1[v] = grafo.Etiqs[u];
                    nodos2[v] = grafo.Etiqs[v];
                }
            }
        }

        // construyo camino de nodos
        nodos = new string[verticesCount];
        int nodOrig = grafo.Etiqs[source];

        for (int i = 0; i < verticesCount; i++)
        {
            if (nodos1[i] != -1)
            {
                List <int> l1 = new List <int>();
                l1.Add(nodos1[i]);
                l1.Add(nodos2[i]);
                while (l1[0] != nodOrig)
                {
                    for (int j = 0; j < verticesCount; j++)
                    {
                        if (j != source && l1[0] == nodos2[j])
                        {
                            l1.Insert(0, nodos1[j]);
                            break;
                        }
                    }
                }
                for (int j = 0; j < l1.Count; j++)
                {
                    if (j == 0)
                    {
                        nodos[i] = l1[j].ToString();
                    }
                    else
                    {
                        nodos[i] += "," + l1[j].ToString();
                    }
                }
            }
        }
    }
Ejemplo n.º 4
0
            public static void GrafoMAs()
            {
                int x, v1, v2, v;

                Console.WriteLine("\nDigite a quantidade de vertice");
                v = int.Parse(Console.ReadLine());

                //cria o grafo atraves de uma matriz
                //onde a quantidade de vertice acima pedido
                //determina o tamanho da martriz
                GrafoMA grafo = new GrafoMA(v);

                grafo.showMA();

                Console.ReadKey(true);
                Console.Clear();
                do
                {
                    //menu de opcoes
                    Console.WriteLine("\n-------- GRAFOS ----------");
                    Console.WriteLine("1 - Ordem");
                    Console.WriteLine("2 - Inserir Aresta");
                    Console.WriteLine("3 - Remover aresta");
                    Console.WriteLine("4 - Grau do grafo");
                    Console.WriteLine("5 - Grafo eh completo ?");
                    Console.WriteLine("6 - Imprimir grafo");
                    Console.WriteLine("7 - Grafo eh Regular ?");
                    Console.WriteLine("8 - Show MA");
                    Console.WriteLine("9 - Show LA");
                    Console.WriteLine("10 - Sequncia Grau");
                    Console.WriteLine("11 - Lista de adjacencia");
                    Console.WriteLine("12 - vertice isolado");
                    Console.WriteLine("13 - Vertice eh Impar ?");
                    Console.WriteLine("14 - Vertice eh Par ?");
                    Console.WriteLine("15 - Adjacentes");
                    Console.WriteLine("16 - Classe GrafosLA");
                    Console.WriteLine("0 - SAIR ");

                    Console.WriteLine("==> ");
                    x = int.Parse(Console.ReadLine());

                    switch (x)
                    {
                    case 0:
                        Environment.Exit(x);
                        break;

                    case 1:

                        int a;
                        a = grafo.Ordem();
                        Console.Clear();
                        Console.WriteLine("\nOrdem eh: " + a);

                        break;

                    case 2:

                        Console.Write("Digite os dois vertices para ligação: ");
                        v1 = int.Parse(Console.ReadLine());
                        v2 = int.Parse(Console.ReadLine());
                        grafo.InserirAresta(v1, v2);
                        Console.Clear();

                        break;

                    case 3:

                        Console.Write("Digite os dois vertices: ");
                        v1 = int.Parse(Console.ReadLine());
                        v2 = int.Parse(Console.ReadLine());
                        grafo.RemoverAresta(v1, v2);
                        Console.Clear();

                        break;

                    case 4:

                        int c;
                        Console.Write("Digite o vertices: ");
                        v = int.Parse(Console.ReadLine());
                        c = grafo.Grau(v);
                        Console.Clear();
                        Console.WriteLine("\nO grau eh: " + c);

                        break;

                    case 5:

                        Console.Clear();
                        if (grafo.Completo())
                        {
                            Console.WriteLine("\n Grafo eh Completo");
                        }
                        else
                        {
                            Console.WriteLine("\n Grafo nao eh Completo");
                        }

                        break;

                    case 6:
                        Console.Clear();
                        grafo.showMA();
                        break;

                    case 7:
                        Console.Clear();
                        if (grafo.Regular())
                        {
                            Console.WriteLine("\n Grafo eh Regular");
                        }
                        else
                        {
                            Console.WriteLine("\n Grafo nao eh Regular");
                        }

                        break;

                    case 8:

                        Console.Clear();
                        grafo.showMA();

                        break;

                    case 9:

                        Console.Clear();
                        grafo.ShowLA();

                        break;

                    case 10:

                        Console.Clear();
                        grafo.SequenciaGraus();
                        break;

                    case 11:

                        Console.Clear();
                        Console.WriteLine("\nDigite o vertice a saber os adjacentes");
                        v = int.Parse(Console.ReadLine());
                        grafo.VerticesAdjacentes(v);

                        break;

                    case 12:

                        Console.Clear();
                        Console.WriteLine("\nDigite o vertice a saber se e isolado");
                        v = int.Parse(Console.ReadLine());

                        if (grafo.Isolado(v))
                        {
                            Console.WriteLine("O vertice eh isolado");
                        }
                        else
                        {
                            Console.WriteLine("O vertice nao eh isolado");
                        }

                        break;

                    case 13:

                        Console.Clear();
                        Console.WriteLine("\nDigite o vertice a saber se eh impar");
                        v = int.Parse(Console.ReadLine());
                        if (grafo.Impar(v) == true)
                        {
                            Console.WriteLine("Vertice eh Impar");
                        }
                        else
                        {
                            Console.WriteLine("Vertice nao eh impar");
                        }
                        break;

                    case 14:

                        Console.Clear();
                        Console.WriteLine("\nDigite o vertice a saber se eh par");
                        v = int.Parse(Console.ReadLine());
                        if (grafo.Par(v))
                        {
                            Console.WriteLine("Vertice eh Par");
                        }
                        else
                        {
                            Console.WriteLine("Vertice nao eh Par");
                        }

                        break;

                    case 15:

                        Console.Clear();

                        Console.Write("Digite os dois vertices p/ verificar adjacentes: ");
                        v1 = int.Parse(Console.ReadLine());
                        v2 = int.Parse(Console.ReadLine());

                        if (grafo.Adjacentes(v1, v2))
                        {
                            Console.WriteLine("sao Adjacentes");
                        }
                        else
                        {
                            Console.WriteLine("Nao sao Adjacentes");
                        }

                        break;

                    case 16:

                        Console.Clear();
                        GrafoLA.GrafoLAProgram();



                        break;
                    }
                } while (x != 99);


                Console.ReadKey(true);
            }
Ejemplo n.º 5
0
        static void Main(string[] args)
        {
            int     op, op2;
            Menu    menu               = new Menu();
            GrafoMA grafoMA            = new GrafoMA(0);
            GrafoLA grafoLa            = new GrafoLA();
            bool    grafoMAInstanciado = false;

            do
            {
                menu.MenuPrincipal();
                op = int.Parse(Console.ReadLine());

                if (op == 1)
                {
                    int v1, v2;
                    //Instaciação do grafo com a quantidade de vertices desejados
                    if (!grafoMAInstanciado)
                    {
                        Console.Write("Digite a quantidade vértices desejado: ");
                        int qtVertices = int.Parse(Console.ReadLine());
                        grafoMA            = new GrafoMA(qtVertices);
                        grafoMAInstanciado = true;
                    }

                    do
                    {
                        Console.Clear();
                        menu.MenuGrafoMA();
                        op2 = int.Parse(Console.ReadLine());
                    } while (op2 < 0 || op2 > 14);


                    if (op2 == 1)
                    {
                        Console.WriteLine(grafoMA.Ordem());
                    }

                    else

                    if (op2 == 2)
                    {
                        Console.Write("Digite o primeiro vértice adjacente a aresta que deseja inserir: ");
                        v1 = int.Parse(Console.ReadLine());
                        Console.Write("Digite o segundo vértice adjacente a aresta que deseja inserir: ");
                        v2 = int.Parse(Console.ReadLine());
                        if (grafoMA.InserirAresta(v1, v2))
                        {
                            Console.WriteLine("Aresta inserida com sucesso");
                        }
                        else
                        {
                            Console.WriteLine("Aresta não foi inserida com sucesso pois vértices são inexistentes ou já existe aresta");
                        }
                    }

                    else

                    if (op2 == 3)
                    {
                        Console.Write("Digite o primeiro vértice adjacente a aresta que deseja inserir: ");
                        v1 = int.Parse(Console.ReadLine());
                        Console.Write("Digite o segundo vértice adjacente a aresta que deseja inserir: ");
                        v2 = int.Parse(Console.ReadLine());
                        if (grafoMA.RemoverAresta(v1, v2))
                        {
                            Console.WriteLine("Aresta removida com sucesso");
                        }
                        else
                        {
                            Console.WriteLine("Aresta não foi removida com sucesso pois vértices são inexistentes ou não existe aresta");
                        }
                    }

                    else

                    if (op2 == 4)
                    {
                        Console.Write("Digite o vértice que deseja verificar o grau: ");
                        v1 = int.Parse(Console.ReadLine());
                        Console.WriteLine(grafoMA.Grau(v1));
                    }

                    else

                    if (op2 == 5)
                    {
                        if (grafoMA.Completo())
                        {
                            Console.WriteLine("Grafo é completo.");
                        }
                        else
                        {
                            Console.WriteLine("Grafo não é completo.");
                        }
                    }

                    else

                    if (op2 == 6)
                    {
                        if (grafoMA.Regular())
                        {
                            Console.WriteLine("Grafo é regular.");
                        }
                        else
                        {
                            Console.WriteLine("Grafo não é regular.");
                        }
                    }

                    else

                    if (op2 == 7)
                    {
                        grafoMA.ShowMA();
                    }

                    else

                    if (op2 == 8)
                    {
                        grafoMA.ShowLA();
                    }

                    else

                    if (op2 == 9)
                    {
                        grafoMA.SequenciaGraus();
                    }

                    else

                    if (op2 == 10)
                    {
                        Console.Write("Digite o vértice que deseja verificar os vértices adjacentes: ");
                        v1 = int.Parse(Console.ReadLine());
                        grafoMA.VerticesAdjacentes(v1);
                    }

                    else

                    if (op2 == 11)
                    {
                        Console.Write("Digite o vértice que deseja verificar se é isolado: ");
                        v1 = int.Parse(Console.ReadLine());
                        if (grafoMA.Isolado(v1))
                        {
                            Console.WriteLine("Vértices é isolado");
                        }
                        else
                        {
                            Console.WriteLine("Vértices não é isolado");
                        }
                    }

                    else

                    if (op2 == 12)
                    {
                        Console.Write("Digite o vértice que deseja verificar se é impar: ");
                        v1 = int.Parse(Console.ReadLine());
                        if (grafoMA.Impar(v1))
                        {
                            Console.WriteLine("Vértices é impar");
                        }
                        else
                        {
                            Console.WriteLine("Vértices não é impar");
                        }
                    }

                    else

                    if (op2 == 13)
                    {
                        Console.Write("Digite o vértice que deseja verificar se é par: ");
                        v1 = int.Parse(Console.ReadLine());
                        if (grafoMA.Par(v1))
                        {
                            Console.WriteLine("Vértices é par");
                        }
                        else
                        {
                            Console.WriteLine("Vértices não é par");
                        }
                    }

                    else

                    if (op2 == 14)
                    {
                        Console.Write("Digite o primeiro vértice que deseja verificar: ");
                        v1 = int.Parse(Console.ReadLine());
                        Console.Write("Digite o segundo vértice que deseja verificar: ");
                        v2 = int.Parse(Console.ReadLine());
                        if (grafoMA.Adjacentes(v1, v2))
                        {
                            Console.WriteLine("Vértices são adjacentes");
                        }
                        else
                        {
                            Console.WriteLine("Vértices não são adjacentes");
                        }
                    }
                }

                else

                if (op == 2)
                {
                    do
                    {
                        Console.Clear();
                        menu.MenuGrafoLA();
                        op2 = int.Parse(Console.ReadLine());
                    } while (op2 < 0 || op2 > 16);

                    if (op2 == 1)
                    {
                        Console.WriteLine(grafoLa.Ordem());
                    }
                    else
                    if (op2 == 2)
                    {
                        Console.Write("Digite o numero do vértice deseja inserir: ");
                        if (!grafoLa.InserirVertice(int.Parse(Console.ReadLine())))
                        {
                            Console.WriteLine("Vertice ja existe");
                        }
                        else
                        {
                            Console.WriteLine("Inserido com sucesso");
                        }
                    }
                    else
                    if (op2 == 3)
                    {
                        Console.Write("Digite o numero do vértice deseja remover: ");
                        if (!grafoLa.RemoverVertice(int.Parse(Console.ReadLine())))
                        {
                            Console.WriteLine("Vertice ja existe");
                        }
                        else
                        {
                            Console.WriteLine("Removido com sucesso");
                        }
                    }
                    else
                    if (op2 == 4)
                    {
                        Console.Write("Digite o numero do primeiro vértice da aresta: ");
                        var primeiro = int.Parse(Console.ReadLine());
                        Console.Write("Digite o numero do segundo vértice da aresta: ");
                        var segundo = int.Parse(Console.ReadLine());
                        if (!grafoLa.InserirAresta(primeiro, segundo))
                        {
                            Console.WriteLine("Aresta ja existe");
                        }
                        else
                        {
                            Console.WriteLine("Inserido com sucesso");
                        }
                    }
                    else
                    if (op2 == 5)
                    {
                        Console.Write("Digite o numero do primeiro vértice da aresta: ");
                        var primeiro = int.Parse(Console.ReadLine());
                        Console.Write("Digite o numero do segundo vértice da aresta: ");
                        var segundo = int.Parse(Console.ReadLine());
                        if (!grafoLa.RemoverAresta(primeiro, segundo))
                        {
                            Console.WriteLine("Aresta não existe");
                        }
                        else
                        {
                            Console.WriteLine("Removido com sucesso");
                        }
                    }
                    else
                    if (op2 == 6)
                    {
                        Console.Write("Digite o numero vértice: ");
                        Console.WriteLine($"O grau do vertice é {grafoLa.Grau(int.Parse(Console.ReadLine()))}");
                    }
                    else
                    if (op2 == 7)
                    {
                        if (grafoLa.Completo())
                        {
                            Console.Write("\nO grafo é completo ");
                        }
                        else
                        {
                            Console.Write("\nO grafo não é completo");
                        }
                    }
                    else
                    if (op2 == 8)
                    {
                        if (grafoLa.Regular())
                        {
                            Console.Write("\nO grafo é regular ");
                        }
                        else
                        {
                            Console.Write("\nO grafo não é regular");
                        }
                    }
                    else
                    if (op2 == 9)
                    {
                        grafoLa.ShowMA();
                    }
                    else
                    if (op2 == 10)
                    {
                        grafoLa.ShowLA();
                    }
                    else
                    if (op2 == 11)
                    {
                        grafoLa.SequenciaGraus();
                    }
                    else
                    if (op2 == 12)
                    {
                        Console.Write("Digite o numero vértice: ");
                        grafoLa.VerticesAdjacentes(int.Parse(Console.ReadLine()));
                    }
                    else
                    if (op2 == 13)
                    {
                        Console.Write("Digite o numero vértice: ");
                        if (grafoLa.Isolado(int.Parse(Console.ReadLine())))
                        {
                            Console.Write("O vertice é isolado ");
                        }
                        else
                        {
                            Console.Write("O vertice não é isolado");
                        }
                    }
                    else
                    if (op2 == 14)
                    {
                        Console.Write("Digite o numero vértice: ");
                        if (grafoLa.Impar(int.Parse(Console.ReadLine())))
                        {
                            Console.Write("O vertice é impar ");
                        }
                        else
                        {
                            Console.Write("O vertice não é impar");
                        }
                    }
                    else
                    if (op2 == 15)
                    {
                        Console.Write("Digite o numero vértice: ");
                        if (grafoLa.Par(int.Parse(Console.ReadLine())))
                        {
                            Console.Write("O vertice é par ");
                        }
                        else
                        {
                            Console.Write("O vertice não é par");
                        }
                    }
                    else
                    if (op2 == 16)
                    {
                        Console.Write("Digite o numero do primeiro vértice");
                        var primeiro = int.Parse(Console.ReadLine());
                        Console.Write("Digite o numero do segundo vértice");
                        var segundo = int.Parse(Console.ReadLine());
                        if (grafoLa.Adjacentes(primeiro, segundo))
                        {
                            Console.WriteLine("São adjacentes");
                        }
                        else
                        {
                            Console.WriteLine("Não são adjacentes");
                        }
                    }
                }
            } while (op != 0);
        }