/**
 * 頂點(diǎn)
 */
@Data
@AllArgsConstructor
@Accessors(chain = true)
@NoArgsConstructor
class Vertex {
    /**
     * 頂點(diǎn)id
     */
    private String id;

    /**
     * 頂點(diǎn)的名稱
     */
    private String name;

    /**
     * 頂點(diǎn)發(fā)散出去的邊信息
     */
    private List<Edge> edges = new ArrayList<>();

}

/**
 * 邊
 */
@Data
@AllArgsConstructor
@Accessors(chain = true)
@NoArgsConstructor
class Edge {

    /**
     * 邊的目標(biāo)id
     */
    private String targetVertexId;

    /**
     * 邊的id
     */
    private String id;

    /**
     * 邊的名稱
     */
    private String name;
}

/**
 * 有向圖
 *
 * @author alvin
 * @date 2022/10/26
 * @since 1.0
 **/
@Data
@Slf4j(topic = "a.DirectedDiagraph")
public class DirectedDiagraph {

    /**
     * 有向圖的的頂點(diǎn)信息
     */
    private Map<String, Vertex> vertextMap = new HashMap<>();

    /**
     * 邊的數(shù)量
     */
    private int edgeNum;

    /**
     * 添加頂點(diǎn)信息
     *
     * @param vertexId   頂點(diǎn)的id
     * @param vertexName 頂點(diǎn)的名稱
     */
    public void addVertex(String vertexId, String vertexName) {
        if (StrUtil.isEmpty(vertexId)) {
            throw new RuntimeException("頂點(diǎn)id不能為空");
        }

        Vertex node = new Vertex().setId(vertexId).setName(vertexName);
        // 添加到有向圖中
        vertextMap.put(vertexId, node);
    }

    /**
     * 添加邊信息
     *
     * @param fromVertexId   邊的起始節(jié)點(diǎn)
     * @param targetVertexId 邊的目標(biāo)節(jié)點(diǎn)
     * @param edgeId         邊id
     * @param edgeName       邊名稱
     */
    public void addEdge(String fromVertexId, String targetVertexId, String edgeId, String edgeName) {
        if (StrUtil.isEmpty(fromVertexId) || StrUtil.isEmpty(targetVertexId)) {
            throw new RuntimeException("邊的起始頂點(diǎn)或者目標(biāo)頂點(diǎn)不能為空");
        }
        Edge edge = new Edge().setTargetVertexId(targetVertexId).setId(edgeId).setName(edgeName);
        // 獲取頂點(diǎn)
        Vertex fromVertex = vertextMap.get(fromVertexId);
        // 添加到邊中
        fromVertex.getEdges().add(edge);
        // 邊的數(shù)量+1
        edgeNum++;
    }

    /**
     * 添加邊信息
     * @param fromVertexId   邊的起始節(jié)點(diǎn)
     * @param targetVertexId 邊的目標(biāo)節(jié)點(diǎn)
     */
    public void addEdge(String fromVertexId, String targetVertexId) {
        this.addEdge(fromVertexId, targetVertexId, null, null);
    }

    /**
     * 獲取圖中邊的數(shù)量
     */
    public int getEdgeNum() {
        return edgeNum;
    }

}

/**
* 計(jì)算兩個(gè)頂點(diǎn)之間路徑的算法
*/
@Slf4j(topic = "a.CalcTwoVertexPathlgorithm")
class CalcTwoVertexPathlgorithm {

/**
 * 起始頂點(diǎn)
 */
private String fromVertexId;

/**
 * 查詢的目標(biāo)頂點(diǎn)
 */
private String toVertextId;

/**
 * 當(dāng)前的圖
 */
private DirectedDiagraph directedDiagraph;

/**
 * 所有的路徑
 */
private final List<List<String>> allPathList = new ArrayList<>();

public CalcTwoVertexPathlgorithm(DirectedDiagraph directedDiagraph, String fromVertexId, String toVertextId) {
    this.fromVertexId = fromVertexId;
    this.toVertextId = toVertextId;
    this.directedDiagraph = directedDiagraph;
}

/**
 * 打印所有的路徑
 */
public void printAllPaths() {
    log.info("the path betweent {} and {}:", fromVertexId, toVertextId);
    allPathList.forEach(item -> {
        log.info("{}", item);
    });
}

/**
 * 獲取兩點(diǎn)之間所有可能的頂點(diǎn)數(shù)據(jù)
 * @return
 */
public Set<String> getAllVertexs() {
    return allPathList.stream().flatMap(Collection::stream).collect(Collectors.toSet());
}

public void calcPaths() {
    // 先清理之前調(diào)用留下的數(shù)據(jù)
    allPathList.clear();

    DirectedDiagraph.Vertex fromNode = directedDiagraph.getVertextMap().get(fromVertexId);
    DirectedDiagraph.Vertex toNode = directedDiagraph.getVertextMap().get(toVertextId);
    // 無(wú)法找到邊
    if (fromNode == null || toNode == null) {
        throw new RuntimeException("頂點(diǎn)id不存在");
    }

    // 如果其實(shí)節(jié)點(diǎn)等于目標(biāo)節(jié)點(diǎn)，則也作為一個(gè)邊
    if (fromNode == toNode) {
        List<String> paths = new ArrayList<>();
        paths.add(fromVertexId);
        allPathList.add(paths);
        return;
    }

    // 遞歸調(diào)用
    coreRecGetAllPaths(fromNode, toNode, new ArrayDeque<>());
}

private void coreRecGetAllPaths(DirectedDiagraph.Vertex fromVertex, DirectedDiagraph.Vertex toVertex, Deque<String> nowPaths) {
    // 檢查是否存在環(huán)，跳過(guò)
    if (nowPaths.contains(fromVertex.getId())) {
        System.out.println("存在環(huán)");
        // 出棧
        nowPaths.pop();
        return;
    }

    // 當(dāng)前路徑加上其實(shí)節(jié)點(diǎn)
    nowPaths.push(fromVertex.getId());
    // 深度搜索邊
    for (DirectedDiagraph.Edge edge : fromVertex.getEdges()) {
        // 如果邊的目標(biāo)頂點(diǎn)和路徑的最終節(jié)點(diǎn)一直，表示找到成功
        if (StrUtil.equals(edge.getTargetVertexId(), toVertex.getId())) {
            // 將數(shù)據(jù)添加到當(dāng)前路徑中
            nowPaths.push(toVertex.getId());
            // 拷貝一份數(shù)據(jù)放到allPathList中
            List<String> findPaths = new ArrayList<>();
            findPaths.addAll(nowPaths);
            CollUtil.reverse(findPaths);
            allPathList.add(findPaths);
            // 加入了最終節(jié)點(diǎn)，返回一次
            nowPaths.pop();
            // 跳過(guò)，查詢下一個(gè)邊
            continue;
        }

        // 以邊的目標(biāo)頂點(diǎn)作為其實(shí)頂點(diǎn)，繼續(xù)搜索
        DirectedDiagraph.Vertex nextFromVertex = directedDiagraph.getVertextMap().get(edge.getTargetVertexId());
        if (nextFromVertex == null) {
            throw new RuntimeException("頂點(diǎn)id不存在");
        }
        // 遞歸調(diào)用下一次
        coreRecGetAllPaths(nextFromVertex, toVertex, nowPaths);
    }

    // 結(jié)束了，沒(méi)找到，彈出數(shù)據(jù)
    nowPaths.pop();
}

@Data
@Slf4j(topic = "a.DirectedDiagraph")
public class DirectedDiagraph {
    .....
    /**
     * 獲取兩個(gè)頂點(diǎn)之間所有可能的數(shù)據(jù)
     *
     * @param fromVertexId 起始頂點(diǎn)
     * @param targetVertexId 目標(biāo)頂點(diǎn)
     * @return
     */
    public Set<String> findAllPaths(String fromVertexId, String targetVertexId) {
        CalcTwoVertexPathlgorithm calcTwoVertexPathlgorithm = new CalcTwoVertexPathlgorithm(this, fromVertexId, targetVertexId);
        // 先計(jì)算
        calcTwoVertexPathlgorithm.calcPaths();
        // 打印找到的路徑
        calcTwoVertexPathlgorithm.printAllPaths();
        // 然后返回所有的內(nèi)容
        return calcTwoVertexPathlgorithm.getAllVertexs();
    }
     ....
}

@Test
public void test1() {
    DirectedDiagraph directedDiagraph = new DirectedDiagraph();
    directedDiagraph.addVertex("A", "A");
    directedDiagraph.addVertex("B", "B");
    directedDiagraph.addVertex("C", "C");
    directedDiagraph.addVertex("D", "D");
    directedDiagraph.addVertex("E", "E");

    directedDiagraph.addEdge("A", "B");
    directedDiagraph.addEdge("B", "C");
    directedDiagraph.addEdge("C", "D");
    directedDiagraph.addEdge("A", "D");
    directedDiagraph.addEdge("B", "D");
    directedDiagraph.addEdge("A", "C");
    directedDiagraph.addEdge("D", "E");

    Set<String> allPaths = directedDiagraph.findAllPaths("A", "D");
    log.info("all vertexIds: {}", allPaths);
}