Dado un árbol, pesos asignar a cada borde con el fin de minimizar el peso de cada camino (u, v) en el árbol de

LavaMaster :

Dado un árbol, pesos asignar a cada borde con el fin de minimizar el peso de cada camino (u, v) en el árbol. Para aclarar, estamos minimizando el peso máximo en cada camino en el árbol

Esta pregunta puede ser resuelto con algún tipo de estructura de datos o algoritmo? ¿Cómo se determina qué pesos lugar en cada borde en el árbol? La entrada es un número N, y usted tiene que colocar pesos en entre los valores de [0, N-2] (inclusive) en cada borde del árbol.

Permítanme aclarar la cuestión. Digamos que usted tiene un borde (1, 2) y colocar el peso 3 en ese borde. La definición actual de "peso" en el contexto de la cuestión es el valor mínimo-máximo de [0, N-2] que no está presente en el camino de (u, v). A pesar de que el peso específico en el borde es de tres, el peso real en el contexto de la pregunta es cero. Además, la raíz del árbol en esta pregunta es 1.

Mi enfoque original para esta pregunta fue la de añadir los valores de [0, N-2] (los valores de borde que podemos asignar a cada borde) a una pila, a continuación, recorrer el árbol usando DFS y el pop un valor de la pila (el máximo valor borde -la mayoría) y asignarlo a la orilla. Esto, sin embargo, no minimizar el costo en todos los caminos. Tenga en cuenta, el costo es el mínimo-máximo valor no está presente en el camino de (u, v). Estamos tratando de colocar los costes para minimizar los costos en cada camino posible.

Mi código:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Stack;
import java.util.Iterator;
import java.util.ArrayList;
    public class Mex    {
        public static void main (String [] args) throws IOException {
            BufferedReader b1 = new BufferedReader(new InputStreamReader(System.in));
            int n = Integer.parseInt(b1.readLine());
            LinkedList<Integer>[] adj = new LinkedList[n+1];
            ArrayList<Integer> v = new ArrayList<Integer>(n+1);
            for(int i = 1; i<=n; i++) {
                adj[i] = new LinkedList<Integer>();
            }
            for(int i = 0; i<n-1; i++) {
                String [] edge = (b1.readLine()).split(" ");
                adj[Integer.parseInt(edge[0])].add(Integer.parseInt(edge[1]));
                adj[Integer.parseInt(edge[1])].add(Integer.parseInt(edge[0]));
                v.add(Integer.parseInt(edge[0]));
                v.add(Integer.parseInt(edge[1]));
            }
            dfs(adj, 1, n, v);


        }
        static void dfs(LinkedList<Integer> adj[], int u, int n, ArrayList<Integer> order)   { 
            Stack<Integer> values = new Stack<>();
            int [][] weight = new int[n+1][n+1];
            for(int i = 0; i<n-1; i++) {
                values.push(i);
            }
            boolean [] visited = new boolean[n+1];
            int [] parent = new int[n+1];
            for (int i = 1; i < n+1; i++) 
                visited[i] = false; 

            Stack<Integer> stack = new Stack<>(); 

            stack.push(u); 

            while(stack.empty() == false) { 
                u = stack.peek(); 
                stack.pop(); 

                if(visited[u] == false)  { 
                  visited[u]  = true; 
                  if(u!= 1) {
                    if(adj[u].size()==1) {
                        if(values.contains(0)) {
                            weight[parent[u]][u] = 0;
                            values.remove(0);
                        }
                        else {
                            int w = values.pop();
                            weight[parent[u]][u] = w;
                        }
                    }
                    else {
                        int w = values.pop();
                        weight[parent[u]][u] = w;   
                    }
                  }
                } 

                Iterator<Integer> itr = adj[u].iterator(); 

                while (itr.hasNext())  {                    
                    int v = itr.next(); 
                    if(parent[v]==0 && v!=1) {
                        parent[v] = u;
                    }
                    if(!visited[v]) 
                        stack.push(v); 
                } 

            } 
            for(int i = 0; i<order.size()-1; i+=2) {
                if(parent[order.get(i)]==order.get(i+1)) {
                    System.out.println(weight[order.get(i+1)][order.get(i)]);               
                }
                else {
                    System.out.println(weight[order.get(i)][order.get(i+1)]);               
                }
            }
        } 
    }

Ekesh Kumar:

No hay ningún algoritmo o los datos de estructura especial que se necesita para resolver este problema. No es sólo una observación clave que necesita para hacer:

• Si cada vértice en el gráfico tiene grado 2 o menos, entonces no importa cómo se colocan los vértices, siempre hay un camino que toca cada borde. Por lo tanto, no importa cómo colocar las etiquetas.

• Si hay al menos un vértice en el gráfico con grado 3 o más, entonces podemos colocar 0, 1, y 2 a cada lado de este vértice. Ahora, la máxima excludant mínimo es 2ya que podemos tomar un camino de 0a 1. Está bastante claro que no se puede hacer mejor que esto ya que siempre puede comenzar en 0e ir a 1conseguir un mínimo de excludant 2. Por lo tanto, puede hacer que los bordes 0, 1y 2incidente al mismo vértice. Las otras etiquetas no importan.