一本通 MST

最新推荐文章于 2024-05-23 20:47:46 发布
最新推荐文章于 2024-05-23 20:47:46 发布
阅读量228 收藏 2
点赞数 3
分类专栏： 图论 一本通提高版 文章标签： leetcode c++ 学习 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60921016/article/details/136958813
版权

黑暗城堡

类似最短路计数的问题，模拟prim的计数过程就好了，可以写成nlog

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
const int N = 1e3+10;
const int inf = 0x3f3f3f3f;
const int mod = 2147483647;
const int M = 1e6+10;
int n,m;
int id[N];
int e[M],ne[M],w[M],h[N],idx;
void add(int a,int b,int c){
	e[idx] = b,ne[idx] = h[a],w[idx] = c,h[a] = idx++;
}
int cost[1010][1010];
int dist[1010];
bool vis[1010];


void spfa()
{
	queue<int>q;
	memset(dist,0x3f,sizeof dist);
	vis[1] = true;
	dist[1] = 0;
	q.push(1);
	
	while(q.size()){
		auto ver = q.front();
		//cout<<ver<<"\n";
		q.pop();
		vis[ver] = false; 
		for(int i=h[ver];~i;i=ne[i]){
			int j = e[i];
			
			if(dist[j]>dist[ver]+w[i]){
				dist[j] = dist[ver] + w[i];
				if(!vis[j]){
					q.push(j);
					vis[j] = true;
				}
			}
		}
	}
	
	
}
 
bool cmp(int a,int b){
	return dist[a]<dist[b];
}

void solve()
{
	scanf("%lld%lld",&n,&m);
	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] = cost[j][i] = inf;
	
	memset(h,-1,sizeof h);
		  
	for(int i=1;i<=m;i++){
		int a,b,c;scanf("%lld%lld%lld",&a,&b,&c);
		if(c<cost[a][b])cost[a][b] = cost[b][a] = c;
		add(a,b,c);
		add(b,a,c);
	}	
	
	spfa();
	

	
	for(int i=1;i<=n;i++)id[i] = i;
	
	sort(id+1,id+1+n,cmp);
	
	int res = 1;
	
	for(int i=2;i<=n;i++){
		int cnt = 0;
		for(int j=1;j<i;++j){
			if(dist[id[i]]==dist[id[j]]+cost[id[j]][id[i]])cnt++;
		}
		cnt%=mod;
		if(cnt)res = (res*cnt)%mod;
	}
	
	cout<<res;
	
	

}

signed main()
{
	//ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
const int N = 1e3+10;
const int inf = 0x3f3f3f3f;
const int mod = 2147483647;
const int M = 1e6+10;
int n,m;
int e[M],ne[M],w[M],h[N],idx;
int dp[N];


void add(int a,int b,int c){
	e[idx] = b,ne[idx] = h[a],w[idx] = c,h[a] = idx++;
}
int dist[1010];
bool vis[1010];



void dijkstra(int num)
{
	priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>>heap;
	if(!num)memset(dist,0x3f,sizeof dist);
	memset(vis,0,sizeof vis);
	dist[1] = 0;
	
	dp[1] = 1;//计数数组
	heap.push({0,1});
	
	while(heap.size()){
		auto t = heap.top();
		heap.pop();
		

		
		int distance = t.first,ver = t.second;
		if(vis[ver])continue;
		vis[ver] = true;
		
		for(int i=h[ver];~i;i=ne[i]){
			int j = e[i];
			if(dist[j]>=w[i]+distance){
				if(num)dp[j] ++; 
				dist[j] = dist[ver]+w[i];
				heap.push({dist[j],j});
			}
		}
		
	}
	

}



bool cmp(int a,int b){
	return dist[a]<dist[b];
}

void solve()
{
	scanf("%lld%lld",&n,&m);


	memset(h,-1,sizeof h);
		  
	for(int i=1;i<=m;i++){
		int a,b,c;scanf("%lld%lld%lld",&a,&b,&c);
		add(a,b,c);
		add(b,a,c);
	}	
	
	dijkstra(0);
	dijkstra(1);
	
	//for(int i=1;i<=n;i++)cout<<dist[i]<<" ";
	//cout<<"\n";
	
	int res = 1;
	for(int i=1;i<=n;i++)res = res*dp[i]%mod;
	cout<<res;
	

	
	

	

}

signed main()
{
	//ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

新的开始

虚拟原点 + prim跑最小生成树

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
const int N = 1e5+10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9+7;

int n,q;


int g[1010][1010];
bool vis[N];
int dist[N];
int ans = 0;
void prim()
{
	
	memset(dist,0x3f,sizeof dist);
	dist[0] = 0;
	
	for(int i=0;i<=n;i++){
		int t = inf;
		int k;
		for(int j=0;j<=n;j++){
			if(dist[j]<t&&!vis[j]){
				t = dist[j],k = j;
			}
		}
		
		//cout<<k<<" "<<t<<"gaga\n";;
		
		ans+=t;
		vis[k] = true;
		
		for(int j=1;j<=n;j++)dist[j] = min(dist[j],g[k][j]);
		
	}
	
	
}

void solve()
{
	cin>>n;
	
	for(int i=1;i<=n;i++){
		int x;cin>>x;
		g[0][i] = x;
	}	
	
	
	for(int i=1;i<=n;i++)
	 for(int j=1;j<=n;j++)
	  cin>>g[i][j];
	  
	prim();
	
	cout<<ans;

}

signed main()
{
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

北极通讯网络

书上给的是一个证明的结论 数据范围很小可以直接暴力乱搞

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
const int N = 1e5+10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9+7;

int n,k;
int p[N];
int find(int x){
	
	if(x!=p[x])p[x] = find(p[x]);
	return p[x];
}


struct Node{
	int x,y;
}node[N];


double get_dist(int a,int b){
	int dx = node[a].x - node[b].x;
	int dy = node[a].y - node[b].y;
	return sqrt(dx*dx+dy*dy);	
}

bool check(double mid){
	
	
	for(int i=1;i<=n;i++)p[i] = i;
	
	for(int i=1;i<=n;i++)
	  for(int j=1;j<=n;j++){
	  	if(i==j)continue;
	  	double x = get_dist(i,j);
	  	if(x<=mid){
	  		int a = find(i),b = find(j);
	  		p[a] = b;
	  	}
	  }
	  
	set<int>s;
	for(int i=1;i<=n;i++)s.insert(find(i));
	return s.size()<=k;
	  
	
}

void solve()
{
	cin>>n>>k;
	for(int i=1;i<=n;i++)cin>>node[i].x>>node[i].y;
	
	
	
	double l = 0,r = 1e4;
	
	while(r-l>1e-4){
		double mid = (l+r)/2;
		if(check(mid))r = mid;
		else l = mid;
		//cnt++;
		//cout<<l<<" "<<r<<"\n";
		//if(cnt>=50)break;
	}
	
	printf("%.2lf",r);
	
	

}

signed main()
{
	//ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

构造完全图

考虑Kruskal的过程，它每次对两个集合进行操作，每次都是只保留最短的那条边，因此每次操作两个集合的时候我们考虑集合里面的其他边对答案的贡献就好 然后乘法原理一下就可以得到答案了

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
const int N = 1e5+10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9+7;

int n,q;
struct Node{
	int a,b,w;
	bool operator<(const Node&W)const{
		return w<W.w;
	}
}node[N];

int p[N],sz[N];


int find(int x){
	if(x!=p[x])p[x] = find(p[x]);
	return p[x];
}

void solve()
{
	
	cin>>n;
	int res = 0;
	for(int i=1;i<n;i++){
		int a,b,c;cin>>a>>b>>c;
		node[i] = {a,b,c};
		res+=c;
	}
	
	
	
	sort(node+1,node+n);
	for(int i=1;i<=n;i++)p[i] = i,sz[i] = 1;
	
	for(int i=1;i<n;i++){
		
		
		int a = node[i].a,b = node[i].b,c = node[i].w;
		a = find(a),b = find(b);
		
		res = res + (sz[a]*sz[b]-1)*(c+1);
		
		p[a] = b;
		sz[b]+=sz[a];
	}
	
	cout<<res;
	
	

}

signed main()
{
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

秘密的奶牛运输

暴力求进行严格次小生成树

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
const int N = 510,M = 2e5+10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9+7;

int n,m;
int e[M],ne[M],w[M],h[N],idx;
int dist1[N][N];
int dist2[N][N];
void add(int a,int b,int c){
	e[idx] = b,ne[idx] = h[a],w[idx] = c,h[a] = idx++;
}
struct Node{
	int a,b,w,f;
	bool operator<(const Node&W)const{
		return w<W.w;
	}
}node[M];
int p[N];
int sum;
int find(int x){
	if(x!=p[x]) p[x] = find(p[x]);
	return p[x];
}


void dfs(int u, int fa, int maxd1, int maxd2, int d1[], int d2[])
{
    d1[u] = maxd1, d2[u] = maxd2;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j != fa)
        {
            int td1 = maxd1, td2 = maxd2;
            if (w[i] > td1) td2 = td1, td1 = w[i];
            else if (w[i] < td1 && w[i] > td2) td2 = w[i];
            dfs(j, u, td1, td2, d1, d2);
        }
    }
}
void solve()
{
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		cin>>node[i].a>>node[i].b>>node[i].w;
	}
	
	
	sort(node+1,node+1+m);
	
	for(int i=1;i<=n;i++)p[i] = i;
	memset(h,-1,sizeof h);
	for(int i=1;i<=m;i++){
		int a = node[i].a,b = node[i].b,c = node[i].w;
		int pa = find(a),pb = find(b);
		if(pa==pb)continue;
		node[i].f = 1;
		add(a,b,c),add(b,a,c);
		sum+=c;
		p[pa] = pb; 
	}
	
	
	
	for(int i=1;i<=n;i++)dfs(i,-1,-inf,-inf,dist1[i],dist2[i]);
	
	
	
	int res=1e15;
	for(int i=1;i<=m;i++){
		if(node[i].f)continue;
		int t = inf;
		int a = node[i].a,b = node[i].b,c = node[i].w;
		if(c>dist1[a][b])t = sum+c-dist1[a][b]; 
		else if(c>dist2[a][b])t = sum+c-dist2[a][b];
		
		res = min(res,t);
	}
	
	cout<<res;

}

signed main()
{
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

Tree

一开始想到的是直接贪心的加能加上的最小的几条白边，其实不是最优的

这里有个经典的套路我之前没怎么接触过就是 带权二分答案，当你求某个东西出现的次数恰好是k的时候让你最优化问题，你可以直接做，通过给这个东西一个权值让它的出现次数呈现单调性也就可以二分答案来求了

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
const int N = 1e5+10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9+7;

int n,m,k;


struct Node{
	int a,b,w,c;
	bool operator<(const Node&W)const{
		if(W.w!=w)return w<W.w;
		return c<W.c;
	}
}node[N];
int p[N];

int s;

int find(int x){
	if(x!=p[x])p[x] = find(p[x]);
	return p[x];
}

int check(int mid){
	for(int i=0;i<=n;i++)p[i] = i;
	s = 0;
	for(int i=1;i<=m;i++)if(node[i].c==0)node[i].w-=mid;
	sort(node+1,node+1+m);
	int cnt = 0;
	for(int i=1;i<=m;i++){
		int a = find(node[i].a),b = find(node[i].b);
		if(a==b)continue;
		p[a] = b;
		s+=node[i].w;
		if(!node[i].c)cnt++;
		
	}
	
	for(int i=1;i<=m;i++)if(node[i].c==0)node[i].w+=mid;
	//cout<<cnt<<"\n";
	return cnt;
	
	
	
}
void solve()
{
	//你想控制答案中某个东西的恰好的出现次数
	//可以使用带权二分答案
	cin>>n>>m>>k;
	
	for(int i=1;i<=m;i++){
		int a,b,w,c;cin>>a>>b>>w>>c;
		node[i] = {a,b,w,c};
	}
	
	int l = -1e5,r = 1e5;
	while(l+1!=r){
		int mid = (l+r)/2;
		if(check(mid)>=k)r = mid;
		else l = mid;
		//cout<<l<<" "<<r<<"\n";
	}
	
	check(r);
	cout<<s+k*r<<"\n";
	
	
	

}

signed main()
{
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

最小生成树计数

调了一下午 不知道自己死在哪里了，发现这道题并查集不能用按秩合并，因为要dfs恢复现场

恶心坏了.......太菜了 吃一堑长一智吧～～

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5+10;
const int inf = 0x3f3f3f3f;
const int mod = 31011;

using namespace std;
int n,m;

struct Edge{
	int x,y,w;
	bool operator<(const Edge&W)const{
		return w<W.w;
	}
}edge[N];
int father[N];


struct Node{
	int l,r;
	int cnt;
}a[N];
int tot;
int sum;

int Find(int x){
	if(x!=father[x])return Find(father[x]);
	return father[x];
}


int Kruskal()
{
	for(int i=1;i<=n;i++)father[i] = i;
	
	sort(edge+1,edge+1+m);
	int cnt = 0;
	
	for(int i=1;i<=m;i++){
		if(edge[i].w!=edge[i-1].w){
			tot++;
			a[tot].l = i;
			a[tot-1].r = i-1;
		}
		
		int x = edge[i].x,y = edge[i].y;
		x = Find(x),y = Find(y);
		if(x==y)continue;
		
		father[x] = y;
		
		cnt++;
		a[tot].cnt++;
		
	}
	
	
	a[tot].r = m;
	
	
	return cnt;
}

void dfs(int x,int now,int s){
	
	
	if(now>a[x].r){
		//cout<<s<<"??\n";
		if(s==a[x].cnt)sum++;
		return;
	}
	
	int fx = Find(edge[now].x),fy = Find(edge[now].y);
	//cout<<fx<<" "<<fy<<"\n";
	if(fx!=fy){
		father[fx] = fy;
		dfs(x,now+1,s+1);
		father[fx] = fx;
		father[fy] = fy;
	}
	
	
	dfs(x,now+1,s);
}


void solve()
{
	cin>>n>>m;
	for(int i=1;i<=m;i++)
		cin>>edge[i].x>>edge[i].y>>edge[i].w;
	
	
	int num = Kruskal();
	
	if(num!=n-1){cout<<0;return;}
	

	
	int res = 1;
	for(int i=1;i<=n;i++)father[i] = i;
	
	for(int i=1;i<=tot;++i){
		sum = 0;
		
		dfs(i,a[i].l,0);
		//cout<<"??"<<"\n";
		//cout<<sum<<"\n";
		res = res*sum%mod;
		
		
		for(int j = a[i].l;j<=a[i].r;++j){
			int fx = Find(edge[j].x);
			int fy = Find(edge[j].y);
			if(fx!=fy)father[fx] = fy;
		}
	}
	

	
	
	cout<<res;

}

signed main()
{
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int _;
	//cin>>_;
	_ = 1;
	while(_--)solve();
	return 0;
}

灬德布罗意的猫灬
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MST.zip_mst
09-24
實作MST 實作MST
最小生成树（MST）
来啦(#^.^#)
11-28 635
目录 一、知识点 二、最小生成树计数 三、例题 一、知识点 1. 生成树定义：在一个有n个点的无向连通图中，取其n-1条边并连接所有的顶点，所得到的子图称为原图的一棵生成树。 2. 树的属性：无环+连通+任意两点之间只有唯一的简单路径+删掉任意边就不连通 3. 最小生成树：各边权和最小的一棵生成树。 4. 最小边原则：图中权值最小的边（如果唯一的话）一定在最小生成树上 5. 唯一...
信息学奥赛一本通 1143：最长最短单词
超级氯化钾的博客
06-02 2554
  1143：最长最短单词 时间限制: 1000 ms         内存限制: 65536 KB 提交数: 2327     通过数: 703  【题目描述】  输入1行句子(不多于200个单词，每个单词长度不超过100)，只包含字母、空格和逗号。单词由至少一个连续的字母构成，空格和逗号都是单词间的间隔。  试输出第1个最长的单词和第1个最短单词。 【输入】 一行句子。 【...
libreoj 10069 「一本通 3.1 练习 4」Tree 题解
LightningUZ的博客
03-15 392
博客观赏效果更佳 题意简述 一个图有 nnn 个点 mmm 条边，每个边是白色或黑色。生成一棵树使得白边的数量恰好是 kkk，并且边权和最小。输出最小的边权和。 1≤n,m≤1051\le n,m\le 10^51≤n,m≤105，边权在 [1,100][1,100][1,100] 之间 思路 我们在跑朴素的 Kruskal 的时候，把每个白边都调的贵一点，或者便宜一点。把白边弄便宜的时候，就会多...
次小生成树（有无重边）
来啦(#^.^#)
12-06 264
一切都从这道题开始.... #10068. 「一本通 3.1 练习 3」秘密的牛奶运输 嗯，然后我去看了次小生成树，踉踉跄跄地做了好久奇奇怪怪的就A了... 然后！突然发现题上说是有重边的！然后我！开始质疑我的代码！一直改呀想呀陷入了怪圈....  对，怪圈....  用Kruskal做本来就是存边的，哪里还用考虑重不重边的问题呀！大概还是自己太蠢了吧... (つД｀)･ﾟ･ 首先，什么是次小...
MST.rar_mst
09-20
Histograms comparaison
MST779 Guide
04-01
MST779开发环境搭建 示例： 1. 安装VMare虚拟机。 2. 安装ubuntu-11.04-desktop-i386.iso，建议选择ubuntu版本的Linux。 3. 安装ToolChain，将aeon-m10.tar.bz2 拷贝到虚拟机中，执行tar xjvf aeon-m10.tar.bz2 –C ...
MST升级工具
10-12
MST升级工具
MST.rar_mst prime
09-19
prime算法的基本思想 1.清空生成树，任取一个顶点加入生成树 2.在那些一个端点在生成树里，另一个端点不在生成树里的边中，选取一条权最小的边，将它和另一个端点加进生成树 3.重复步骤2，直到所有的顶点都进入了...
笔记89：LeetCode_135_分发糖果
weixin_44063383的博客
05-20 377
注：代码随想录中没有很清楚的提起想出方法的思路，只是给出了解决这个问题的大致思路和代码；下面我将介绍一下我的思考过程，并贴出实现代码；aaaa。
力扣HOT100 - 1143. 最长公共子序列
qq_61504864的博客
05-20 389
【代码】力扣HOT100 - 1143. 最长公共子序列。
力扣HOT100 - 72. 编辑距离
qq_61504864的博客
05-20 322
【代码】力扣HOT100 - 72. 编辑距离。
leetcode 打卡#day29 39. 组合总和、40. 组合总和 II、131. 分割回文串
weixin_41835324的博客
05-21 195
【代码】leetcode 打卡#day29 39. 组合总和、40. 组合总和 II、131. 分割回文串。
leetCode-hot100-数组专题之区间问题
m0_49074706的博客
05-23 961
leetCode-hot100-数组专题之区间问题
【力扣一轮】15.三数之和 && 18.四数之和
最新发布
诚。
05-23 280
刚开始是准备用之前的方法哈希进行查找。但是题目中说到不能有重复的元素值。所以直接看视频讲解。视频用到双指针法。先对整个数组进行排序，接着对数组每个元素遍历。如果第一个元素就大于0，那么直接返回空。因为正数列表怎么加都不能为0。left和right以及当前遍历的数值，如果三者相加为正，则说明要减少其和，right要向左移动；如果三者相加为负，则说明要增加其和，left要向右移动。那么去重操作怎么做？👇Q1=》判断还是?A1=》前者如果contine，会把有重复的元素的结果集给筛掉。而后者则不会。
【数组】Leetcode 228. 汇总区间【简单】
FLGB
05-22 323
返回 恰好覆盖数组中所有数字 的 最小有序 区间范围列表。也就是说，nums 的每个元素都恰好被某个区间范围所覆盖，并且不存在属于某个范围但不属于 nums 的数字 x。给定一个 无重复元素 的 有序 整数数组 nums。
力扣：541. 反转字符串 II
icbbm的博客
05-22 527
从字符串开头算起，每计数至。
LeetCode-105-岛屿的最大面积
人间失格的博客
05-21 202
LeetCode-105-岛屿的最大面积
mst instance
08-25
MST（Multiple Spanning Tree）是一种基于MSTP（Multiple Spanning Tree Protocol）的多生成树协议。在MST中，可以配置多个MST实例，每个实例可以包含一组VLAN。通过配置MST实例，可以将不同的VLAN映射到不同的实例...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值