数组开到10000

结果交了10+次

然后一次AC

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 56ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 72ms

├ 测试数据 06：答案正确... 72ms

├ 测试数据 07：答案正确... 41ms

├ 测试数据 08：答案正确... 41ms

├ 测试数据 09：答案正确... 41ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：323ms

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 25ms

├ 测试数据 04：答案正确... 9ms

├ 测试数据 05：答案正确... 25ms

├ 测试数据 06：答案正确... 56ms

├ 测试数据 07：答案正确... 41ms

├ 测试数据 08：答案正确... 56ms

├ 测试数据 09：答案正确... 41ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：253ms

并查集写错n次...

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 9ms

├ 测试数据 04：答案正确... 9ms

├ 测试数据 05：答案正确... 56ms

├ 测试数据 06：答案正确... 56ms

├ 测试数据 07：答案正确... 56ms

├ 测试数据 08：答案正确... 72ms

├ 测试数据 09：答案正确... 41ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：299ms

KRUSKAL...

裸体mst?

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 9ms

├ 测试数据 04：答案正确... 9ms

├ 测试数据 05：答案正确... 25ms

├ 测试数据 06：答案正确... 25ms

├ 测试数据 07：答案正确... 25ms

├ 测试数据 08：答案正确... 56ms

├ 测试数据 09：答案正确... 41ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：190ms

怎么都是些MST的题啊,没新意`\`稀疏图用克鲁斯卡尔,稠密图用PRIM,显然这题用克鲁斯卡尔``\

终于过了....

这个题直接建小头堆过不了........只能先排序然后再做..

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 41ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 25ms

├ 测试数据 06：答案正确... 41ms

├ 测试数据 07：答案正确... 41ms

├ 测试数据 08：答案正确... 9ms

├ 测试数据 09：答案正确... 41ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：198ms

从同学处学得 节点不用记录类型用数组

标准kruskal(并查集，路径压缩)

加堆优化的prime

我的怎么这么慢？

编译通过...

├ 测试数据 01：答案正确... 1228ms

├ 测试数据 02：答案正确... 494ms

├ 测试数据 03：答案正确... 2588ms

├ 测试数据 04：答案正确... 1838ms

├ 测试数据 05：答案正确... 2916ms

├ 测试数据 06：答案正确... 2931ms

├ 测试数据 07：答案正确... 2931ms

├ 测试数据 08：答案正确... 2744ms

├ 测试数据 09：答案正确... 2759ms

├ 测试数据 10：答案正确... 0ms

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 56ms

├ 测试数据 04：答案正确... 9ms

├ 测试数据 05：答案正确... 56ms

├ 测试数据 06：答案正确... 72ms

├ 测试数据 07：答案正确... 56ms

├ 测试数据 08：答案正确... 72ms

├ 测试数据 09：答案正确... 72ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：393ms

好不容易终于AC了......

Kruskal+并查集

注意精度问题和读入问题

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 56ms

├ 测试数据 04：答案正确... 9ms

├ 测试数据 05：答案正确... 88ms

├ 测试数据 06：答案正确... 103ms

├ 测试数据 07：答案正确... 150ms

├ 测试数据 08：答案正确... 72ms

├ 测试数据 09：答案正确... 72ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：550ms

一次AC

我怎么总觉的kruskal和贪心没什么区别，在做这题之前，我居然连什么是kruskal都

不知道，简直就是变相的贪心

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 25ms

├ 测试数据 04：答案正确... 25ms

├ 测试数据 05：答案正确... 88ms

├ 测试数据 06：答案正确... 88ms

├ 测试数据 07：答案正确... 88ms

├ 测试数据 08：答案正确... 41ms

├ 测试数据 09：答案正确... 72ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：427ms

垃圾算法 慢拉

标准KRUSKAL 用并查集添加 要注意不是连通图的情况 小心进入死循环

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 56ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 41ms

├ 测试数据 06：答案正确... 72ms

├ 测试数据 07：答案正确... 56ms

├ 测试数据 08：答案正确... 72ms

├ 测试数据 09：答案正确... 88ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：385ms

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 25ms

├ 测试数据 04：答案正确... 9ms

├ 测试数据 05：答案正确... 41ms

├ 测试数据 06：答案正确... 9ms

├ 测试数据 07：答案正确... 25ms

├ 测试数据 08：答案正确... 25ms

├ 测试数据 09：答案正确... 41ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：175ms

爽！！！！！！prim算法优化，用邻接表储存 成功降为O(n+m)

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 119ms

├ 测试数据 04：答案正确... 25ms

├ 测试数据 05：答案正确... 25ms

├ 测试数据 06：答案正确... 72ms

├ 测试数据 07：答案正确... 56ms

├ 测试数据 08：答案正确... 72ms

├ 测试数据 09：答案正确... 56ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：425ms

Kruskal

编译通过...

├ 测试数据 01：答案正确... 41ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 884ms

├ 测试数据 04：答案正确... 212ms

├ 测试数据 05：答案正确... 72ms

├ 测试数据 06：答案正确... 603ms

├ 测试数据 07：答案正确... 400ms

├ 测试数据 08：答案正确... 759ms

├ 测试数据 09：答案正确... 697ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：3668ms

哈哈，发了n遍，终于过了，倒数第二次一模一样的发上去居然90分！！！

Qsort+kruskal+并查集

庆祝一下！

不压缩路径，不启发式合并

朴素算法：Qsort+kruskal+并查集

Venus Blaze

编译通过...

├ 测试数据 01：答案正确... 100ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 751ms

├ 测试数据 04：答案正确... 251ms

├ 测试数据 05：答案正确... 50ms

├ 测试数据 06：答案正确... 20ms

├ 测试数据 07：答案正确... 50ms

├ 测试数据 08：答案正确... 511ms

├ 测试数据 09：答案正确... 70ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：1803ms

├ 测试数据 01：答案正确... 212ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 1697ms

├ 测试数据 04：答案正确... 759ms

├ 测试数据 05：答案正确... 72ms

├ 测试数据 06：答案正确... 619ms

├ 测试数据 07：答案正确... 431ms

├ 测试数据 08：答案正确... 2056ms

├ 测试数据 09：答案正确... 1869ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：7715ms

同样做法(堆排+kruskal+并查集),怎么时间差这么远!!

编译通过...

├ 测试数据 01：答案正确... 72ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 884ms

├ 测试数据 04：答案正确... 228ms

├ 测试数据 05：答案正确... 88ms

├ 测试数据 06：答案正确... 619ms

├ 测试数据 07：答案正确... 431ms

├ 测试数据 08：答案正确... 744ms

├ 测试数据 09：答案正确... 41ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：3107ms

+了2个条件快了..但貌似还是差很远

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 56ms

├ 测试数据 04：答案正确... 25ms

├ 测试数据 05：答案正确... 72ms

├ 测试数据 06：答案正确... 56ms

├ 测试数据 07：答案正确... 88ms

├ 测试数据 08：答案正确... 72ms

├ 测试数据 09：答案正确... 72ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：441ms

Qsort+kruskal+并查集

太快了!!不可思议!!!