程序员经验分享-hwhale

Fuzzy C-Means（模糊C均值聚类）算法原理详解与python实现

2023-05-16

目录

模糊理论

Fuzzy C-Means算法原理

算法步骤

python实现

参考资料

本文采用数据集为iris,将iris.txt放在程序的同一文件夹下。请先自行下载好。

模糊理论

模糊控制是自动化控制领域的一项经典方法。其原理则是模糊数学、模糊逻辑。1965，L. A. Zadeh发表模糊集合“Fuzzy Sets”的论文， 首次引入隶属度函数的概念，打破了经典数学“非0即 1”的局限性，用[0,1]之间的实数来描述中间状态。

很多经典的集合（即：论域U内的某个元素是否属于集合A，可以用一个数值来表示。在经典集合中，要么0，要么1）不能描述很多事物的属性，需要用模糊性词语来判断。比如天气冷热程度、人的胖瘦程度等等。模糊数学和模糊逻辑把只取1或0二值（属于/不属于）的普通集合概念推广0~1区间内的多个取值，即隶属度。用“隶属度”来描述元素和集合之间的关系。

如图所示，对于冷热程度，我们采取三个模糊子集：冷、暖、热。对于某一个温度，可能同时属于两个子集。要进一步具体判断，我们就需要提供一个描述“程度”的函数，即隶属度。

例如，身高可以分为“高”、“中等”、“矮”三个子集。取论域U（即人的身高范围）为[1.0,3.0]，单位m。在U上定义三个隶属度函数来确定身高与三个模糊子集的关系：

模糊规则的设定：

(1)专家的经验和知识

– 藉由询问经验丰富的专家，在获得系统的知 识后，将知识改为IF....THEN ....的型式。

(2)操作员的操作模式

– 记录熟练的操作员的操作模式，并将其整理为IF....THEN ....的型式。

(3)自学习

– 设定的模糊规则可能存在偏差，模糊控制器能依设定的目标，增加或修改模糊控制规则

Fuzzy C-Means算法原理

模糊c均值聚类融合了模糊理论的精髓。相较于k-means的硬聚类，模糊c提供了更加灵活的聚类结果。因为大部分情况下，数据集中的对象不能划分成为明显分离的簇，指派一个对象到一个特定的簇有些生硬，也可能会出错。故，对每个对象和每个簇赋予一个权值，指明对象属于该簇的程度。当然，基于概率的方法也可以给出这样的权值，但是有时候我们很难确定一个合适的统计模型，因此使用具有自然地、非概率特性的模糊c均值就是一个比较好的选择。

简单地说，就是要最小化目标函数Jm:（在一些资料中也定义为SSE即误差的平方和）

其中m是聚类的簇数；i，j是类标号；u_i_j表示样本x_i属于j类的隶属度。i表示第i个样本，x是具有d维特征的一个样本。c_j是j簇的中心，也具有d维度。||*||可以是任意表示距离的度量。关于有哪些基于距离的度量，可参考我的另一篇博文《数据的相似性和相异性的度量》。

模糊c是一个不断迭代计算隶属度u_i_j和簇中心c_j的过程，直到他们达到最优。

，

注：对于单个样本x_i，它对于每个簇的隶属度之和为1。

迭代的终止条件为：

其中k是迭代步数，\varepsilon是误差阈值。上式含义是，继续迭代下去，隶属程度也不会发生较大的变化。即认为隶属度不变了，已经达到比较优（局部最优或全局最优）状态了。该过程收敛于目标Jm的局部最小值或鞍点。

抛开复杂的算式，这个算法的意思就是：给每个样本赋予属于每个簇的隶属度函数。通过隶属度值大小来将样本归类。

算法步骤

1、初始化

通常采用随机初始化。即权值随机地选取。簇数需要人为选定。

2、计算质心

FCM中的质心有别于传统质心的地方在于，它是以隶属度为权重做一个加权平均。

3、更新模糊伪划分

即更新权重（隶属度）。简单地说，如果x越靠近质心c，则隶属度越高，反之越低。

python实现

这段代码是以iris数据集为例的，雏形源于网络，在错误的地方做了一些修正。是专门针对iris写的：

如果要使用你自己的数据集，请看第二段代码。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Mar 27 10:51:45 2019
@author: youxinlin
"""
import copy
import math
import random
import time

global MAX # 用于初始化隶属度矩阵U
MAX = 10000.0

global Epsilon  # 结束条件
Epsilon = 0.0000001
 
def import_data_format_iris(file):
    """
    file这里是输入文件的路径，如iris.txt.
    格式化数据，前四列为data，最后一列为类标号（有0，1，2三类）
    如果是你自己的data，就不需要执行此段函数了。
    """
    data = []
    cluster_location =[]  
    with open(str(file), 'r') as f:
        for line in f:
            current = line.strip().split(",")  #对每一行以逗号为分割，返回一个list
            current_dummy = []
            for j in range(0, len(current)-1):
                current_dummy.append(float(current[j]))  #current_dummy存放data

    #下面注这段话提供了一个范例：若类标号不是0，1，2之类数字时该怎么给数据集
            j += 1 
            if  current[j] == "Iris-setosa\n":
                cluster_location.append(0)
            elif current[j] == "Iris-versicolor\n":
                cluster_location.append(1)
            else:
                cluster_location.append(2)
            data.append(current_dummy)
    print("加载数据完毕")
    return data
#	return data , cluster_location
 
def randomize_data(data):
	"""
	该功能将数据随机化，并保持随机化顺序的记录
	"""
	order = list(range(0, len(data)))
	random.shuffle(order)
	new_data = [[] for i in range(0, len(data))]
	for index in range(0, len(order)):
		new_data[index] = data[order[index]]
	return new_data, order
 
def de_randomise_data(data, order):
	"""
	此函数将返回数据的原始顺序，将randomise_data()返回的order列表作为参数
	"""
	new_data = [[]for i in range(0, len(data))]
	for index in range(len(order)):
		new_data[order[index]] = data[index]
	return new_data
 
def print_matrix(list):
	""" 
	以可重复的方式打印矩阵
	"""
	for i in range(0, len(list)):
		print (list[i])
 
def initialize_U(data, cluster_number):
	"""
	这个函数是隶属度矩阵U的每行加起来都为1. 此处需要一个全局变量MAX.
	"""
	global MAX
	U = []
	for i in range(0, len(data)):
		current = []
		rand_sum = 0.0
		for j in range(0, cluster_number):
			dummy = random.randint(1,int(MAX))
			current.append(dummy)
			rand_sum += dummy
		for j in range(0, cluster_number):
			current[j] = current[j] / rand_sum
		U.append(current)
	return U
 
def distance(point, center):
	"""
	该函数计算2点之间的距离（作为列表）。我们指欧几里德距离。闵可夫斯基距离
	"""
	if len(point) != len(center):
		return -1
	dummy = 0.0
	for i in range(0, len(point)):
		dummy += abs(point[i] - center[i]) ** 2
	return math.sqrt(dummy)
 
def end_conditon(U, U_old):
    """
	结束条件。当U矩阵随着连续迭代停止变化时，触发结束
	"""
    global Epsilon
    for i in range(0, len(U)):
	    for j in range(0, len(U[0])):
		    if abs(U[i][j] - U_old[i][j]) > Epsilon :
			    return False
    return True
 
def normalise_U(U):
	"""
	在聚类结束时使U模糊化。每个样本的隶属度最大的为1，其余为0
	"""
	for i in range(0, len(U)):
		maximum = max(U[i])
		for j in range(0, len(U[0])):
			if U[i][j] != maximum:
				U[i][j] = 0
			else:
				U[i][j] = 1
	return U
 
# m的最佳取值范围为[1.5，2.5]
def fuzzy(data, cluster_number, m):
	"""
	这是主函数，它将计算所需的聚类中心，并返回最终的归一化隶属矩阵U.
    参数是：簇数(cluster_number)和隶属度的因子(m)
	"""
	# 初始化隶属度矩阵U
	U = initialize_U(data, cluster_number)
	# print_matrix(U)
	# 循环更新U
	while (True):
		# 创建它的副本，以检查结束条件
		U_old = copy.deepcopy(U)
		# 计算聚类中心
		C = []
		for j in range(0, cluster_number):
			current_cluster_center = []
			for i in range(0, len(data[0])):
				dummy_sum_num = 0.0
				dummy_sum_dum = 0.0
				for k in range(0, len(data)):
    				# 分子
					dummy_sum_num += (U[k][j] ** m) * data[k][i]
					# 分母
					dummy_sum_dum += (U[k][j] ** m)
				# 第i列的聚类中心
				current_cluster_center.append(dummy_sum_num/dummy_sum_dum)
            # 第j簇的所有聚类中心
			C.append(current_cluster_center)
 
		# 创建一个距离向量, 用于计算U矩阵。
		distance_matrix =[]
		for i in range(0, len(data)):
			current = []
			for j in range(0, cluster_number):
				current.append(distance(data[i], C[j]))
			distance_matrix.append(current)
 
		# 更新U
		for j in range(0, cluster_number):	
			for i in range(0, len(data)):
				dummy = 0.0
				for k in range(0, cluster_number):
    				# 分母
					dummy += (distance_matrix[i][j ] / distance_matrix[i][k]) ** (2/(m-1))
				U[i][j] = 1 / dummy
 
		if end_conditon(U, U_old):
			print ("结束聚类")
			break
	print ("标准化 U")
	U = normalise_U(U)
	return U
 
def checker_iris(final_location):
    """
    和真实的聚类结果进行校验比对
    """
    right = 0.0
    for k in range(0, 3):
        checker =[0,0,0]
        for i in range(0, 50):
            for j in range(0, len(final_location[0])):
                if final_location[i + (50*k)][j] == 1:  #i+(50*k)表示 j表示第j类
                    checker[j] += 1  #checker分别统计每一类分类正确的个数    
        right += max(checker) #累加分类正确的个数
    print ('分类正确的个数是:',right)
    answer =  right / 150 * 100
    return "准确率：" + str(answer) +  "%"
 
if __name__ == '__main__':
	
	# 加载数据
	data = import_data_format_iris("iris.txt")
	# print_matrix(data)
 
	# 随机化数据
	data , order = randomize_data(data)
	# print_matrix(data)
 
	start = time.time()
	# 现在我们有一个名为data的列表，它只是数字
	# 我们还有另一个名为cluster_location的列表，它给出了正确的聚类结果位置
	# 调用模糊C均值函数
	final_location = fuzzy(data , 3 , 2)
 
	# 还原数据
	final_location = de_randomise_data(final_location, order)
#	print_matrix(final_location)
 
	# 准确度分析
	print (checker_iris(final_location))
	print ("用时：{0}".format(time.time() - start))

如果要用你自己的数据集做聚类：替换下面代码的data为你自己的数据集；自己写一个准确率的判断方法。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Mar 27 10:51:45 2019
模糊c聚类:https://blog.csdn.net/lyxleft/article/details/88964494
@author: youxinlin
"""
import copy
import math
import random
import time

global MAX # 用于初始化隶属度矩阵U
MAX = 10000.0

global Epsilon  # 结束条件
Epsilon = 0.0000001
 
def print_matrix(list):
	""" 
	以可重复的方式打印矩阵
	"""
	for i in range(0, len(list)):
		print (list[i])
 
def initialize_U(data, cluster_number):
	"""
	这个函数是隶属度矩阵U的每行加起来都为1. 此处需要一个全局变量MAX.
	"""
	global MAX
	U = []
	for i in range(0, len(data)):
		current = []
		rand_sum = 0.0
		for j in range(0, cluster_number):
			dummy = random.randint(1,int(MAX))
			current.append(dummy)
			rand_sum += dummy
		for j in range(0, cluster_number):
			current[j] = current[j] / rand_sum
		U.append(current)
	return U
 
def distance(point, center):
	"""
	该函数计算2点之间的距离（作为列表）。我们指欧几里德距离。闵可夫斯基距离
	"""
	if len(point) != len(center):
		return -1
	dummy = 0.0
	for i in range(0, len(point)):
		dummy += abs(point[i] - center[i]) ** 2
	return math.sqrt(dummy)
 
def end_conditon(U, U_old):
    """
	结束条件。当U矩阵随着连续迭代停止变化时，触发结束
	"""
    global Epsilon
    for i in range(0, len(U)):
	    for j in range(0, len(U[0])):
		    if abs(U[i][j] - U_old[i][j]) > Epsilon :
			    return False
    return True
 
def normalise_U(U):
	"""
	在聚类结束时使U模糊化。每个样本的隶属度最大的为1，其余为0
	"""
	for i in range(0, len(U)):
		maximum = max(U[i])
		for j in range(0, len(U[0])):
			if U[i][j] != maximum:
				U[i][j] = 0
			else:
				U[i][j] = 1
	return U
 

def fuzzy(data, cluster_number, m):
	"""
    这是主函数，它将计算所需的聚类中心，并返回最终的归一化隶属矩阵U.
    输入参数：簇数(cluster_number)、隶属度的因子(m)的最佳取值范围为[1.5，2.5]
	"""
	# 初始化隶属度矩阵U
	U = initialize_U(data, cluster_number)
	# print_matrix(U)
	# 循环更新U
	while (True):
		# 创建它的副本，以检查结束条件
		U_old = copy.deepcopy(U)
		# 计算聚类中心
		C = []
		for j in range(0, cluster_number):
			current_cluster_center = []
			for i in range(0, len(data[0])):
				dummy_sum_num = 0.0
				dummy_sum_dum = 0.0
				for k in range(0, len(data)):
    				# 分子
					dummy_sum_num += (U[k][j] ** m) * data[k][i]
					# 分母
					dummy_sum_dum += (U[k][j] ** m)
				# 第i列的聚类中心
				current_cluster_center.append(dummy_sum_num/dummy_sum_dum)
            # 第j簇的所有聚类中心
			C.append(current_cluster_center)
 
		# 创建一个距离向量, 用于计算U矩阵。
		distance_matrix =[]
		for i in range(0, len(data)):
			current = []
			for j in range(0, cluster_number):
				current.append(distance(data[i], C[j]))
			distance_matrix.append(current)
 
		# 更新U
		for j in range(0, cluster_number):	
			for i in range(0, len(data)):
				dummy = 0.0
				for k in range(0, cluster_number):
    				# 分母
					dummy += (distance_matrix[i][j ] / distance_matrix[i][k]) ** (2/(m-1))
				U[i][j] = 1 / dummy
 
		if end_conditon(U, U_old):
			print ("已完成聚类")
			break

	U = normalise_U(U)
	return U 
 
 
if __name__ == '__main__':
	data= [[6.1, 2.8, 4.7, 1.2], [5.1, 3.4, 1.5, 0.2], [6.0, 3.4, 4.5, 1.6], [4.6, 3.1, 1.5, 0.2], [6.7, 3.3, 5.7, 2.1], [7.2, 3.0, 5.8, 1.6], [6.7, 3.1, 4.4, 1.4], [6.4, 2.7, 5.3, 1.9], [4.8, 3.0, 1.4, 0.3], [7.9, 3.8, 6.4, 2.0], [5.2, 3.5, 1.5, 0.2], [5.9, 3.0, 5.1, 1.8], [5.7, 2.8, 4.1, 1.3], [6.8, 3.2, 5.9, 2.3], [5.4, 3.4, 1.5, 0.4], [5.4, 3.7, 1.5, 0.2], [6.6, 3.0, 4.4, 1.4], [5.1, 3.5, 1.4, 0.2], [6.0, 2.2, 4.0, 1.0], [7.7, 2.8, 6.7, 2.0], [6.3, 2.8, 5.1, 1.5], [7.4, 2.8, 6.1, 1.9], [5.5, 4.2, 1.4, 0.2], [5.7, 3.0, 4.2, 1.2], [5.5, 2.6, 4.4, 1.2], [5.2, 3.4, 1.4, 0.2], [4.9, 3.1, 1.5, 0.1], [4.6, 3.6, 1.0, 0.2], [4.6, 3.2, 1.4, 0.2], [5.8, 2.7, 3.9, 1.2], [5.0, 3.4, 1.5, 0.2], [6.1, 3.0, 4.6, 1.4], [4.7, 3.2, 1.6, 0.2], [6.7, 3.3, 5.7, 2.5], [6.5, 3.0, 5.8, 2.2], [5.4, 3.4, 1.7, 0.2], [5.8, 2.7, 5.1, 1.9], [5.4, 3.9, 1.3, 0.4], [5.3, 3.7, 1.5, 0.2], [6.1, 3.0, 4.9, 1.8], [7.2, 3.2, 6.0, 1.8], [5.5, 2.3, 4.0, 1.3], [5.7, 2.8, 4.5, 1.3], [4.9, 2.4, 3.3, 1.0], [5.4, 3.0, 4.5, 1.5], [5.0, 3.5, 1.6, 0.6], [5.2, 4.1, 1.5, 0.1], [5.8, 4.0, 1.2, 0.2], [5.4, 3.9, 1.7, 0.4], [6.5, 3.2, 5.1, 2.0], [5.5, 2.4, 3.7, 1.0], [5.0, 3.5, 1.3, 0.3], [6.3, 2.5, 5.0, 1.9], [6.9, 3.1, 4.9, 1.5], [6.2, 2.2, 4.5, 1.5], [6.3, 3.3, 4.7, 1.6], [6.4, 3.2, 4.5, 1.5], [4.7, 3.2, 1.3, 0.2], [5.5, 2.4, 3.8, 1.1], [5.0, 2.0, 3.5, 1.0], [4.4, 2.9, 1.4, 0.2], [4.8, 3.4, 1.9, 0.2], [6.3, 3.4, 5.6, 2.4], [5.5, 2.5, 4.0, 1.3], [5.7, 2.5, 5.0, 2.0], [6.5, 3.0, 5.2, 2.0], [6.7, 3.0, 5.0, 1.7], [5.2, 2.7, 3.9, 1.4], [6.9, 3.1, 5.1, 2.3], [7.2, 3.6, 6.1, 2.5], [4.8, 3.0, 1.4, 0.1], [6.3, 2.9, 5.6, 1.8], [5.1, 3.5, 1.4, 0.3], [6.9, 3.1, 5.4, 2.1], [5.6, 3.0, 4.1, 1.3], [7.7, 2.6, 6.9, 2.3], [6.4, 2.9, 4.3, 1.3], [5.8, 2.7, 4.1, 1.0], [6.1, 2.9, 4.7, 1.4], [5.7, 2.9, 4.2, 1.3], [6.2, 2.8, 4.8, 1.8], [4.8, 3.4, 1.6, 0.2], [5.6, 2.9, 3.6, 1.3], [6.7, 2.5, 5.8, 1.8], [5.0, 3.4, 1.6, 0.4], [6.3, 3.3, 6.0, 2.5], [5.1, 3.8, 1.9, 0.4], [6.6, 2.9, 4.6, 1.3], [5.1, 3.3, 1.7, 0.5], [6.3, 2.5, 4.9, 1.5], [6.4, 3.1, 5.5, 1.8], [6.2, 3.4, 5.4, 2.3], [6.7, 3.1, 5.6, 2.4], [4.6, 3.4, 1.4, 0.3], [5.5, 3.5, 1.3, 0.2], [5.6, 2.7, 4.2, 1.3], [5.6, 2.8, 4.9, 2.0], [6.2, 2.9, 4.3, 1.3], [7.0, 3.2, 4.7, 1.4], [5.0, 3.2, 1.2, 0.2], [4.3, 3.0, 1.1, 0.1], [7.7, 3.8, 6.7, 2.2], [5.6, 3.0, 4.5, 1.5], [5.8, 2.7, 5.1, 1.9], [5.8, 2.8, 5.1, 2.4], [4.9, 3.1, 1.5, 0.1], [5.7, 3.8, 1.7, 0.3], [7.1, 3.0, 5.9, 2.1], [5.1, 3.7, 1.5, 0.4], [6.3, 2.7, 4.9, 1.8], [6.7, 3.0, 5.2, 2.3], [5.1, 2.5, 3.0, 1.1], [7.6, 3.0, 6.6, 2.1], [4.5, 2.3, 1.3, 0.3], [4.9, 3.0, 1.4, 0.2], [6.5, 2.8, 4.6, 1.5], [5.7, 4.4, 1.5, 0.4], [6.8, 3.0, 5.5, 2.1], [4.9, 2.5, 4.5, 1.7], [5.1, 3.8, 1.5, 0.3], [6.5, 3.0, 5.5, 1.8], [5.7, 2.6, 3.5, 1.0], [5.1, 3.8, 1.6, 0.2], [5.9, 3.0, 4.2, 1.5], [6.4, 3.2, 5.3, 2.3], [4.4, 3.0, 1.3, 0.2], [6.1, 2.8, 4.0, 1.3], [6.3, 2.3, 4.4, 1.3], [5.0, 2.3, 3.3, 1.0], [5.0, 3.6, 1.4, 0.2], [5.9, 3.2, 4.8, 1.8], [6.4, 2.8, 5.6, 2.2], [6.1, 2.6, 5.6, 1.4], [5.6, 2.5, 3.9, 1.1], [6.0, 2.7, 5.1, 1.6], [6.0, 3.0, 4.8, 1.8], [6.4, 2.8, 5.6, 2.1], [6.0, 2.9, 4.5, 1.5], [5.8, 2.6, 4.0, 1.2], [7.7, 3.0, 6.1, 2.3], [5.0, 3.3, 1.4, 0.2], [6.9, 3.2, 5.7, 2.3], [6.8, 2.8, 4.8, 1.4], [4.8, 3.1, 1.6, 0.2], [6.7, 3.1, 4.7, 1.5], [4.9, 3.1, 1.5, 0.1], [7.3, 2.9, 6.3, 1.8], [4.4, 3.2, 1.3, 0.2], [6.0, 2.2, 5.0, 1.5], [5.0, 3.0, 1.6, 0.2]]
	start = time.time()

	# 调用模糊C均值函数
	res_U = fuzzy(data , 3 , 2)
	# 计算准确率
	print ("用时：{0}".format(time.time() - start))

参考资料

J. C. Dunn (1973): "A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters", Journal of Cybernetics 3: 32-57

J. C. Bezdek (1981): "Pattern Recognition with Fuzzy Objective Function Algoritms", Plenum Press, New York

Pang-Ning Tan, et al.数据挖掘导论

http://home.deib.polimi.it/matteucc/Clustering/tutorial_html/cmeans.html

https://blog.csdn.net/zwqhehe/article/details/75174918

 

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Fuzzy C-Means（模糊C均值聚类）算法原理详解与python实现 的相关文章

  • Python 学习笔记——入门

    文章目录 Python 是什么一 推荐的教程二 这篇学习笔记适合什么人三 环境1 操作系统对于 Windows对于 Ubuntu对于其他操作系统 2 Python对于 Windows安装步骤1 下载2 安装 测试是否成功安装退出 Pytho

  • CF 1166A Silent Classroom

    文章目录 传送门题目大意思路别人的思路参考代码Python 学习笔记 传送门 题目大意 有 n n 100

  • SHGetKnownFolderPath function

    原文 SHGetKnownFolderPath 通过一个 KNOWNFOLDERID 标志获取对应已知文件夹的完整路径 Retrieves the full path of a known folder identified by the

  • WM_DPICHANGED message

    原文 WM DPICHANGED message 当窗口的 DPI 改变时将收到此消息 DPI 是窗口的缩放比例 有多种情况会导致 DPI 改变 xff0c 如下表列出 xff1a 窗口被移动到有不同 DPI 的显示器 窗口所在显示器的 D

  • WSL运行python程序关于路径的坑

    安装了wsl xff08 Windows下的Linux子系统 xff09 xff0c 跑python代码时 xff0c 发现路径有问题 总结来说 xff0c 如果是跑linux里的代码 xff0c 那么其中的绝对路径就按linux的地址解析

  • 【基础编程题】Java基础====键盘输入学生成绩，计算后按总分高低顺序存入磁盘文件txt

    要求 xff1a 有五个学生 xff0c 每个学生有3门课程的成绩从键盘输入以上数据 xff08 包括姓名 xff0c 三门课成绩 xff09 输入的格式 xff1a 如 xff1a zhangsan 30 40 60计算出总成绩 xff0

  • MySQL 配置文件位置及命名。

    MySQL 配置文件位置及命名 使用 mysqladmin 或 mysql xff0c 会提示 MySQL 加载配置文件的顺序及文件命名规范 span class token keyword Default span options are

  • Codeforces 1419B. Stairs 递归

    Codeforces 1419B Stairs 递归 原题链接https codeforces com problemset problem 1419 B 样例 输入 5 2 1 49 5 20 50 6 20 50 5 3 8 9 13

  • dos中定义变量与引用变量以及四则运算

    在dos中使用set定义变量 xff1a set a 61 8 注意等号两边没有空格 引用变量如 xff1a echo a 将打印a的值 dos中要使用算术运算 xff0c 需要使用 set 命令 xff1a set a val 61 3

  • Python将计算结果拷贝至粘贴板

    前言 xff1a 我们知道在使用ctrl 43 c复制文字时 xff0c 实际是将文字复制到了粘贴板中 xff08 内存 xff09 xff0c 而在实际应用中 xff0c 除了将Python的计算结果打印外 xff0c 有时还想进行自动复

  • Java反射——通过Java反射机制设置属性值

    本示例使用Java反射机制分别设置当前类的private public属性以及其父类的private属性来说明如何通过Java反射机制设置属性值 xff08 注 xff1a 设置继承的父类属性时 xff0c 无法通过当前类的Class对象直

  • 7-9 选择法排序之过程 (15 分)

    7 9 选择法排序之过程 15 分 本题要求使用选择法排序 xff0c 将给定的n个整数从小到大排序后输出 xff0c 并输出排序过程中每一步的中间结果 选择排序的算法步骤如下 xff1a 第0步 xff1a 在未排序的n个数 xff08

  • Debian配置清华源

    确定debian的系统版本 plc 64 debian cat etc os release PRETTY NAME 61 34 Debian GNU Linux 9 stretch 34 NAME 61 34 Debian GNU Lin

  • AAC音频编码格式介绍

    一 概述及分类 AAC Advanced Audio Coding 的缩写 xff0c 中文称为 高级音频编码 xff0c 被手机界称为 21世纪数据压缩方式 xff0c AAC所采用的运算方式是与MP3的运算有所不同 xff0c AAC同

  • Ubuntu系统失败之----安装U盘不能存放其它文件

    Ubuntu安装失败的经验贴 背景 xff1a 笔者在数月之前制作了一个Ubuntu 14 4系统安装盘 xff08 当时把U盘格式化 制作了引导并且拷贝了镜像 xff09 U盘的特点是除了系统相关文件之外没有其它任何文件 当时在三台联想笔

  • 结构体sizeof不想字节对齐

    问题描述 xff1a 笔者在做一个项目 xff1a 硬件要访问内存中按照Spec格式定义 的一段数据包 在C语言中一般使用结构体初始化这个数据包 xff0c 因为可以方便配置各个字段 但结构体默认需要字节对齐的 xff08 sizeof和实

  • C/C++语言static修饰函数的作用

    描述 xff1a 在C C 43 43 语言程序中 xff0c 特别是的大型程序 xff0c 函数名前往往用static关键词修饰 作用 xff1a 主要的作用是避免命名冲突 static函数与一般函数作用域不同 xff0c 仅在本文件有效

  • ubuntu16.04升级18.04(再次作死)

    继上次升级glibc版本作了一次大死后 xff0c 手又痒了 xff0c 又觉得我可以了 来继续升级ubuntu16 04升级到 ubuntu18 04 最主要的原因是ubuntu自带的python只到了3 5的版本 而我需要python3

  • 初始C语言——统计字符串中的字母，数字和其他符号 的个数

    define CRT SECURE NO WARNINGS 1 防止visual studio2013以上版本scanf报错 xff0c vc6 0环境可忽略 include lt stdio h gt int main int a 61

  • Linux下开发调试中大型C语言代码-如何提高效率

    背景 xff1a 在Linux下开发中大型C语言程序 xff08 包括编写 编译调试等步骤 xff09 时 xff0c 尤其大部分代码都是原创的情况下 以下的经验往往能提高调试效率 经验 xff1a xff08 1 xff09 Linux命

随机推荐

  • 《C语言中分配了动态内存后一定要释放吗？》

    问 xff1a 比如main函数里有一句 malloc 后面没有free 1 那么当main结束后 xff0c 动态分配的内存不会随之释放吗 xff1f 2 如果程序结束能自动释放 xff0c 那么还加上free xff08 xff09 x

  • Qemu使用心得

    使用Qemu的心得体会如下 xff1a xff08 1 xff09 在QEMU源码中增加自己的 c实现 xff0c 编译后出现很多个错误如 xff1a error storage class specified for parameter

  • 转载：malloc和free底层实现

    转载 xff1a malloc和free底层实现 内存管理内幕 Linux内存管理 xff1a Malloc 本文引用了下面这篇文章 xff0c 读完下面 xff0c 应该读下上面两篇文章 xff0c 其中 xff0c 内存管理内幕 提供了

  • qemu tcg代码执行流程

    转自 xff1a http blog csdn net alloc7 article details 7719823 一 qemu简介 qemu是使用动态二进制翻译的cpu模拟器 xff0c 它支持两种运行模式 xff1a 全系统模拟和用户

  • c语言如何调用c++(本文从qemu开发中总结)

    背景 xff1a 有时候一个工程中有c语言编写的代码 c xff0c 也有c 43 43 cpp 编写的 xff0c 分别用 xff43 语言编译器 xff08 这里指 xff47 xff43 xff43 xff09 和 xff43 xff

  • c++常错语法

    1 new T 代表创建一个T类的对象指针 xff0c new T 标识创建T类对象数组指针 2 template模板类只能把成员函数都定义在 h中 xff0c 分开 h和 cpp会报链接错误 3 类A 的成员变量包含B的对象B b xff

  • UEFI EDK2开发环境设置关键点/修改环境变量

    1 问题描述 Linux下当修改了已经编译过的EDK2工程顶层路径后 进入工程顶层路径source edksetup sh会报错 2 解决步骤 有一个隐藏问题非常容易被忽视 那就是EDK2工程的环境变量可能还是原来的旧的 这时候 1 进入工

  • linux静态库.a使用常见错误

    在linux中如果一个程序需要用到 a 有以下几点需要注意 1 如果x o与y o中用到了静态xx a中的函数 不能用gcc xx a o test x o y o这种方式编译 会提示那些函数undefined 正确的做法是gcc o te

  • C/C++多线程常见问题

    1 问题 1 1 创建线程后是否立马开始并行执行 答 主线程创建了子线程之后 后者并不是立即就开始运行了 至少在Linux操作系统下 1 子线程和主线程运行在一个core上 那还需要等待主线程交出core控制权 可能是时间片耗尽 2 子线程

  • 2020 年百度之星·程序设计大赛 - 初赛二 题解

    废话 丑话说在前头 xff0c T8我不会 xff08 没错是指我会出丑 xff09 T1 既然要玩尽可能多轮 xff0c 那么每轮投入的钱就要最少 xff0c 也就是 m m m 元 xff0c 那么可以算出每轮游戏会亏损

  • QEMU内存管理

    QEMU内存管理 1 QEMU中管理的Memory有 xff1a 普通的RAM MMIO 内存控制器 将物理内存动态的映射到不同的虚拟地址空间 2 QEMU的Memory是以一个MemoryRegin为节点组成的非循环图的形式组织的 叶子节

  • Matlab实现基于二维伽马函数的光照不均匀图像自适应校正算法

    Matlab程序 xff1a 基于二维伽马函数的光照不均匀图像自适应校正算法 clc close all tic im 61 imread 39 你的图片 jpg 39 figure imshow im title 39 原图 39 h s

  • SCI回复评审意见模板

    一般反馈回来修改时 xff0c 要给编辑重新写一封cover letter xff0c 表示尊重与感谢 xff0c 范文如下 句式大家可以依照自己的习惯表达修改 xff0c 多参考他人经验 xff09 Dear XX xff08 给你回信的

  • 毕业快乐 —— 写于2020年3月13日

    很久没有经营这个博客了 今天来写点什么罢 2020的春天 xff0c 由于猝不及防的疫情 xff0c 参加了一场特殊的毕业答辩 线上答辩形式 没有西装和鲜花 xff0c 似乎缺少了一些仪式感 但毕业似乎真真切切就是一件水到渠成的事情 xff

  • Mac连上WIFI但是无法上网的3种解决方案

    一般我们最先会认为是DNS问题 xff0c 你可以试下用ip访问一个服务器 xff08 网站 xff09 看下行不行 xff0c 如果也不行那就应该不是DNS的问题了 或者改变一下DNS xff0c 如114 xff0c 或者自己内网要求的

  • 简单粗暴理解支持向量机（SVM）及其MATLAB实例

    目录 SVM概述 SVM的改进 xff1a 解决回归拟合问题的SVR 多分类的SVM QP求解 SVM的MATLAB实现 xff1a Libsvm 实例 用SVM分类 实例 用SVM回归 SVM概述 SVM已经是非常流行 大家都有所耳闻的技

  • 极限学习机(Extreme Learning Machine, ELM)原理详解和MATLAB实现

    目录 引言 极限学习机原理 MATLAB中重点函数解读 极限学习机的MATLAB实践 引言 极限学习机不是一个新的东西 xff0c 只是在算法 xff08 方法 xff09 上有新的内容 在神经网络结构上 xff0c 就是一个前向传播的神经

  • 粒子群优化算法（PSO）简介及MATLAB实现

    目录 粒子群优化算法概述 PSO算法步骤 PSO xff08 粒子群优化算法 xff09 与GA xff08 遗传算法 xff09 对比 PSO的MATLAB实现 粒子群优化算法概述 粒子群优化 PSO particle swarm opt

  • 结构化概率模型

    机器学习的算法经常会涉及到在非常多的随机变量上的概率分布 通常 xff0c 这些概率分布涉及到的直接相互作用都是介于非常少的变量之间的 使用单个函数来描述整个联合概率分布是非常低效的 无论是计算上还是统计上 我们可以把概率分布分解成许多因子

  • Fuzzy C-Means（模糊C均值聚类）算法原理详解与python实现

    目录 模糊理论 Fuzzy C Means算法原理 算法步骤 python实现 参考资料 本文采用数据集为iris 将iris txt放在程序的同一文件夹下 请先自行下载好 模糊理论 模糊控制是自动化控制领域的一项经典方法 其原理则是模糊数

热门标签