[kuangbin带你飞]专题六 最小生成树

最新推荐文章于 2020-02-23 17:34:02 发布
原创 最新推荐文章于 2020-02-23 17:34:02 发布 · 524 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了使用Prim算法解决多个不同场景下的最小生成树问题，包括道路建设、网络搭建等实际应用案例，并提供了完整的代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

A - Jungle Roads 题目链接

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <iostream>
using namespace std;

const int INF=0x3f3f3f3f;
const int MAXN=30;
bool vis[MAXN];
int lowc[MAXN];
int cost[MAXN][MAXN];


int Prim(int n)
{
	int ans=0;
	memset(vis,false,sizeof(vis));
	memset(lowc,0,sizeof(lowc));
	vis[0]=true;
	for(int i=1;i<n;i++)
		lowc[i]=cost[0][i];
	for(int i=1;i<n;i++)
	{
		int minc=INF;
		int p=-1;
		for(int j=0;j<n;j++)
		{
			if(!vis[j]&&minc>lowc[j])
			{
				minc=lowc[j];
				p=j;
			}
		}
		if(minc==INF)
			return -1;
		ans+=minc;
		vis[p]=true;
		for(int j=0;j<n;j++)
		{
			if(!vis[j]&&lowc[j]>cost[p][j])
				lowc[j]=cost[p][j];
		}
	}
	return ans;
}

void init(int n)
{
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
		{
			if(i==j)
				cost[i][j]=0;
			else
				cost[i][j]=cost[j][i]=INF;
		}
}

int main()
{
	int n,m,a;
	char s[10],ss[10];
	while(scanf("%d",&n)==1)
	{
		if(n==0)
			break;
		init(n);
		for(int i=1;i<n;i++)
		{
			scanf("%s%d ",&s,&m);
			for(int j=0;j<m;j++)
			{
				scanf("%s%d ",&ss,&a);
				cost[s[0]-'A'][ss[0]-'A']=cost[ss[0]-'A'][s[0]-'A']=a;
			}
		}	
		printf("%d\n",Prim(n));
	}
    return 0;
}

B -  Networking 题目链接 

#include <stdio.h>
#include <string.h>
#include <set>
#include <map>
#include <algorithm>
using namespace std;

const int INF=0x3f3f3f3f;
const int MAXN=59;
bool vis[MAXN];
int lowc[MAXN];
int cost[109][109];

int Prim(int n)
{
	int ans=0;
	memset(vis,false,sizeof(vis));
	vis[1]=true;
	for(int i=2;i<=n;i++)
		lowc[i]=cost[1][i];
	for(int i=2;i<=n;i++)
	{
		int minc=INF;
		int p=-1;
		for(int j=1;j<=n;j++)
		{
			if(!vis[j]&&minc>lowc[j])
			{
				minc=lowc[j];
				p=j;
			}
		}
		if(minc==INF)
			return -1;
		ans+=minc;
		vis[p]=true;
		for(int j=1;j<=n;j++)
		{
			if(!vis[j]&&lowc[j]>cost[p][j])
				lowc[j]=cost[p][j];
		}

	}
	return ans;
}

void init(int n)
{
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			cost[i][j]=cost[j][i]=INF;
}
int main()
{
	int n,m;
	while(scanf("%d",&n)==1)
	{
		if(n==0)
			break;
		scanf("%d",&m);
		init(n);
		while(m--)
		{
			int a,b,time;
			scanf("%d%d%d",&a,&b,&time);
			if(cost[a][b]>time)
			{
				cost[a][b]=cost[b][a]=time;
			}
		}
		/*for(int i=1;i<n;i++)
			for(int j=1;j<=n;j++)
				printf("%d ",cost[i][j]);*/
		printf("%d\n",Prim(n));
	}
    return 0;
}

C -  Building a Space Station 题目链接 

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <stdlib.h>
using namespace std;

const double INF=0x3f3f3f3f;
const int MAXN=109;
bool vis[MAXN];
double lowc[MAXN];
double cost[MAXN][MAXN];

double Prim(int n)
{
	double ans=0;
	memset(vis,false,sizeof(vis));
	memset(lowc,0,sizeof(lowc));
	vis[0]=true;
	for(int i=1;i<n;i++)
		lowc[i]=cost[0][i];
	for(int i=1;i<n;i++)
	{
		double minc=INF;
		int p=-1;
		for(int j=0;j<n;j++)
		{
			if(!vis[j]&&minc>lowc[j])
			{
				minc=lowc[j];
				p=j;
			}
		}
		if(minc==INF)
			return -1;
		ans+=minc;
		vis[p]=true;
		for(int j=0;j<n;j++)
		{
			if(!vis[j]&&lowc[j]>cost[p][j])
				lowc[j]=cost[p][j];
		}
	}
	return ans;
}

void init(int n)
{
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
		{
			if(i==j)
				cost[i][j]=0;
			else
				cost[i][j]=cost[j][i]=INF;
		}
}

int main()
{
	int n;
	while(scanf("%d",&n)==1)
	{
		if(n==0)
			break;
		init(n);
		for(int i=0;i<n;i++)
		{
			double a[109],b[109],c[109],r[109];
			scanf("%lf%lf%lf%lf",&a[i],&b[i],&c[i],&r[i]);
			for(int j=0;j<i;j++)
			{
				double dist=sqrt((a[i]-a[j])*(a[i]-a[j])+(b[i]-b[j])*(b[i]-b[j])+(c[i]-c[j])*(c[i]-c[j]));
				if(dist<=r[i]+r[j])
					cost[i][j]=cost[j][i]=0;
				else
					cost[i][j]=cost[j][i]=dist-(r[i]+r[j]);
			}
		}
		printf("%.3lf\n",Prim(n));
	}
	return 0;
}

D -  Constructing Roads 题目链接 

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <stdlib.h>
using namespace std;

const int INF=0x3f3f3f3f;
const int MAXN=109;
bool vis[MAXN];
int lowc[MAXN];
int cost[MAXN][MAXN];


int Prim(int n)
{
	int ans=0;
	memset(vis,false,sizeof(vis));
	memset(lowc,0,sizeof(lowc));
	vis[0]=true;
	for(int i=1;i<n;i++)
		lowc[i]=cost[0][i];
	for(int i=1;i<n;i++)
	{
		int minc=INF;
		int p=-1;
		for(int j=0;j<n;j++)
		{
			if(!vis[j]&&minc>lowc[j])
			{
				minc=lowc[j];
				p=j;
			}
		}
		if(minc==INF)
			return -1;
		ans+=minc;
		vis[p]=true;
		for(int j=0;j<n;j++)
		{
			if(!vis[j]&&lowc[j]>cost[p][j])
				lowc[j]=cost[p][j];
		}
	}
	return ans;
}

void init(int n)
{
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
		{
			if(i==j)
				cost[i][j]=0;
			else
				cost[i][j]=cost[j][i]=INF;
		}
}

int main()
{
	int n;
	scanf("%d",&n);
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
		{
			int a;
			scanf("%d",&a);
			cost[i][j]=a;
		}
	int m;
	scanf("%d",&m);
	while(m--)
	{
		int a,b;
		scanf("%d%d",&a,&b);
		cost[a-1][b-1]=cost[b-1][a-1]=0;
	}
	printf("%d\n",Prim(n));
	return 0;
}

E -  QS Network 题目链接 

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <stdlib.h>
using namespace std;

const int INF=0x3f3f3f3f;
const int MAXN=1009;
bool vis[MAXN];
int lowc[MAXN];
int pre[MAXN];
int Max[MAXN][MAXN];
bool used[MAXN][MAXN];

int prim(int cost[][MAXN],int n)
{
	int ans=0;
	memset(vis,false,sizeof(vis));
	memset(Max,0,sizeof(Max));
	memset(used,false,sizeof(used));
	vis[0]=true;
	pre[0]=-1;
	for(int i=1;i<n;i++)
	{
		lowc[i]=cost[0][i];
		pre[i]=0;
	}
	lowc[0]=0;
	for(int i=1;i<n;i++)
	{
		int minc=INF;
		int p=-1;
		for(int j=0;j<n;j++)
		{
			if(!vis[j]&&minc>lowc[j])
			{
				minc=lowc[j];
				p=j;
			}
		}
		if(minc==INF)
			return -1;
		ans+=minc;
		vis[p]=true;
		used[p][pre[p]]=used[pre[p]][p]=true;
		for(int j=0;j<n;j++)
		{
			if(vis[j])
				Max[j][p]=Max[p][j]=max(Max[j][pre[p]],lowc[p]);
			if(!vis[j]&&lowc[j]>cost[p][j])
			{
				lowc[j]=cost[p][j];
				pre[j]=p;
			}
		}
	}
	return ans;
}

int Prim(int cost[][MAXN],int n)
{
	double ans=0;
	memset(vis,false,sizeof(vis));
	memset(lowc,0,sizeof(lowc));
	vis[0]=true;
	for(int i=1;i<n;i++)
		lowc[i]=cost[0][i];
	for(int i=1;i<n;i++)
	{
		int minc=INF;
		int p=-1;
		for(int j=0;j<n;j++)
		{
			if(!vis[j]&&minc>lowc[j])
			{
				minc=lowc[j];
				p=j;
			}
		}
		if(minc==INF)
			return -1;
		ans+=minc;
		vis[p]=true;
		for(int j=0;j<n;j++)
		{
			if(!vis[j]&&lowc[j]>cost[p][j])
				lowc[j]=cost[p][j];
		}
	}
	return ans;
}

void init(int cost[][MAXN],int n)
{
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
		{
			if(i==j)
				cost[i][j]=0;
			else
				cost[i][j]=cost[j][i]=INF;
		}
}

int ans;

int smst(int cost[][MAXN],int n)
{
	int Min=INF;
	for(int i=0;i<n;i++)
		for(int j=i+1;j<n;j++)
		{
			if(cost[i][j]!=INF&&!used[i][j])
			{
				Min=min(Min,ans+cost[i][j]-Max[i][j]);
			}
		}
	if(Min==INF)
		return -1;
	return Min;
}

int cost[MAXN][MAXN];

int main()
{
	//freopen("in.txt","r",stdin);
	//freopen("out.txt","w",stdout);
	int T,s[MAXN];
	scanf("%d",&T);
	while(T--)
	{
		int n;
		scanf("%d",&n);
		init(cost,n);
		for(int i=0;i<n;i++)
			scanf("%d",&s[i]);
		for(int i=0;i<n;i++)
			for(int j=0;j<n;j++)
			{
				int a;
				scanf("%d",&a);
				cost[i][j]=a+s[i]+s[j];
			}
		printf("%d\n",Prim(cost,n));
	}
	return 0;
}
I -  Agri-Net 题目链接 

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;


const int INF=0x3f3f3f3f;
const int MAXN=109;
bool vis[MAXN];
int lowc[MAXN];
int cost[MAXN][MAXN];
int n;

int Prim()
{
	int ans=0;
	memset(vis,0,sizeof(vis));
	vis[1]=true;
	for(int i=2;i<=n;i++)
	{
		lowc[i]=cost[1][i];
	}
	for(int i=2;i<=n;i++)
	{
		int minc=INF;
		int p=-1;
		for(int j=1;j<=n;j++)
		{
			if(!vis[j]&&minc>lowc[j])
			{
				minc=lowc[j];
				p=j;
			}
		}
		if(minc==INF)
			return -1;
		ans+=minc;
		vis[p]=true;
		for(int j=1;j<=n;j++)
		{
			if(!vis[j]&&lowc[j]>cost[p][j])
				lowc[j]=cost[p][j];
		}
	}
	return ans;
}

int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
	while(scanf("%d",&n)==1)
	{
		for(int i=1;i<=n;i++)
			lowc[i]=i;
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
			{
				scanf("%d",&cost[i][j]);
			}
		printf("%d\n",Prim());
	}
    return 0;
}

K -  The Unique MST 题目链接

此题错了5次。。

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <stdlib.h>
using namespace std;

const int INF=0x3f3f3f3f;
const int MAXN=109;
bool vis[MAXN];
int lowc[MAXN];
int pre[MAXN];
int Max[MAXN][MAXN];
bool used[MAXN][MAXN];

int prim(int cost[][MAXN],int n)
{
	int ans=0;
	memset(vis,false,sizeof(vis));
	memset(Max,0,sizeof(Max));
	memset(used,false,sizeof(used));
	vis[0]=true;
	pre[0]=-1;
	for(int i=1;i<n;i++)
	{
		lowc[i]=cost[0][i];
		pre[i]=0;
	}
	lowc[0]=0;
	for(int i=1;i<n;i++)
	{
		int minc=INF;
		int p=-1;
		for(int j=0;j<n;j++)
		{
			if(!vis[j]&&minc>lowc[j])
			{
				minc=lowc[j];
				p=j;
			}
		}
		if(minc==INF)
			return -1;
		ans+=minc;
		vis[p]=true;
		used[p][pre[p]]=used[pre[p]][p]=true;
		for(int j=0;j<n;j++)
		{
			if(vis[j])
				Max[j][p]=Max[p][j]=max(Max[j][pre[p]],lowc[p]);
			if(!vis[j]&&lowc[j]>cost[p][j])
			{
				lowc[j]=cost[p][j];
				pre[j]=p;
			}
		}
	}
	return ans;
}

int Prim(int cost[][MAXN],int n)
{
	double ans=0;
	memset(vis,false,sizeof(vis));
	memset(lowc,0,sizeof(lowc));
	vis[0]=true;
	for(int i=1;i<n;i++)
		lowc[i]=cost[0][i];
	for(int i=1;i<n;i++)
	{
		int minc=INF;
		int p=-1;
		for(int j=0;j<n;j++)
		{
			if(!vis[j]&&minc>lowc[j])
			{
				minc=lowc[j];
				p=j;
			}
		}
		if(minc==INF)
			return -1;
		ans+=minc;
		vis[p]=true;
		for(int j=0;j<n;j++)
		{
			if(!vis[j]&&lowc[j]>cost[p][j])
				lowc[j]=cost[p][j];
		}
	}
	return ans;
}

void init(int cost[][MAXN],int n)
{
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
		{
			if(i==j)
				cost[i][j]=0;
			else
				cost[i][j]=cost[j][i]=INF;
		}
}

int ans;

int smst(int cost[][MAXN],int n)
{
	int Min=INF;
	for(int i=0;i<n;i++)
		for(int j=i+1;j<n;j++)
		{
			if(cost[i][j]!=INF&&!used[i][j])
			{
				Min=min(Min,ans+cost[i][j]-Max[i][j]);
			}
		}
	if(Min==INF)
		return -1;
	return Min;
}

int cost[MAXN][MAXN];

int main()
{
	//freopen("in.txt","r",stdin);
	//freopen("out.txt","w",stdout);
	int T;
	scanf("%d",&T);
	while(T--)
	{
		int n,m;
		scanf("%d%d",&n,&m);
		init(cost,n);
		while(m--)
		{
			int a,b,c;
			scanf("%d%d%d",&a,&b,&c);
			cost[a-1][b-1]=cost[b-1][a-1]=c;
		}
		ans=prim(cost,n);
		if(ans==-1)
		{
			printf("Not Unique!\n");
			continue;
		}
		if(ans==smst(cost,n))
		{
			printf("Not Unique!\n");
		}
		else
		{
			printf("%d\n",ans);
		}
	}
	return 0;
}

L -  还是畅通工程 题目链接 

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;

const int INF=0x3f3f3f3f;
const int MAXN=109;
bool vis[MAXN];
int lowc[MAXN];
int cost[MAXN][MAXN];
int n;

int Prim()
{
	int ans=0;
	memset(vis,0,sizeof(vis));
	vis[1]=true;
	for(int i=2;i<=n;i++)
	{
		lowc[i]=cost[1][i];
	}
	for(int i=2;i<=n;i++)
	{
		int minc=INF;
		int p=-1;
		for(int j=1;j<=n;j++)
		{
			if(!vis[j]&&minc>lowc[j])
			{
				minc=lowc[j];
				p=j;
			}
		}
		if(minc==INF)
			return -1;
		ans+=minc;
		vis[p]=true;
		for(int j=1;j<=n;j++)
		{
			if(!vis[j]&&lowc[j]>cost[p][j])
				lowc[j]=cost[p][j];
		}
	}
	return ans;
//	printf("%d\n",ans);
}

int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
	while(scanf("%d",&n)==1)
	{
		if(n==0)
			break;
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
			{
				if(i==j)
					cost[i][j]=0;
				else
					cost[i][j]=INF;
			}
		for(int i=0;i<n*(n-1)/2;i++)
		{
			int a,b,time;
			scanf("%d%d%d",&a,&b,&time);
			if(cost[a][b]>time)
				cost[a][b]=cost[b][a]=time;
		}
		printf("%d\n",Prim());
	}
    return 0;
}

M -  Jungle Roads 题目链接 

#include <stdio.h>
#include <string.h>
#include <set>
#include <map>
#include <algorithm>
#include <math.h>
#include <iostream>
using namespace std;

const int INF=0x3f3f3f3f;
const int MAXN=109;
bool vis[MAXN];
int lowc[MAXN];
int cost[109][109];


int Prim(int n)
{
	int ans=0;
	memset(vis,0,sizeof(vis));
	vis[0]=true;
	for(int i=1;i<n;i++)
		lowc[i]=cost[0][i];
	for(int i=1;i<n;i++)
	{
		int minc=INF;
		int p=-1;
		for(int j=0;j<n;j++)
		{
			if(!vis[j]&&minc>lowc[j])
			{
				minc=lowc[j];
				p=j;
			}
		}
		if(minc==INF)
			return -1;
		ans+=minc;
		vis[p]=true;
		for(int j=0;j<n;j++)
		{
			if(!vis[j]&&lowc[j]>cost[p][j])
				lowc[j]=cost[p][j];
		}
	}
	return ans;
}

void init(int n)
{
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
		{
			if(i==j)
				cost[i][j]=0;
			else
				cost[i][j]=cost[j][i]=INF;
		}
}

int main()
{
	int n,m,a;
	char c,d;
	while(scanf("%d",&n)==1)
	{
		if(n==0)
			break;
		getchar();
		init(n);
		for(int i=0;i<n-1;i++)
		{
			scanf("%c %d",&c,&m);
			if(m!=0)
				getchar();
			while(m--)
			{
				if(m==0)
					scanf("%c %d",&d,&a);
				else
					scanf("%c %d ",&d,&a);
				cost[c-'A'][d-'A']=cost[d-'A'][c-'A']=a;
			//	printf("%d %d \n",c-'A',d-'A');
			}
			getchar();
		}
		/*for(int i=0;i<n;i++)
		{
			for(int j=0;j<n;j++)
			{
				printf("%d ",cost[i][j]);
			}
			printf("\n");
		}*/
		printf("%d\n",Prim(n));
	}
    return 0;
}

N -  畅通工程再续 题目链接 
#include <stdio.h>
#include <string.h>
#include <set>
#include <map>
#include <algorithm>
#include <math.h>
#include <iostream>
using namespace std;

const double INF=0x3f3f3f3f;
const int MAXN=109;
bool vis[MAXN];
double lowc[MAXN];
double cost[109][109];

struct node
{
	double x,y;
}s[109];

double Prim(int n)
{
	double ans=0;
	memset(vis,false,sizeof(vis));
	vis[1]=true;
	for(int i=2;i<=n;i++)
		lowc[i]=cost[1][i];
	for(int i=2;i<=n;i++)
	{
		double minc=INF;
		int p=-1;
		for(int j=1;j<=n;j++)
		{
			if(!vis[j]&&minc>lowc[j])
			{
				minc=lowc[j];
				p=j;
			}
		}
		if(minc==INF)
			return -1;
		if(minc>1000||minc<10)
		{
			return -1;
		}
		ans+=minc;
		vis[p]=true;
		for(int j=1;j<=n;j++)
		{
			if(!vis[j]&&lowc[j]>cost[p][j])
				lowc[j]=cost[p][j];
		}

	}
	return ans;
}

void init(int n)
{
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			cost[i][j]=cost[j][i]=INF;
}

int main()
{
	int T;
	scanf("%d",&T);
	while(T--)
	{
		int n;
		scanf("%d",&n);
		for(int i=1;i<=n;i++)
		{
			scanf("%lf%lf",&s[i].x,&s[i].y);
		}
		init(n);
		int k=0;
		for(int i=1;i<=n;i++)
		{
			for(int j=i+1;j<=n;j++)
			{
				double time=sqrt((s[i].x-s[j].x)*(s[i].x-s[j].x)+(s[i].y-s[j].y)*(s[i].y-s[j].y));
				if(cost[i][j]>time&&time<=1000&&time>=10)
					cost[i][j]=cost[j][i]=time;
			}
		}
		if(Prim(n)==-1)
			printf("oh!\n");
		else
		{
			printf("%.1lf\n",Prim(n)*100.0);
		}
	}	
    return 0;
}



POJ 2031 Building a Space Station(kuangbin带你飞 专题六：最小生成树)
01-31 388
大概题意就是要有n个空间站，给出三维坐标以及半径（是个球）..要每两个空间站之间都能互相通信啥的...问建立的最小花费是多少..花费就是两个空间站的距离...如果小于0当做0.. 两球之间的距离等于两球心之间的距离减去两球的半径...就能算出球面之间的距离了..然后最小生成树走起 #include #include #include #include #include #include usi
[kuangbin带你飞]专题六 做题顺序与题解 【最小生成树】
指弹键盘哼民谣
02-23 3719
随便说点： 博主正在刷kuangbin专题的题目，初学者，没接触过什么算法，刷题的初衷是备战蓝桥杯，后来发现了算法资料大多是针对acm的，挑选kuangbin专题入门也是如此，毕竟这样分类看起来比较有目的的刷题。 所以有的代码比较冗余，越往后面的题解代码变化越大， 代码的风格和算法思想也是在一步步的学习和进步，多多包容，互相借鉴。 建议做题顺序： 做最小生成树专题没最短路和并查集专题时那么吃力...
[kuangbin带你飞]专题六 最小生成树A
zjy2015302395的博客
01-05 402
http://poj.org/problem?id=1251题意：题目大意在相通n个岛屿的所有桥都坏了，要重修，重修每一个桥所用的时间不同，求重修使每个岛屿都间接或直接与其他岛屿相同时所用的的最短时间（只有修完一个桥后才可修下一个桥）。 对于数据，数据输入的第一行n代表岛屿的个数，当为0是结束程序，接着n-1行开始时为这岛屿的编号，用大写字母表示，接着是一个整数m，表示与该岛屿连接的字典序大于该岛
[kuangbin带你飞]专题六 最小生成树 解题报告
chr1stopher
04-29 496
文章目录A - Jungle RoadsB - NetworkingC - Building a Space Station（待补）D - Constructing RoadsE - QS NetworkF - Truck History（待补）G - Arctic NetworkH - HighwaysI - Agri-NetJ - Borg Maze（待补）K - The Unique MST...
[kuangbin带你飞]专题六 最小生成树 题解+总结
放荡者的茶会
10-06 1930
kuangbin带你飞：点击进入新世界 最短路算法模板：点击进入新世界 总结： 本人算是初学者中的初学者，欢迎交流~ kuangbin的专题确实是理解最短路的一大途径，这篇博客主要记录题解，顺便总结最短路的题型。 A.模板题 参考1 . 6 . 10 B.变形最短路 （求最大边权的最小值or最小边权的最大值） 参考2 . 3 C.变形最短路 （求往返最短路的最大值） 参考4 D....
HDU 1233 还是畅通工程 （kuangbin带你飞 专题六 最小生成树）
01-23 426
好久没写过图了...上去就错了好几次- -写的好搓..一直忘记边数时n*（n-1）/2...kruskal..#include #include #include #include #include #include using namespace std; struct node { int u,v,s; }; int cmp(node a,node b) { return a.
ZOJ 1586&&FZU 1096 QS Network（kuangbin带你飞 专题六 最小生成树）
01-29 489
这个题...好水，不过多了一个顶点的权值，所以建立某条边的话费就是边的花费+；两个顶点的花费... 这种各种找简单题做也不是办法...专题一还剩一道题...明天尽力给A掉...一直没看懂来着..好好努力...寒假眼看就剩一个月了  #include #include #include #include #include #include using namespace std; int n,m
kuangbin带你飞 专题六 最小生成树 1586（基本都是水题）
Miracle_ma的专栏
07-10 738
做了十来道了，基本都挺水的，主要自己傻，各种数组开小，RE了不少 zoj 1586 题意：貌似就是说给出了许多QS之间的路，然后QS每次只能用一次（每次都有花费） 题解：就是边的权值还得加上两点的花费（都是题意难以理解） for(int i=1;i<=n;i++){ scanf("%d",&val[i]); pre[i]=i;
[kuangbin带你飞]专题六 最小生成树 A~E
qq_41855962的博客
07-20 238
A - Jungle Roads 套模板 直接出 Kruskal #include<stdio.h> #include<string.h> #include<algorithm> using namespace std; int father[100]; int n,m; struct point { int u; int v; ...
kuangbin带你飞 专题1-23 题单
HelloACM_ICPC的博客
01-27 2863
kuangbin大神，对于打过ACM比赛的ACMer，无人不知无人不晓。 在此，附上vjudge平台上一位大神整理的[kuangbin带你飞]专题目录链接。 [kuangbin带你飞专题目录1-23] : https://vjudge.net/article/187 专题一 简单搜索 POJ 1321 棋盘问题 POJ 2251 Dungeon Master POJ 3278 Catch That...
kuangbin专题八生成树总结
qq_34921856的博客
02-28 344
总结:生成树的知识点真多，不过博主觉得图论的题目终究是建图难，第一步就是如何建图，将其转换成已知的问题。 另外，关于生成树的两个注意点，也是为了防止碰到毒瘤题。一就是自环，二就是重边。 A - The Unique MST 次小生成树裸题。 prim模板 #include&lt;iostream&gt; #include&lt;cstring&gt; #include&lt;algori...
[kuangbin带你飞]专题一 做题顺序与题解 【简单搜索】
指弹键盘哼民谣
02-23 8105
随便说点： 博主正在刷kuangbin专题的题目，初学者，没接触过什么算法，刷题的初衷是备战蓝桥杯，后来发现了算法资料大多是针对acm的，挑选kuangbin专题入门也是如此，毕竟这样分类看起来比较有目的的刷题。 所以有的代码比较冗余，越往后面的题解代码变化越大， 代码的风格和算法思想也是在一步步的学习和进步，多多包容，互相借鉴。 建议做题顺序： 11 2 12 3 1 8 13 6 14 ...
go 代码生成工具 基于sqlx echo.zip
最新发布
08-23
go 代码生成工具 基于sqlx echo.zip
西门子PLC与V20变频器以太网通讯编程：频率与启停控制实现
08-23
内容概要：本文档详细介绍了西门子1200 PLC与西门子V20变频器之间的通讯编程方法，重点在于通过以太网线实现对变频器的频率设定、启停控制及状态监测。文中涵盖了系统的组成器件（如西门子KTP700 Basic PN触摸屏、昆仑通态触摸屏）、控制方式（触摸屏与PLC以太网通讯，PLC与变频器485口通讯），并提供完整的接线与设置指南。此外，还详细解释了程序的功能、设计思路及其模块化的实现方式，确保程序的易维护性和可扩展性。 适用人群：从事工业自动化领域的工程师和技术人员，尤其是那些需要掌握PLC与变频器通讯编程技能的人群。 使用场景及目标：适用于需要集成PLC与变频器进行自动化控制的项目，旨在提高系统的响应速度和稳定性，减少人工干预，提升生产效率。 其他说明：文档不仅提供了详细的程序注释和技术细节，还包括了变频器的具体设置步骤和接线图，便于用户快速上手和调试。
综合能源系统优化运行研究：碳机制与需求响应的应用及影响 综合能源系统
08-23
内容概要：本文深入探讨了在不同情境下综合能源系统的优化运行，特别是无碳机制、无需求响应，仅考虑需求响应，以及碳机制下考虑需求响应的情况。首先，在无碳机制和无需求响应的传统模式中，系统主要依赖化石燃料，虽然短期内有效，但从长远看既不环保也不经济。其次，仅考虑需求响应时，通过智能电网和需求侧管理技术，用户可根据实时电价调整能源消费行为，有助于平衡供需并提高效率，但仍忽视了碳排放。最后，在碳机制下考虑需求响应的情景中，不仅强调用户侧灵活性，还将碳排放和环境成本纳入考量，提出了一系列优化措施如增加可再生能源比例、引入碳交易市场、强化需求响应策略和系统集成，以实现更高效的能源管理和更低的碳排放。 适合人群：从事能源管理、环境保护及相关领域的研究人员和技术人员。 使用场景及目标：适用于希望深入了解综合能源系统优化运行及其在不同条件下的表现的研究者，以及寻求提升能源系统效率和减少碳排放的企业管理者和技术专家。 其他说明：文中引用了多篇关于综合能源系统优化运行、需求响应应用及碳交易市场影响的相关文献，为研究提供了坚实的理论基础。
基于STM32F4的BMS电池管理系统：实现SOC均衡与电池监控的先进控制器
08-23
一款基于STM32F407的电池管理系统(BMS)，该系统利用LTC6804和LTC3300实现了对12节电池的精确监控和高效均衡。文中不仅提供了系统的硬件架构图，还深入解析了关键芯片的工作原理及其配置方法，特别是针对SOC估算和主动均衡的具体实现进行了详尽阐述。此外，作者分享了PCB布局的经验教训，并给出了一些优化性能的小技巧，如滑动窗口均值滤波算法用于减少误触发概率，以及在ADC采样前加入GPIO电平翻转作为硬件自检手段。最后展示了系统的实测数据，证明了其高精度和低功耗特性。 适合人群：电子工程师、嵌入式开发者、对电池管理系统感兴趣的科研人员和技术爱好者。 使用场景及目标：适用于需要构建高性能电池管理系统的场合，旨在帮助读者掌握从理论到实践的完整流程，包括但不限于硬件选型、软件编程、PCB设计等方面的知识。 阅读建议：由于涉及到较多的专业术语和技术细节，在阅读过程中可以结合提供的源代码和电路图进行理解和验证。同时关注文中提到的各种优化措施，这对于提高项目的稳定性和可靠性至关重要。
基于MATLAB的粒子群算法优化SVM多特征输入分类模型及其应用
08-23
一种利用粒子群算法（PSO）优化支持向量机（SVM）进行多特征输入单输出的二分类及多分类建模的方法。文中提供了完整的MATLAB代码，涵盖数据预处理、模型训练与评估、参数优化以及结果可视化的全过程。通过调整SVM的关键参数——惩罚因子C和RBF核参数gamma，实现了对模型性能的有效提升。实验结果显示，在特定数据集上，经过PSO优化后的SVM模型将分类准确率从82%提高到了94%。 适合人群：熟悉MATLAB编程环境并对机器学习尤其是SVM有一定了解的研究人员和技术开发者。 使用场景及目标：适用于需要解决复杂分类问题的数据科学家或工程师，旨在帮助他们掌握如何运用PSO来寻找最佳超参数组合，从而改善SVM模型的表现。同时，提供的可视化工具能够直观展示优化过程和结果。 其他说明：文中还给出了若干实用技巧，如针对大规模数据集选择合适的SVM实现方式、高维度特征空间下的降维处理方法等，有助于避免常见陷阱并确保优化过程顺利进行。
新时达主板及外呼通讯板程序协议详解：电梯控制与门禁系统应用
08-23
新时达系列主板程序协议及其外呼通讯板程序协议的应用。首先概述了新时达主板程序协议的设计目的和核心功能，强调其在电梯控制和门禁系统中的重要性。接着解析了新时达外呼程序的工作机制，解释了用户如何通过楼层按钮、呼梯面板等设备与电梯系统进行交互。然后重点讨论了新时达02g程序与380系列主板外呼通讯板之间的兼容性和优化措施，特别是对t029、t036、s8等型号的支持。最后通过一段C语言代码示例，展示了如何在新时达系统中进行基本的通讯和数据传输。 适合人群：从事电梯控制系统开发的技术人员，尤其是负责硬件通信协议设计和优化的专业人士。 使用场景及目标：帮助技术人员理解和优化新时达系列主板程序协议，提高电梯控制系统的稳定性和效率。适用于新项目开发和技术维护阶段。 其他说明：文中提供的代码示例为简化版本，实际应用中需要考虑更多复杂情况，如数据编码、加密和多设备间的协调。
西门子200smart环境下电子凸轮区间运动控制与PLC指令编程解析
08-23
电子凸轮区间运动Ver1.3.1的技术特点及其在西门子200smart CPU224XP环境下的应用。主要内容涵盖主轴伺服和从轴伺服的位置跟随机制、PLS指令编写方法、凸轮带加减速功能的具体实现方式。文中还讨论了软硬件配合对设备稳定性和可靠性的影响，强调了合理控制和算法设计的重要性。 适合人群：从事自动化控制领域的工程师和技术人员，尤其是熟悉西门子PLC编程的专业人士。 使用场景及目标：适用于希望深入了解电子凸轮控制原理并掌握具体编程技巧的人群。目标是在实际项目中能够运用所学知识提升设备的运行精度和响应速度。 其他说明：文章提供了详细的理论分析和技术细节，有助于读者全面理解电子凸轮区间的运动控制原理。同时，文中提及的内容对于优化现有系统性能也有一定的指导意义。
kuangbin带你飞
02-27
“kuangbin带你飞”专题十四涵盖了数论基础知识的学习，旨在帮助参赛者掌握算法竞赛中常用的数论概念和技术。该系列不仅提供了丰富的理论讲解，还推荐了一本详细的书籍《算法竞赛中的初等数论》，这本书包含了ACM、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值