Java 无向图所有连通分量的最小元素之和

在一个城市里，有

n

人，每个人在城市里都有一些朋友 城市。（如果a是b的朋友，那么b也是a的朋友）我们想在这些人之间散布谣言，但是 对每个人的谣言都有成本，但在这之后，这个人 在所有朋友之间免费传播谣言

我们想找到将谣言传播给世界上所有人的最低成本 城市在输入中，我们得到

n

：人数

m

：关系数。然后是

n

整数

c\u i

：对人说出谣言的成本

i

，然后在

m

行中，我们得到两个整数

u

，

v

，每行表示

u，v

是朋友。（请注意，人数从

1

到

n

开始，但在数组中，我们从

0

到

n-1

）

---

而且

n，m这些行不能满足您的要求：

    // Stores the minimum
    mini = Math.min(mini, costs[(Integer) node]);

如果它们改变了调用方的
mini
，那么您的代码在其他方面似乎是正确的（假设没有堆栈溢出）。我的建议是返回新值
mini
，供调用者使用：

Long dfs(Integer node, Long mini) {
    // Stores the minimum
    mini = Math.min(mini, costs[(Integer) node]);

    // Marks node as visited
    visited[(Integer) node] = true;

    // Traversed in all the connected nodes
    for (Integer i : graph[(Integer) node]) {
        if (!visited[(Integer) i])
            mini = dfs(i, mini);
    }

    return mini;
}

void minimumSumConnectedComponents() {
    // Initially sum is 0
    Long sum = 0L;

    // Traverse for all nodes
    for (Integer i = 0; i < numberOfVertices; i++) {
        if (!visited[i]) {
            sum += dfs(i, costs[i]);
        }
    }

    // Returns the answer

    System.out.println(sum);
}

长dfs（整数节点，长迷你）{
//存储最小值
mini=Math.min（mini，成本[（整数）节点]；
//将节点标记为已访问
已访问[（整数）节点]=true；
//在所有连接的节点中遍历
对于（整数i:graph[（整数）节点]）{
如果（！已访问[（整数）i]）
mini=dfs（i，mini）；
}
返回迷你；
}
void minimumSumConnectedComponents（）{
//最初的总和是0
长和=0L；
//遍历所有节点
对于（整数i=0；i
它解决了很多问题，但现在我只在一个案例中发现了timelimit错误。有优化的想法吗？（我想这个问题的时间限制是2秒左右）我用LinkedList代替Vector解决了这个时间限制问题。感谢您在算法方面的帮助。
5 2
2 5 3 4 8
1 4
4 5

Expected Output: 10

10 0
1 2 3 4 5 6 7 8 9 10

Expected Output: 55

10 5
1 6 2 7 3 8 4 9 5 10
1 2
3 4
5 6
7 8
9 10

Expected Output: 15

    // Stores the minimum
    mini = Math.min(mini, costs[(Integer) node]);

Long dfs(Integer node, Long mini) {
    // Stores the minimum
    mini = Math.min(mini, costs[(Integer) node]);

    // Marks node as visited
    visited[(Integer) node] = true;

    // Traversed in all the connected nodes
    for (Integer i : graph[(Integer) node]) {
        if (!visited[(Integer) i])
            mini = dfs(i, mini);
    }

    return mini;
}

void minimumSumConnectedComponents() {
    // Initially sum is 0
    Long sum = 0L;

    // Traverse for all nodes
    for (Integer i = 0; i < numberOfVertices; i++) {
        if (!visited[i]) {
            sum += dfs(i, costs[i]);
        }
    }

    // Returns the answer

    System.out.println(sum);
}