Pasar información C++ Amplitud primera búsqueda

LCP 07. Pasar el mensaje

Simple

239

negocio relacionado

El niño A está jugando a un juego de mensajes con sus amigos. Las reglas del juego son las siguientes:

1. Hay n jugadores, todos los jugadores están numerados del 0 al n-1 y el número del niño A es 0
2. Cada jugador tiene un número fijo de otros jugadores (o posiblemente ninguno) a quienes puede enviar mensajes. La relación de transmisión de información es unidireccional (por ejemplo, A puede enviar información a B, pero B no puede enviar información a A).
3. Cada ronda de información debe pasarse a otra persona, y la información puede pasar a través de la misma persona repetidamente.

Dado el número total de jugadores  ny  [玩家编号,对应可传递玩家编号] una matriz 2D por relación  relation. La información devuelta es el número de propuestas pasadas desde el pequeño A (número 0)  k al socio pequeño con el número n-1 a través de rondas; si no se puede alcanzar, devuelve 0.

Ejemplo 1:

ingresar:n = 5, relation = [[0,2],[2,1],[3,4],[2,3],[1,4],[2,0],[0,4]], k = 3

producción:3

Explicación: La información comienza desde el número 0 de la A pequeña, pasa por 3 rondas y llega al número 4. Hay 3 esquemas, a saber, 0->2->0->4, 0->2->1->4, 0->2->3->4.

Ejemplo 2:

ingresar:n = 3, relation = [[0,2],[2,1]], k = 2

producción:0

Explicación: La información no se puede pasar de la A pequeña al número 2 a través de 2 rondas

límite:

• 2 <= n <= 10
• 1 <= k <= 5
• 1 <= relation.length <= 90, 且 relation[i].length == 2
• 0 <= relation[i][0],relation[i][1] < n 且 relation[i][0] != relation[i][1]

Pases

50K

Envíos

65,7K

Tasa de aprobación

76,1%

Solución: entré después de observar la simplicidad y descubrí que era un problema de recorrido de gráfico dirigido. La primera vez pensé en usar el método de retroceso para responder, pero no lo escribí, así que pensé en bfs nuevamente. .He hecho varios problemas antes. Así que lo escribí esta noche y lo aprobé.

Mire el código para obtener más detalles.

class Solution {
public:
    int numWays(int n, vector<vector<int>>& relation, int k) {
        int ret=0;
        queue<int> qpos;
        qpos.push(0);
        int time=0;
        while(!qpos.empty())
        {
            int qsize=qpos.size();
            while(qsize-->0)
            {
                int temp=qpos.front();
                qpos.pop();
                for(auto i:relation)
                {
                    if(i[0]==temp)
                    {
                        qpos.push(i[1]);
                    }
                }
            }
            time++;
            if(time==k)
            {
                while(!qpos.empty())
                {
                    int tem=qpos.front();
                    qpos.pop();
                    if(tem==n-1)
                        ret++;
                }
                break;
            }
        }
        return ret;
    }
};

Esta eficiencia no es alta, la solución oficial a la solución de programación dinámica. Parece que todavía necesito complementar mis conocimientos de dfs, retroceso y programación dinámica.