算法设计课程项目 工厂与顾客分配策略

最新推荐文章于 2021-05-25 08:43:03 发布
最新推荐文章于 2021-05-25 08:43:03 发布
阅读量192 收藏 1
点赞数
分类专栏： 学习笔记 算法练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37977536/article/details/85394736
版权

项目背景：

有m个工厂，每个工厂开设都有一个固定的费用open_cost及容量capacity，有n个客户，每个客户有一定的需求量demand，每个客户可以分配给任一个工厂且有相应的分配费用assign_cost，但是要求分配给每个工厂的客户总需求量不能超过工厂的容量。

目标：

求一个合理的分配策略，使得总的费用尽可能小。

测试样例数据处理：

因为测试样例数据较多，且他们的格式不统一，所以在编写算法前，我先对测试样例数据进行读取处理，把它们都用变量来表示。

数据处理代码如下：

void split(const string &s, vector<string> &v, const string &p) { //进行字符串分割
	string::size_type pos1, pos2;
	pos2 = s.find(p);
	pos1 = 0;
	while(string::npos != pos2) {
		v.push_back(s.substr(pos1,pos2-pos1));
		
		pos1=pos2 + p.size();
		pos2=s.find(p, pos1);
	}
	if(pos1 != s.length())
		v.push_back(s.substr(pos1));
}
//把测试数据用cap， fcost，demand， relcost 数组存，后面再把这些数组的数据放到算法所用的结构体中
void DealData(vector<int> &cap, vector<int> &fcost, 
			vector<int> &demand, vector<vector<int> > &relcost) {
	int j=1,k=0;	
	int fnum=1 ,cnum;
	

	string s;
	stringstream ss;
	
	ifstream myfile("Instances\\p13");
	
	if(!myfile.is_open()){
		cout << "open failed!";
	}
	
	while(getline(myfile, s)) {
		ss.clear();
		ss.str("");
		vector<string> v;
		if(j<=fnum+1)
			split(s,v," ");
		else if (j>fnum+1)
			split(s,v,".");
		if(j==1){
			ss << v[0];
			ss >> fnum;
			ss.clear();
			ss.str("");
			ss << v[1];
			ss >> cnum;
			if(cnum>201 || cnum<0){
				ss.clear();
				ss.str("");
				ss << v[2];
				ss >> cnum;
			}
		}
		else if(j>1 && j <= fnum+1) {
			int c,f;
			ss << v[0];
			ss >> c;
			ss.clear();
			ss.str("");
			ss << v[1];
			ss >> f;
			if(f<0 || f>3000){
				ss.clear();
				ss.str("");
				ss << v[2];
				ss >> f;
			}
			cap.push_back(c);
			fcost.push_back(f);		
		}
		else if(j >fnum+1 && j <= cnum/10 + fnum+1) {
			int d;
			for(int i=0; i<10; i++) {
				ss << v[i];
				ss >> d;
				ss.clear();
				ss.str("");
				demand.push_back(d);
			}
		}

		else if (j > cnum/10 + fnum+1 && j < (cnum/10)+fnum+2+(cnum*(fnum/10))){
			int r;	
			relcost.push_back(vector<int>());
			for(int i=0; i<10; i++) {	
				ss << v[i];
				ss >> r;
				relcost[k].push_back(r);
				ss.clear();
				ss.str("");
			}
			k++;
		}
		j++;
	}
	myfile.close();
	
}

 

算法1：模拟退火算法

模拟退火算法的实质是 通过多次尝试修改每个顾客从m个工厂中选择的工厂，如果找到则选择该方案，如果找到的解比原来的更差，则以一定的概率来接受该解，并且在每次尝试后，接受更差解的概率会逐渐降低，最终不会再接受更差解。因此找到的总的费用最小的分配策略实质还是一个局部最优解。但是模拟退火算法是有一定的可能性跳出某些局部最优解，从而找到更大范围内的一个局部最优解，甚至有可能找到一个全局最优解（虽然这个可能性非常非常小）。

 

代码如下：

#include <iostream>
#include <algorithm>
#include <sstream>
#include <fstream>
#include <time.h> 
#include <math.h>
#include <vector>

#define M 50		// 最大工厂数量 
#define N 250		//最大客户数量 
#define T 3000		//初始温度 
#define EPS 1e-8	//终止温度 
#define DELTA 0.97	//温度衰减率 
#define OLOOP 20   //外循环 20次 
#define ILOOP 100  //内循环 100次 
#define LIMIT 1000	//概率选择上限 

using namespace std;

//定义分配策略结构体 
struct Assign {
	int fact_state[M]; 			// 工厂状态，0为关闭，1为打开 
	int assign_fact[N];			// 每个顾客分配的工厂 
	int total_cost;				//总的费用 
};

//定义顾客结构体 
struct Customer {
	int demand;					// 顾客的需求量 
	int ass_cost[M];			// 顾客分配给各工厂对应的分配费用 
};
 // 定义工厂结构体 
struct Factory {
	int capacity;				// 工厂容量 
	int last_cap;				// 工厂的剩余容量 
	int open_cost;				// 开厂费用 
	int my_customer;			// 工厂分配的客户数 
};

//初始化最佳分配策略 
Assign bestAssign = {
	 {0},
	 {0},
	 0
};

Customer C[N];			//顾客 
Factory F[M]; 			// 工厂 
int nCase;				// 测试次数

//把测试样例数据输入工厂结构体中 
void InputFactory(vector<int> cap, vector<int> fcost, int &m) {
	int i;
	for (i=0; i!= cap.size(); i++) {
		F[i].capacity = cap[i];
		F[i].last_cap = F[i].capacity; 
		F[i].open_cost = fcost[i];
		F[i].my_customer = 0;
	}
	m = i;
}

//把测试样例数据输入顾客结构体中 
void InputCustomer(vector<int> demand, vector<vector<int> > asscost ,int &n) {
	int i;
	for (i=0; i != demand.size(); i++) {
		C[i].demand = demand[i];
		for(int j = 0; j != asscost[i].size(); j++) {
			C[i].ass_cost[j] = asscost[i][j];
		}
	}
	n = i;
}
//先初始化一个分配方案，初始分配策略是按工厂号从前往后分配，前一个工厂容量不够才分配给后一个工厂 
void Init(int m, int n) {			
	nCase = 0;
//	bestAssign.total_cost = 0;
	int t_demand=0;
//	int j=0;
	//给每个客户选一个工厂，按工厂号从小到大选 
	for(int i = 0; i < n; i++) {
		for(int j=0; j<m; j++) {
			if(F[j].last_cap >= C[i].demand) {
				bestAssign.assign_fact[i] = j;					//对顾客分配工厂 
				F[j].last_cap -= C[i].demand;
				F[j].my_customer++;
				if(bestAssign.fact_state[j] == 0) {				//更改工厂状态 
					bestAssign.fact_state[j] = 1;
					bestAssign.total_cost += F[j].open_cost  + C[i].ass_cost[j];
				} else {
					bestAssign.total_cost += C[i].ass_cost[j];
				}
				break;
			}
		}
	}
}

//打印结果，总共三行，第一行是总的费用、第二行是工厂的状态（1为打开，0为关闭）
//第三行是每个顾客分配的工厂号 
void Print(Assign a, int m, int n) {
	cout << a.total_cost << endl;
	for(int i=0; i<m-1; i++) {
		cout << a.fact_state[i] << " ";
	}
	cout << a.fact_state[m-1] << endl;
	
	for(int i=0; i<n-1; i++) {
		cout << a.assign_fact[i] << " ";
	}
	cout << a.assign_fact[n-1] << endl;
} 

//更新分配方案，更新策略是从所有工厂中随机选一个新工厂，再随机选一个顾客，用新工厂替换该顾客所分配的工厂 
//
Assign GetNext(Assign a, int m, int n) {
	Assign ans = a;
	int fnum = (int) (m * (rand() / (RAND_MAX + 1.0)));
	int cnum = (int) (n * (rand() / (RAND_MAX + 1.0)));
	while(fnum == ans.assign_fact[cnum] || F[fnum].last_cap < C[cnum].demand) {	//让随机选出的新工厂满足顾客需求大于工厂剩余容量的条件 
		fnum = (int) (m * (rand() / (RAND_MAX + 1.0)));
	}
	
	F[ans.assign_fact[cnum]].last_cap += C[cnum].demand;		//处理旧工厂
	if ((--F[ans.assign_fact[cnum]].my_customer) == 0) {		//处理旧工厂贡献的cost 
		ans.fact_state[ans.assign_fact[cnum]] = 0;				//当旧工厂没有分配客户时，关闭工厂 
		ans.total_cost -= F[ans.assign_fact[cnum]].open_cost;
	}
	ans.total_cost -= C[cnum].ass_cost[ans.assign_fact[cnum]];
	
	ans.assign_fact[cnum] = fnum;								//分配新工厂 
	F[fnum].last_cap -= C[cnum].demand;							//处理新工厂 
	F[fnum].my_customer++;
	if (ans.fact_state[fnum] == 0) {							//更新cost 
		ans.fact_state[fnum] = 1;
		ans.total_cost += F[fnum].open_cost + C[cnum].ass_cost[fnum]; 
	} else {
		ans.total_cost += C[cnum].ass_cost[fnum];
	}
	nCase++;
	return ans;
}

//退火算法，  
void SA(int m, int n) {
	int P_L = 0;
	int P_F = 0;
	double t = T;
	srand((unsigned)(time(NULL)));
	Assign curAssign = bestAssign;
	Assign newAssign = bestAssign;
	
	while(1) {									//外循环，更新参数t，模拟退火过程 
		for(int i = 0; i < ILOOP; i++) {		//内循环，寻找在一定温度下最优值 
			newAssign = GetNext(curAssign, m, n);
			double dE = newAssign.total_cost - curAssign.total_cost;
			if (dE < 0) {						//找到更优值则更新分配方案 
				curAssign = newAssign;
				P_L = 0;
				P_L = 0;
			} else {				//如果找到的解更差，则以一定概率接受该解，接受概率会越来越小 
				double rd = rand() / (RAND_MAX + 1.0);
				if (exp(dE / t) > rd && exp(dE / t) < 1)
					curAssign = newAssign;
				P_L++;
			}
			if (P_L > LIMIT) { //选择次数超过上限则放弃 
				P_F++;
				break;
			}
		}
		if (curAssign.total_cost < bestAssign.total_cost)
			bestAssign = curAssign;
		if (P_F > OLOOP || t < EPS) {
			break;
		}
		t *= DELTA;
	}
}

int main() {
	int m, n;
	vector<int> cap, fcost, demand;
	vector<vector<int> > relcost;
	DealData(cap, fcost, demand, relcost);
	InputFactory(cap,fcost,m);
	InputCustomer(demand, relcost,n);
	Init(m,n);
	SA(m,n);
	Print(bestAssign,m,n);
	return 0;
}

 

测试结果：

p1

p2

p3

p4

p5

p6-p10

 

 

p20-25

 

 

p30-p34

 

 

p60-p63

 

 

p68-p71

 

 

算法2： 贪心算法：

首先是对每个工厂选择分配费用最小的客户，因为最优解肯定包含最小分配费用的工厂的(此处有个问题是这样处理每个工厂最终都打开)。然后对剩余未分配工厂的顾客选择分配费用最小的工厂。

#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>

#define M 30	// 最大工厂数量 
#define N 300	// 最大的顾客数 

using namespace std;

//定义分配策略结构体 
struct Assign {
	int fact_state[M];		// 工厂状态，0为关闭，1为打开 
	int assign_fact[N];		// 每个顾客分配的工厂 
	int total_cost;			//总的费用 
};

//定义顾客结构体 
struct Customer {
	int demand;			// 顾客的需求量 
	int ass_cost[M];	// 顾客分配给各工厂对应的分配费用 
	bool assigned;		//顾客的工厂分配标志， 1代表已分配 
};

// 定义工厂结构体
struct Factory {
	int capacity;		// 工厂容量 
	int last_cap;		// 工厂的剩余容量 
	int open_cost;		// 开厂费用 
	int my_customer;	// 工厂分配的客户数 
};

//初始化最佳分配策略
Assign bestAssign = {
	 {0},
	 {0},
	 0
};

Customer C[N];
Factory F[M]; 

//进行字符串分割 
void split(const string &s, vector<string> &v, const string &p) {
	string::size_type pos1, pos2;
	pos2 = s.find(p);
	pos1 = 0;
	while(string::npos != pos2) {
		v.push_back(s.substr(pos1,pos2-pos1));
		
		pos1=pos2 + p.size();
		pos2=s.find(p, pos1);
	}
	if(pos1 != s.length())
		v.push_back(s.substr(pos1));
}

//把测试样例数据输入工厂结构体中
void InputFactory(vector<int> cap, vector<int> fcost, int &m) {
	int i;
	for (i=0; i!= cap.size(); i++) {
		F[i].capacity = cap[i];
		F[i].last_cap = F[i].capacity; 
		F[i].open_cost = fcost[i];
		F[i].my_customer = 0;
	}
//	m = i;
}

//把测试样例数据输入顾客结构体中
void InputCustomer(vector<int> demand, vector<vector<int> > asscost, int &n) {
	int i;
	for (i=0; i != demand.size(); i++) {
		C[i].demand = demand[i];
		C[i].assigned = 0; 
		for(int j = 0; j != asscost[i].size(); j++) {
			C[i].ass_cost[j] = asscost[i][j];
		}
	}
//	n = i;
}

//打印结果，总共三行，第一行是总的费用、第二行是工厂的状态（1为打开，0为关闭）
//第三行是每个顾客分配的工厂号 
void Print(Assign a, int m, int n) {
	cout << a.total_cost << endl;
	for(int i=0; i<m-1; i++) {
		cout << a.fact_state[i] << " ";
	}
	cout << a.fact_state[m-1] << endl;
	
	for(int i=0; i<n-1; i++) {
		cout << a.assign_fact[i] << " ";
	}
	cout << a.assign_fact[n-1] << endl;
} 

//贪心算法 先找出顾客中分配给各工厂所需分配费用最小的那位顾客
//然后在剩余的顾客中寻找分配费用最小的那个工厂
void Greedy(vector<vector<int> > asscost, int m, int n) {
	int min, t;
	
	for(int i=0; i<m; i++) {				//先找出顾客中分配给各工厂所需分配费用最小的那位顾客 
		t=0;
		min = asscost[0][i];
		for(int j = 1; j<n; j++) {
			if (asscost[j][i] < min) {
				min = asscost[j][i];
				t = j;			//配费用最小的顾客 
			}
		}
		if (C[t].demand <= F[i].last_cap) {		//工厂须满足顾客需求大于工厂剩余容量的条件 
			C[t].assigned = 1;
			bestAssign.assign_fact[t] = i;
			bestAssign.fact_state[i] = 1;
			bestAssign.total_cost += F[i].open_cost + C[t].ass_cost[i];
			F[i].my_customer++;
			F[i].last_cap -= C[t].demand;
		}
	}
	
	for(int i=0; i<n; i++) {		//在剩余的顾客中寻找分配费用最小的那个工厂 
		if (!C[i].assigned) {
			t=0;
			min = asscost[i][0];
			for(int j=1; j<m; j++) {
				if (asscost[i][j] < min) {
					min = asscost[i][j];
					t = j;		//配费用最小的工厂 
				}
			}
			if (C[i].demand <= F[t].last_cap) {		///工厂须满足顾客需求大于工厂剩余容量的条件  
				C[i].assigned = 1;
				bestAssign.assign_fact[i] = t;
				if(bestAssign.fact_state[t] == 0){
					bestAssign.fact_state[t] = 1;
					bestAssign.total_cost += F[t].open_cost + C[i].ass_cost[t];
				} else {
					bestAssign.total_cost += C[i].ass_cost[t];
				}
				F[t].my_customer++;
				F[t].last_cap -= C[i].demand;
			}
		}
	} 
}

void DealData(vector<int> &cap, vector<int> &fcost, 
			vector<int> &demand, vector<vector<int> > &relcost, int &fnum, int &cnum)  {
	ifstream myfile("Instances\\p27");
	int j=1,k=0, l=0;
	fnum=1;
	if(!myfile.is_open()){
		cout << "open failed!";
	}
	
	string s;
	stringstream ss;
	
	while(getline(myfile, s)) {
		ss.clear();
		ss.str("");
		vector<string> v;
		if (j<=fnum+1){
			split(s,v," ");	
			if(j==1){
				ss << v[0];
				ss >> fnum;
				ss.clear();
				ss.str("");
				ss << v[1];
				ss >> cnum;
				if(cnum>201|| cnum<0){
					ss.clear();
					ss.str("");
					ss << v[2];
					ss >> cnum;
				} 
			}
			else if(j>1 && j <= fnum+1) {
				int c,f;
				ss << v[0];
				ss >> c;
				ss.clear();
				ss.str("");
				ss << v[1];
				ss >> f;
				if(f<0 || f>2500){
					ss.clear();
					ss.str("");
					ss << v[2];
					ss >> f;
				}
				cap.push_back(c);
				fcost.push_back(f);
			}
			
		} 
		else if(j >fnum+1 && j <= cnum/10 + fnum+1) {
			int d;
			split(s,v,".");
			for(int i=0; i<10; i++) {
				ss << v[i];
				ss >> d;
				ss.clear();
				ss.str("");
				demand.push_back(d);
			}
			
		}
		else if( j > cnum/10 + fnum+1 && j <= cnum*(fnum/10) + cnum/10 + fnum+1) {
			int d;
			split(s,v,".");
			if (k==0)
				relcost.push_back(vector<int>());
			for(int i=0; i<10; i++) {
				ss << v[i];
				ss >> d;
				ss.clear();
				ss.str("");
				relcost[l].push_back(d);
			}
			k++;
			if(k== fnum/10){
				k=0;
				l++;
			}
		
		}
		j++;
	}
	myfile.close();
}
int main() {
	int fnum, cnum;
	vector<int> cap, fcost, demand;
	vector<vector<int> > relcost;

	DealData(cap, fcost, demand, relcost, fnum, cnum);
	InputFactory(cap,fcost,fnum);
	InputCustomer(demand, relcost ,cnum);
	Greedy(relcost, fnum, cnum);
	Print(bestAssign,fnum, cnum);
	
	return 0;
}

 

测试结果：

p1-p10:

 

 

 

p13-p15

p23-p26

p31-p33

 

p45-p47

 

p53-p55

p56

第二个贪心算法发现在测试前25个测试样例的时候cost在10000左右，呈现稳定递增态势。

但是在第25个样例开始cost突降到6000左右，也呈现稳定递增态势。

在第56个测试样例往后，没有输出

Vinyao
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Cesium批量显示三维模型(gltf格式)和一些心得体会——接上篇
zxzfcsu的博客
07-08 1万+
上篇是关于osgb--&gt;gltf的内容，如有需要，请自行查阅。如果想了解gltf文件批量显示的问题，可以直接看本篇内容。一、文件组织结构       在完成了上一篇中一堆操作之后，我们得到了非常多(看你的项目)的gltf模型以及存储这些模型参数的json文件，我把json文件再贴出来，并说一下是什么意思。[{"ModelName":"point1", "LocationX":"37.1518...
【编译原理】LALR(1)语法分析方法（c++实现）
qq_43417265的博客
05-29 5450
LALR(1)文法的判断，拓广文法，构建DFA，建立LALR分析表，最后对输入串进行文法分析
给工厂分配销售组织/分销渠道
少年休闲海
06-14 4298
一．说明 在SAP系统做销售，需将销售组织/分销渠道的组合与工厂进行关联，其中前者的组合用于销售业务，而后者（工厂）用于交货。销售组织/分销渠道组合下可以有多个工厂；一个工厂可以分配给多个销售组织/分销渠道组合。 此项配置决定了工厂允许的销售方式，例如某些工厂只能零售；而某些工厂既可以零售又可以批发（需分配两组销售组织/分销渠道组合）。 分配方式有两种类型： 销售组织、
字符串分割split：将一个字符串通过指定的分隔符分割成若干子串
m0_37357063的博客
08-13 9202
1.先来看一下JAVA里的字符串分割代码： 首先从标准输入得到一行数据，数据之间用逗号,分隔。 将这行数据存为字符串，然后调用字符串分割函数split将其分割成字符数组String [] strRating，在定义一个整型数组，将字符数组转换成整数数组： import java.util.Arrays; import java.util.Scanner; public class Ma...
JAVA按金额平均分配任务量，随机分配，指定数量分配算法实例
热门推荐
zxchenpeng的博客
01-11 1万+
按金额平均分配任务量算法实例需求背景思路分析代码实现 需求背景 需要批量分配订单给人员，尽量保证分配到每个人的订单金额相近。 思路分析 比如100个任务,每个任务ID和金额及号为(T100,100)…(t1,1)。第一轮分配先取最大的任务金额的分配给User1，即user1拥有T100，user2分配到T99，user3分配到T98。第二轮分配最小值，User1分配T1，User2分配T2，Use...
生产者与消费者算法模拟课程设计.doc
07-03
本课程设计的主要目标是设计并实现一个生产者与消费者算法模拟系统，通过该系统来模拟生产者和消费者之间的资源分配和竞争关系。系统将模拟多个生产者和消费者之间的交互，根据系统资源的种类和数目、系统作业或进程...
计算机操作系统课程设计银行家算法的设计与实现
05-16
计算机操作系统课程设计银行家算法的设计与实现 计算机操作系统课程设计报告题目中的银行家算法的设计与实现是本次课程设计的主要内容。该设计的目的是模拟实现资源分配，避免死锁的发生。银行家算法是避免死锁的一...
算法分析与设计课程设计
09-11
在这个“算法分析与设计课程设计”中，我们将深入探讨算法的基本概念、设计策略以及性能评估。 首先，我们要理解什么是算法。算法是一系列明确的指令，用于解决特定问题或完成特定任务。它们可以被编写成计算机程序...
哈工大-高级算法设计与分析课程ppt-2020最新版
04-30
《哈工大高级算法设计与分析课程PPT-2020最新版》是一份全面且深入探讨算法设计与分析的教育资源，源自知名的哈尔滨工业大学。这份资料涵盖了算法领域的多个核心主题，旨在帮助学习者理解并掌握解决复杂计算问题的...
算法设计与分析习题答案 .pdf
06-02
总之，算法设计与分析课程旨在培养学生的逻辑思维能力、分析问题和解决问题的能力，并且让学生能够熟练地运用各种算法策略来设计高效、可靠的算法来解决实际问题。通过对中科大研究生课程算法设计与分析的习题答案的...
算法project——Capacitated Facility Location Problem
diceroller的博客
12-22 744
Capacitated Facility Location Problem是一个NP难的问题，为了在有限的时间内解决这个问题，我采用了两种启发式算法来解决它。第一种是模拟退火算法，第二种是禁忌搜索算法。两种算法应该说各有千秋。 下面是Capacitated Facility Location Problem的大致内容：  Suppose there are n facilities and m...
算法设计练习9 Course Schedule 有向图BFS
weixin_37977536的博客
12-06 189
题目：要修n门课程，修某些课程会有先决条件（要已经修完某门课程）要求判断能否修完所有课程。 链接：https://leetcode.com/problems/course-schedule/   算法思路： 用有向图表示课程和课程间的关系，比如修课程b之前需要修完课程a，则表示为结点a有一条指向结点b的边，即&lt;a,b&gt; 那么要求判断能否修完所有课程就转化成判断有向图中是否存在...
ROS实现串口GPS数据的解析与通信(这篇文章所用的代码和我买的带有ROS功能包的GPS模块的功能包的代码一样)
诗筱涵的博客
05-25 2221
转载自：https://blog.csdn.net/weixin_43795921/article/details/85219249 ROS实现串口GPS数据的解析与通信 何伯特 2018-12-22 23:37:55 7123 收藏 86 分类专栏： ROS 文章标签： 串口 通信 ROS GPS 版权 1. 配置串口 配置串口时，利用ROS自带的serial功能包进行串口数据的读取，具体来说就是创建一个串口对象，用成员函数read进行读取，需要注意的是其中Timeout的设置以及read
字符串分割c++实现
沧浪之水清兮
08-15 410
//将一个字符串分割成多个字符串，c为分割符（“，” 、“；” 、“ ”等） //s为输入的一个长字符串 //v为输出的多个子字符串 void SplitString(const std::string&amp; s, std::vector&lt;std::string&gt;&amp; v, const std::string&amp; c) { std::string::size_ty...
[Python] 用K-means聚类算法进行客户分群
lam_yx的博客
08-21 9518
k均值聚类算法（k-means clustering algorithm）是一种迭代求解的聚类分析算法，其步骤是，预将数据分为K组，则随机选取K个对象作为初始的聚类中心，然后计算每个对象与各个种子聚类中心之间的距离，把每个对象分配给距离它最近的聚类中心。聚类中心以及分配给它们的对象就代表一个聚类。每分配一个样本，聚类的聚类中心会根据聚类中现有的对象被重新计算。这个过程将不断重复直到满足某个终止条件。终止条件可以是没有（或最小数目）对象被重新分配给不同的聚类，没有（或最小数目）聚类中心再发生变化，误差平方和局
C++中String类的字符串分割实现
weixin_42339460的博客
06-29 2645
最近笔试，经常遇到需要对字符串进行快速分割的情景，主要是在处理输入的时候，而以前练习算法题或笔试，很多时候不用花啥时间考虑测试用例输入的问题。可是C++标准库里面没有像java的String类中提供的字符分割函数split ，着实不方便。那么怎么解决这个问题呢？整理了一些方法如下：1.简洁高效的方法（不过只能包含一个分隔符）：123456789101112131415161718192021222...
工业视觉智能-分割模型基础知识
08-18
根据《阿里云工业视觉智能高级工程师ACP认证免费课程》（https://edu.aliyun.com/course/3128115/lesson/342981389）创建的个人笔记
计算机毕业设计jsp高考志愿选择辅助系统idea论文
最新发布
08-18
计算机毕业设计jsp高考志愿选择辅助系统idea论文
算法分析与设计课程作业详解：递归到动态规划
"该文档是关于算法分析与设计的课程作业，包含了递归算法、分治算法、贪心算法、动态规划算法、回溯算法和分支限界算法等多个主题的详细解析。每个主题下都有具体的问题实例，如汉诺塔问题、斐波那契数列、归并排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值