11月27日 connect the city

本文探讨了一个关于通过构建道路来重新连接因海平面上升而断开的城市的问题。使用了图论中的并查集算法实现最小生成树,通过两种不同的代码实现方式解决了问题,并对比了性能。

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

本题我一直TLE,所以代码转载自https://www.cnblogs.com/13224ACMer/p/4639351.html


Description

In 2100, since the sea level rise, most of the cities disappear. Though some survived cities are still connected with others, but most of them become disconnected. The government wants to build some roads to connect all of these cities again, but they don’t want to take too much money.  

Input

The first line contains the number of test cases.
Each test case starts with three integers: n, m and k. n (3 <= n <=500) stands for the number of survived cities, m (0 <= m <= 25000) stands for the number of roads you can choose to connect the cities and k (0 <= k <= 100) stands for the number of still connected cities.
To make it easy, the cities are signed from 1 to n.
Then follow m lines, each contains three integers p, q and c (0 <= c <= 1000), means it takes c to connect p and q.
Then follow k lines, each line starts with an integer t (2 <= t <= n) stands for the number of this connected cities. Then t integers follow stands for the id of these cities.

Output

For each case, output the least money you need to take, if it’s impossible, just output -1.

Sample Input

1
6 4 3
1 4 2
2 6 1
2 3 5
3 4 33
2 1 2
2 1 3
3 4 5 6

Sample Output

1

我自己的代码(感觉没问题,但是tle了,不知道是不是qsort的问题?)
#include<cstdio>
#include<algorithm>
#include<cstdlib>
using namespace std;
int rt[505], pr[505],Rank[505],ncase,sum;
struct edge{
	int a, b, le;
}eg[25005];
int n, m, k;
int cnt;
int find(int x)
{
	int tmp=x,root = x;
	while (pr[root] != root)
	{
		root = pr[root];
	}
	/*while (pr[tmp] != root)
	{
		rt[tmp] = root;
		tmp = pr[tmp];
	}*/
	return root;
}
void Union(int x,int y)
{
	int a = find(x);
	int b = find(y);
	pr[a] = b;
	/*else
	{
		pr[b] = a;
		if (Rank[a] == Rank[b])Rank[a]++;
	}*/
}
int cmp(const void* a, const void* b)
{
	return ((edge*)a)->le - ((edge*)b)->le;
}
void init(int n)
{
	for (int i = 0; i <= n; i++)
	{
		pr[i] = i;
		rt[i] = i;
	}
	sum = 0;
}
int main()
{
	scanf("%d", &ncase);
	for (int i = 0; i < ncase; i++)
	{
		int nedge = 0;
		scanf("%d%d%d", &n, &m, &k);
		int q = n;
		init(n);
		for (int j = 0; j < m; j++)
		{
			scanf("%d%d%d", &eg[j].a, &eg[j].b, &eg[j].le);
		}
		for (int j = 0; j < k; j++)
		{
			int num,rr;
			scanf("%d", &num);
			scanf("%d", &rr);
			for (int k = 0; k < num-1; k++)
			{
				int b;
				scanf("%d", &b);
				q -= (b-1);
				Union(b, rr);
			}
		}
		qsort(eg, m, sizeof(eg[0]), cmp);
		for (int j = 0; j < m && nedge!=q-1; j++)
		{
			int x = find(eg[j].a);
			int y = find(eg[j].b);
			if (x != y)
			{
				Union(eg[j].a, eg[j].b);
				sum += eg[j].le;
				nedge++;
			}
		}
		if (nedge < q - 1) printf("%d\n", -1);
		else printf("%d\n", sum);
	}
	return 0;
}
别人的代码
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
struct node{
   int u;
   int v;
   int w;
}que[100000];
int father[505];
bool cmp(struct node a,struct node b){
    return a.w<b.w;
}
void init(int n){
    for(int i=1;i<=n;i++)
    father[i]=i;
}
int find(int u){
    if(father[u]!=u)
    father[u]=find(father[u]);
    return father[u];
}
int main(){
    int t;
    scanf("%d",&t);
    while(t--){
       int n,m,k;
       int edge=0,sum=0;
       scanf("%d%d%d",&n,&m,&k);
       init(n);
       for(int i=0;i<m;i++){
          scanf("%d%d%d",&que[i].u,&que[i].v,&que[i].w);
       }
       sort(que,que+m,cmp);
       for(int i=1;i<=k;i++){
           int cnt,root;
           scanf("%d%d",&cnt,&root);
           for(int j=1;j<cnt;j++){
              int x;
              scanf("%d",&x);
              int c1=find(x),c2=find(root);
              if(c1!=c2){
                  father[c1]=c2;
              }
           }
       }
      for(int i=1;i<=n;i++)
      if(father[i]==i)
      edge++;
      bool flag=false;
      for(int i=0;i<m;i++){
          int tx=find(que[i].u),ty=find(que[i].v);
          if(tx!=ty){
              father[tx]=ty;
              sum+=que[i].w;
              edge--;
          }
          if(edge==1){
            flag=true;
            break;
          }
 
      }
      if(flag)
      printf("%d\n",sum);
      else
      printf("-1\n");
 
    }
    return 0;
}
希望大神指导指导


内容概要:本文围绕直流微电网中带有恒功率负载(CPL)的DC/DC升压转换器的稳定控制问题展开研究,提出了一种复合预设性能控制策略。首先,通过精确反馈线性化技术将非线性不确定的DC转换器系统转化为Brunovsky标准型,然后利用非线性扰动观测器评估负载功率的动态变化和输出电压的调节精度。基于反步设计方法,设计了具有预设性能的复合非线性控制器,确保输出电压跟踪误差始终在预定义误差范围内。文章还对比了多种DC/DC转换器控制技术如脉冲调整技术、反馈线性化、滑模控制(SMC)、主动阻尼法和基于无源性的控制,并分析了它们的优缺点。最后,通过数值仿真验证了所提控制器的有效性和优越性。 适合人群:从事电力电子、自动控制领域研究的学者和工程师,以及对先进控制算法感兴趣的研究生及以上学历人员。 使用场景及目标:①适用于需要精确控制输出电压并处理恒功率负载的应用场景;②旨在实现快速稳定的电压跟踪,同时保证系统的鲁棒性和抗干扰能力;③为DC微电网中的功率转换系统提供兼顾瞬态性能和稳态精度的解决方案。 其他说明:文中不仅提供了详细的理论推导和算法实现,还通过Python代码演示了控制策略的具体实现过程,便于读者理解和实践。此外,文章还讨论了不同控制方法的特点和适用范围,为实际工程项目提供了有价值的参考。
内容概要:该论文介绍了一种名为偏振敏感强度衍射断层扫描(PS-IDT)的新型无参考三维偏振敏感计算成像技术。PS-IDT通过多角度圆偏振光照射样品,利用矢量多层光束传播模型(MSBP)和梯度下降算法迭代重建样品的三维各向异性分布。该技术无需干涉参考光或机械扫描,能够处理多重散射样品,并通过强度测量实现3D成像。文中展示了对马铃薯淀粉颗粒和缓步类动物等样品的成功成像实验,并提供了Python代码实现,包括系统初始化、前向传播、多层传播、重建算法以及数字体模验证等模块。 适用人群:具备一定光学成像和编程基础的研究人员,尤其是从事生物医学成像、材料科学成像领域的科研工作者。 使用场景及目标:①研究复杂散射样品(如生物组织、复合材料)的三维各向异性结构;②开发新型偏振敏感成像系统,提高成像分辨率和对比度;③验证和优化计算成像算法,应用于实际样品的高精度成像。 其他说明:PS-IDT技术相比传统偏振成像方法具有明显优势,如无需干涉装置、无需机械扫描、可处理多重散射等。然而,该技术也面临计算复杂度高、需要多角度数据采集等挑战。文中还提出了改进方向,如采用更高数值孔径(NA)物镜、引入深度学习超分辨率技术等,以进一步提升成像质量和效率。此外,文中提供的Python代码框架为研究人员提供了实用的工具,便于理解和应用该技术。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值