精华内容
下载资源
问答
  • 计算中位数相等的Kruskal-Wallis检验。 Kruskal-Wallis秩和检验针对多个样本评估其中位数相同的零假设。 Kruskal-Wallis检验是一种非参数检验,不需要将数据进行正态分布。 为了进行测试,计算各个组的等级总和S_...
  • 它是由 Leo Goodman 和 William Kruskal 在一系列论文(1954、1959、1963 和 1972)中提出的。 如果在一个变量上较高的受试者在另一个变量上也较高,则一对观察是一致的,如果在一个变量上较高的受试者在另一个...
  • 非参数方差分析的 Kruskal-Wallis 检验在统计学中,Kruskal-Wallis 按等级对方差进行单向分析(命名为(威廉·克鲁斯卡尔(William Kruskal)和W.艾伦·沃利斯(W.Allen Wallis) 检验各组之间人口中位数的相等性。 ...
  • 项目介绍 使用查找无向加权图的(MST)的Java程序。 项目特色 以最有效的形式使用。 使用 通过命令行从输入文件中读取无向加权图。 输入文件包含以下内容(请参见testUF.txt): 零个或多个以'c'开头的注释行 ...
  • Kruskal 算法是图论中的一种算法,它为连通的无向加权图找到最小生成树 压缩文件包含 kruskal.m iscycle.m fysalida.m connected.m 如果我们想找到最小生成树。 我们称之为函数 kruskal。 % 输入:PV = nx3 martix...
  • 最小生成树(Prim,Kruskal)C++代码实现 (可运行,含测试用例,有输出,注释详细) 对于一个带权连通图,生成树不同,树中各边上权值总和也不同,权值总和最小的生成树则称为图的最小生成树。
  • (1)、实验题目:给定一个地区的n 个城市间的距离网,用Prim算法或Kruskal算法建立最小生成树,并得到的最小生成树的代价。 (2)、实验要求: 1、城市间的距离网采用的邻接矩阵表示,邻接矩阵的存储结构定义采用...
  • 一个有 n 个结点的连通图的生成树是原图的极小连通子图,且包含原图中的所有 n 个结点,并且有保持图连通的最少的边。最小生成树可以用kruskal算法
  • Kruskal-Wallis 的非参数方差分析检验了组间的差异,它适用于相等或不相等的样本量以及是否存在相同的等级。 该文件同时使用卡方和 F 近似值。
  • kruskal算法及代码 ---含伪代码c代码matlabpascal等代码 K r u s k a l 算法每次选择n- 1条边所使用的贪婪准则是从剩下的边中选择一条不会产生 环路的具有最小耗费的边加入已选择的边的集合中注意到所选取的边若产生...
  • 主要为大家详细介绍了python最小生成树kruskal与prim算法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Kruskal算法.docx

    2019-12-04 16:31:12
    算法分析与设计或者数据结构Kruskal求最小生成树,从任意一个边出发,贪心选择最小边权的边,直到把所有的顶点连到一起。
  • Kruskal算法的MATLAB实现

    2018-01-29 22:20:15
    Kruskal算法的MATLAB实现,输入参数d是原图的权值矩阵;输出参数T是最小生成树的顶点组成的矩阵,每条边的两个顶点放在同一列中;a是最小生成树的总权值
  • Kruskal

    2021-05-05 14:41:37
    文章目录前言一、Kruskal算法二、AcWing 859. Kruskal算法求最小生成树本题分析AC代码三、时间复杂度 前言 复习acwing算法基础课的内容,本篇为讲解基础算法:Kruskal,关于时间复杂度:目前博主不太会计算,先鸽了...


    前言

    复习acwing算法基础课的内容,本篇为讲解基础算法:Kruskal,关于时间复杂度:目前博主不太会计算,先鸽了,日后一定补上。


    一、Kruskal算法

    把所有边按照权重从小到大进行排序,枚举每条边(a,b,w),如果a,b不连通,把这条边也加入到集合中,判断a,b是否联通用的是并查集

    下图来自AcWing算法基础课

    在这里插入图片描述


    二、AcWing 859. Kruskal算法求最小生成树

    本题链接:AcWing 859. Kruskal算法求最小生成树
    本博客提供本题截图:

    在这里插入图片描述

    本题分析

    p数组就是并查集中的p数组,find函数就是并查集中的find函数,res存储的是最小生成树中的所有树边的权重之和,cnt存储的是当前加入了多少条边,因为一共有n个点,所以如果最后的边数小于n - 1的话,证明不存在最小生成树

    AC代码

    #include <cstdio>
    #include <algorithm>
    
    using namespace std;
    
    const int N = 100010, M = 200010;
    const int INF = 0x3f3f3f3f;
    
    int n, m;
    int p[N];
    
    struct Edge
    {
        int a, b, w;
        
        bool operator < (const Edge W) const
        {
            return w < W.w;
        }
    }edges[M];
    
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }
    
    int kruskal()
    {
        sort(edges, edges + m);
        
        for (int i = 1; i <= n; i ++ ) p[i] = i;
        
        int res = 0, cnt = 0;
        for (int i = 0; i < m; i ++ )
        {
            auto t = edges[i];
            int a = t.a, b = t.b, w = t.w;
            
            a = find(a), b = find(b);
            
            if (a != b)
            {
                res += w;
                cnt ++;
                p[a] = b;
            }
        }
        
        if (cnt < n - 1) return INF;
        else return res;
    }
    
    int main()
    {
        scanf("%d%d", &n, &m);
        
        for (int i = 0; i < m; i ++ )
        {
            int a, b, w;
            scanf("%d%d%d", &a, &b, &w);
            
            edges[i] = {a, b, w};
        }
        
        int t = kruskal();
        
        if (t == INF) printf("impossible");
        else printf("%d", t);
        
        return 0;
    }
    

    三、时间复杂度

    关于Kruskal算法的时间复杂度以及证明,后续会给出详细的说明以及证明过程,目前先鸽了。

    展开全文
  • 通过使用深度优先搜索或广度优先搜索(取决于用户指定的内容)随机生成可解决的迷宫。 用Java编写,并使用东北大学的“ impworld”库绘制迷宫。
  • 基于Kruskal算法的混淆状态机设计
  • Kruskal算法代码

    2016-09-05 16:25:05
    介绍最小生成树的Kruskal算法,用于计算关于城市之间以最小代价建造公路或者造桥问题;
  • 主要介绍了C++使用Kruskal和Prim算法实现最小生成树,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Kruskal.java

    2020-07-27 10:37:03
    Kruskal 算法的 Java 实现。克鲁斯卡尔算法的具体思路是:将所有边按照权值的大小进行升序排序,然后从小到大一一判断,条件为:如果这个边不会与之前选择的所有边组成回路,就可以作为最小生成树的一部分;反之,...
  • Kruskal算法python实现

    2017-06-21 20:20:15
    Kruskal算法python实现,包括无向图的绘制,需要自己在桌面上先建关于无向图的TXT
  • 合肥学院 计算机科学与技术系 课程设计报告 20132014 学年第 2 学期 课程 数据结构与算法 课程设计题目名称 用Kruskal算法求解其所有的最小生成树 学生姓名 童子轩 学号 1204013037 专业班级 12级计本3班 指导教师 ...
  • 学 生 实 验 报 告 学 院 软件与通信工程学院 课程名称 专业班级 离散数学软件 12 软件 2 班 姓 学 名 号 杨滨 0123707 学生实验报告2 学生姓名 杨滨 学号 0123707 同组人 实验项目 求最小生成树Kruskal 算法 同组人...
  • Kruskal C语言实现

    2018-05-08 11:07:30
    /************************ Kruskal************************************ ************************explanation in english********************** *******************Create by Huiyue2012**********************...
  • 合肥学院 计算机科学与技术系 课程设计报告 2014-2015学年第二学期 课程 数据结构 课程设计名称 Kruskal算法求最小生成树 学生姓名 姚国栋 学号 1204091021 专业班级 12软件工程 指导教师 何立新 2014年9月 题目设计...
  • kruskal.py

    2020-02-13 16:41:50
    克鲁斯卡尔算法(即 Kruskal)的一种 Python 代码实现,这是最经典的一种图算法之一,对于图G(V,E),借助这个算法可以得到其最小生成树。
  • kruskal 算法及代码 含伪代码 c 代码 matlab pascal 等代码 K r u s k a l 算法 每次选择 n- 1 条边所使用的贪婪准则是从剩下的边中 选择一条不会产生 环路 的具有最小耗费的边加入已选择的边的集合中 注意到所 选取...
  • kruskal

    2018-11-12 22:12:04
    //kruskal #include&lt;iostream&gt; #include&lt;stdlib.h&gt; #include&lt;malloc.h&gt; using namespace std; #define TOPMAX 60000 #define MAX 100 //邻接矩阵 typedef struct _...

     

    //kruskal
    
    
    #include<iostream>
    #include<stdlib.h>
    #include<malloc.h>
    using namespace std;
    
    
    #define TOPMAX  60000
    #define MAX 100
    
    //邻接矩阵
    typedef struct _graph
    {
    	char vexs[MAX];//顶点
    	int vexnum;//顶点数
    	int edgnum;//边数
    	int matrix[MAX][MAX];//保存矩阵的信息
    }Graph,*PGraph;
    //边的结构图
    typedef struct _EdgeData
    {
    	char start;
    	char end;
    	int weight;
    }EData;
    
    
    void CreateJuzhen(Graph &G)
    {
    	int i, j = 0;
    	G.vexnum = 9;
    	for (i = 0; i < G.vexnum; i++)
    	{
    		G.vexs[i] = 65 + i;
    		cout << "i的值为:" << G.vexs[i] << endl;
    	}
    	G.vexs[G.vexnum] = '\0';
    	G.edgnum = 15;	
    	for (i = 0; i < G.vexnum; i++)
    	{
    		for (j = 0; j < G.vexnum; j++)
    		{
    			if (i == j)
    				G.matrix[i][j] = 0;
    			else
    				G.matrix[i][j] = TOPMAX;
    		}
    	}
    		G.matrix[0][1] = 10;
    		G.matrix[0][5] = 11;
    		G.matrix[1][2] = 18;
    		G.matrix[1][8] = 12;
    		G.matrix[1][6] = 16;
    		G.matrix[2][8] = 8;
    		G.matrix[2][3] = 22;
    		G.matrix[3][8] = 21;
    		G.matrix[3][7] = 16;
    		G.matrix[3][4] = 20;
    		G.matrix[4][7] = 7;
    		G.matrix[4][5] = 26;
    		G.matrix[5][6] = 17;
    		G.matrix[6][7] = 19;
    	for (i = 0; i < G.vexnum; i++)
    	{
    			for (j = 0; j < G.vexnum; j++)
    				G.matrix[j][i] = G.matrix[i][j];
    	}
    
    	
    }
    static int get_position(Graph G, char ch)
    {
    	int i;
    	for (i = 0; i < G.vexnum; i++)
    	{
    		if (ch == G.vexs[i])
    			return i;
    	}
    	return -1;
    }
    
    
    
    
    	void Print(Graph G)
    	{
    		int i, j;
    		for (i = 0; i < G.vexnum; i++)
    		{
    			for (j = 0; j < G.vexnum; j++)
    				cout << G.matrix[i][j] << "  ";
    			cout << endl;
    		}
    	}
    
    	//获取图中的边
    	EData* get_edges(Graph G)
    	{
    		int i, j;
    		int index=0;
    		EData *edges = NULL;
    		edges = (EData *)malloc(G.edgnum * sizeof(EData));
    		if (NULL == edges)
    		{
    			cout << "error" << endl;
    			return NULL;
    		}
    		for (i = 0; i < G.vexnum; i++)
    		{
    			for (j = i + 1; j < G.vexnum; j++)
    			{
    				if (G.matrix[i][j] != TOPMAX)
    				{
    					edges[index].start = G.vexs[i];
    					edges[index].end = G.vexs[j];
    					edges[index].weight = G.matrix[i][j];
    					index++;
    				}
    			}
    		}
    		return edges;
    }
    
    //对边按照权值大小排序
    
    
    	void sorted_edges(EData *edges, int elen)
    	{
    		int i, j;
    		EData tmp;
    		for (i = 0; i < elen; i++)
    		{
    			for (j = i + 1; j < elen; j++)
    			{
    				if (edges[i].weight > edges[j].weight)
    				{
    					tmp = edges[i];
    					edges[i] = edges[j];
    					edges[j] = tmp;
    				}
    			}
    		}
    }
    	//获取i的终点
    	int get_end(int vends[], int i)
    	{
    		if (i >= 0)
    		{
    			while (vends[i] != 0)
    				i = vends[i];
    		}
    		return i;
    
    	}
    
    	void kruskal(Graph G)
    	{
    		int i, m, n, p1, p2;
    		int length;
    		int index = 0;
    		int vends[MAX] = { 0 };// 用于保存"已有最小生成树"中每个顶点在该最小树中的终点
    		EData rets[MAX];// 结果数组,保存kruskal最小生成树的边
    		EData *edges=NULL; // 图对应的所有边
    		// 获取"图中所有的边"
    		edges = get_edges(G);
    		if (edges == NULL)
    			return;
    		sorted_edges(edges, G.edgnum);
    		for (i = 0; i < G.edgnum; i++)
    		{
    			p1 = get_position(G, edges[i].start);// 获取第i条边的"起点"的序号
    			p2 = get_position(G, edges[i].end);// 获取第i条边的"终点"的序号
    
    			m = get_end(vends, p1);
    			n = get_end(vends, p2);
    			if (m != n)
    			{
    				vends[m] = n;
    				rets[index++] = edges[i];
    			}
    
    		}
    		length = 0;
    		for (i = 0; i < index; i++)
    			length += rets[i].weight;
    		cout << "Kruskal:" << length << endl;
    		for (i = 0; i < index; i++)
    			cout << "(" << rets[i].start << "," << rets[i].end << ")" << endl;
    
    
    }
    
    
    
    int main()
    {
    	Graph G;
    	CreateJuzhen(G);
    	Print(G);
    	kruskal(G);
    	system("pause");
    	return 0;
    }
    



     

    展开全文
  • MST Prim 和 Kruskal 算法的 Java 实现,用于查找图的最小生成树
  • 基于Union-Find数据结构实现Kruskal求最小生成树,代码设计及变量命名附详细注释。基于Union-Find数据结构实现Kruskal求最小生成树,代码设计及变量命名附详细注释。
  • 本文讨论了Kruskal算法的基本思想,然后提出了一种新的改进算法-两分支Kruskal算法,该算法经过改进以选择中间值。 最后,由于减少了时间复杂度,并且处理更加方便,因此可以得出结论,改进的Kruskal算法在大多数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,711
精华内容 15,084
关键字:

KRUSKAL