java pojo 转成树结构对象

问题描述

数据结构-最小生成树

Description

给定一个有n个点的无向图，其中有m条权值为wi的边，问该图的最小生成树的费用为多少。

Input

第一行给定两个整数分别为n，m，分别代表完全图中有n个点，有m条权值为ai的边

后面输入有m行，每行三个值u，v，w代表从u到v有一条权值为w的边

Output

最小生成树的费用，如果无法生成最小生成树，则输出Imp

Sample Input 1 

2 0

Sample Output 1

Imp

Sample Input 2 

3 2 1 2 2 1 3 3

Sample Output 2

5

问题分析

解决最小生成树问题有prim和kurskal两种算法，这里使用prim算法解决。

在一个无向图中，n个顶点的图最多有多少条边，允许自环（即顶点连接到自己）的情况下，最多有n * (n + 1) / 2 条边（小于n*n）。

可以选择使用矩阵的方法来存储图，保证边的数量不溢出，列如：

生成一个4个节点的无向图，选择用4*4的矩阵表示

初始化：将对角线结点置为0（表示自己到自己的距离），其余为+++（无穷大）

填入边的权重：

创建一个数组index[],存储最短路径

创建一个数组visited[],标记结点的访问状态

从第一个结点（0号结点）开始，遍历00，01，02，03四条边，将代价最小的更新到index[],并将visited[]中对应结点更新为已访问状态

继续循环，直到访问完最后一个结点，将index[]中的值加起来就是最小代价啦。

完整代码实现

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static int initialNum = 99;  // 设置一个初始值，表示无穷大

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        // 读取点的数量和边的数量
        int point = input.nextInt();  // 读取点（节点）的数量
        int edge = input.nextInt();   // 读取边的数量

        // 创建一个二维数组来表示图，图是由点和边组成的
        int[][] graph = new int[point][point];

        // 初始化图，将所有点之间的距离设置为初始值（无穷大）
        for (int i = 0; i < point; i++) {
            Arrays.fill(graph[i], initialNum);
            graph[i][i] = 0;  // 对角线上的距离为0，表示一个点到自己的距离
        }

        // 读取边的信息并填充到图中
        for (int i = 0; i < edge; i++) {
            int startNum = input.nextInt() - 1;  // 读取起点，并减去1以将点从1-based索引转换为0-based索引
            int finalNum = input.nextInt() - 1;  // 读取终点，并减去1以将点从1-based索引转换为0-based索引
            int weight = input.nextInt();  // 读取边的权重
            graph[startNum][finalNum] = weight;  // 设置起点到终点的距离
            graph[finalNum][startNum] = weight;  // 因为是无向图，所以需要对称填充
        }

        // 调用 primeIndex 方法计算最小生成树的权重
        int count = primeIndex(graph);

        // 输出结果，如果无法生成最小生成树，则输出 "Imp"
        System.out.println(count == initialNum ? "Imp" : count);
    }

    // 计算最小生成树的权重
    private static int primeIndex(int[][] graph) {
        int length = graph.length;
        int[] index = new int[length];  // 存储生成最短路径的权重
        boolean[] visited = new boolean[length];  // 标记节点是否已访问

        // 初始化生成最短路径的权重数组，假设从第一个节点开始生成
        Arrays.fill(index, initialNum);
        index[0] = 0;

        for (int i = 0; i < length - 1; i++) {
            // 查找下一个要生成最短路径的节点
            int correctIndex = findIndex(index, visited);
            if (correctIndex == -1) {
                // 如果无法生成最小生成树，返回初始值
                return initialNum;
            }
            visited[correctIndex] = true;  // 标记该节点为已访问
            for (int j = 0; j < length; j++) {
                if (!visited[j] && graph[correctIndex][j] != initialNum) {
                    // 如果节点未访问过且存在连接，则更新最短路径权重
                    index[j] = Math.min(graph[correctIndex][j], index[j]);
                }
            }
        }

        // 计算最小生成树的权重总和
        int count = 0;
        for (int i = 0; i < length; i++) {
            count += index[i];
        }
        return count;
    }

    // 查找下一个要生成最短路径的节点
    private static int findIndex(int[] index, boolean[] visited) {
        int indexNum = -1;
        int length = index.length;
        for (int i = 0; i < length; i++) {
            if (!visited[i] && index[i] < initialNum) {
                indexNum = i;
            }
        }
        return indexNum;
    }
}