最小生成树练习

最新推荐文章于 2025-05-19 21:37:46 发布
原创 最新推荐文章于 2025-05-19 21:37:46 发布 · 259 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

A - 还是畅通工程

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
#define ll long long
#define clr(a) memset(a,0,sizeof(a))
#define line cout<<"----------------------"<<endl;

const int maxn = 1e6+10;
const int inf = 0x3f3f3f3f;
const int N = 1010;

int n,m;
ll ans ;
int pre[maxn];
struct node{
    int u,v,cost;
}p[maxn];

void init(){
    for(int i=0;i<=n;i++)
        pre[i] = i;
}
bool cmp(node a,node b){
    return a.cost < b.cost;
}
int find(int x){
    if(x == pre[x]) return x;
    else return pre[x] = find(pre[x]);
}
int main(){
    while(scanf("%d",&n)!=EOF&&n){
        clr(p);
        init();
        ans = 0;
        m = n * (n-1) / 2;
        int u,v,cost;
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&u,&v,&cost);
            p[i].u = u;p[i].v = v;p[i].cost = cost;
        }
        sort(p,p+m,cmp);
        for(int i=0;i<m;i++){
            int dx = find(p[i].u);
            int dy = find(p[i].v);
            if(dx != dy){
                pre[dy] = dx;
                ans += p[i].cost;
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

B - Highways

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#define MAX 999999
using namespace std;
int pre[100001];
int n,m;
struct node{
	int u,v;
	int value;
}p[300000];

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

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

bool cmp (node x,node y){
	return x.value<y.value;
}

void mix(int x,int y){
	int fx=find(x);
	int fy=find(y);
	if(fx!=fy){
		pre[fy]=fx;
	}
}

int main(){
	int t,s;
	cin>>t;
	while(t--){
		scanf("%d",&n);
		init(n);
		int k=0;
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				scanf("%d",&s);
				p[k].u =i;
				p[k].v =j;
				p[k++].value =s;
			}
		}
		sort(p,p+k,cmp);
		int dis=0;
		for(int i=0;i<k;i++){
			if(find(p[i].u)!=find(p[i].v)){
				if(p[i].value>dis)
				dis=p[i].value ;
				mix(p[i].u ,p[i].v );
			}
		}
		printf("%d\n",dis);
	}
	return 0;
}

 

C - Networking

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#define MAX 999999
using namespace std;
int pre[100001];
int n,m;
struct node
{
	int u,v;
	int value;
}p[300000];

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

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

bool cmp (node x,node y)
{
	return x.value<y.value;
}

void mix(int x,int y)
{
	int fx=find(x);
	int fy=find(y);
	if(fx!=fy)
	{
		pre[fy]=fx;
	}
}

int main()
{
	while(scanf("%d",&n)!=EOF&&n!=0)
	{
		memset(pre,0,sizeof(pre));
		scanf("%d",&m);
		init(n);
		if(m==0)
			printf("0\n");
		else
		{
			for(int i=0;i<m;i++)
			{
				scanf("%d%d%d",&p[i].u,&p[i].v,&p[i].value);
			}
			int ans=0;
			sort(p,p+m,cmp);
			for(int i=0;i<m;i++)
			{
				int fx=find(p[i].u);
				int fy=find(p[i].v);
				if(fx!=fy)
				{
					pre[fy]=fx;
					ans+=p[i].value; 
				}
			}
			printf("%d\n",ans);
		}
	}
	return 0;
}

D - 畅通工程

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
int pre[111];
struct node
{
	int u,v;
	int value;
}p[111];

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

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

bool cmp (node x,node y)
{
	return x.value<y.value;
}

void mix(int x,int y)
{
	int fx=find(x);
	int fy=find(y);
	if(fx!=fy)
	{
		pre[fy]=fx;
	}
}

int main()
{
	int  n,m,p1,p2;
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		if(n==0)
			return 0;
		for(int i=1;i<=n;i++)
		{
			scanf("%d%d%d",&p[i].u,&p[i].v,&p[i].value);
		}
		sort(p,p+n,cmp);
		int num=0,ans=0;
		init(n);
		for(int i=1;i<=n&&num<m-1;i++)
		{
			int fx=find(p[i].u);
			int fy=find(p[i].v);
			if(fx!=fy)
			{
				pre[fy]=fx;
				num++;
				ans+=p[i].value;
			}
		}
		if(num==m-1)
		{
			printf("%d\n",ans);
		}
		else
		{
			printf("?\n");
		}
	}
	return 0;
}

E - Highways

#include<cstdio>
#include<algorithm>
#include<cstring> 
#include<cmath>
using namespace std;
struct edge
{
	double x,y;
}da[800];
struct node
{
	int u,v;
	double dis;
}e[320000+11];
struct edge2
{
	int a,b;
}data[800];
int par[800],ran[800];
int vis[800][800];
int find(int m)
{
	if(m==par[m])
		return m;
	else
		return par[m]=find(par[m]);
}
void unite(int x,int y)
{
	int fx,fy;
	fx=find(x);
	fy=find(y);
	if(fx==fy)
		return ;
	if(ran[fx]<ran[fy])
		par[fx]=fy;
	else
	{
		par[fy]=fx;
		if(ran[fx]==ran[fy])
			ran[fx]++;
	}
}
bool cmp(node a,node b)
{
	return a.dis <b.dis ;
}
int main() 
{	
	int n;
	while(scanf("%d",&n)!=EOF)
	{
		memset(vis,0,sizeof(vis));
		for(int i=1;i<=n;i++)
		{
			par[i]=i;
			ran[i]=0;
		}
		for(int i=1;i<=n;i++)
		{
			scanf("%lf%lf",&da[i].x,&da[i].y);
		}
		int m;
		scanf("%d",&m);
		for(int i=1;i<=m;i++)
		{
			int a,b;
			scanf("%d%d",&a,&b);
			vis[a][b]=1,vis[b][a]=1;
			unite(a,b);
		}
		int k=0;
		for(int i=1;i<n;i++)
		{
			for(int j=i+1;j<=n;j++)
			{
				e[k].u =i;
				e[k].v =j;
				double a=da[i].x -da[j].x ;
				double b=da[i].y -da[j].y ;
				e[k].dis =sqrt(a*a+b*b);
				k++;
			}
		}
		sort(e,e+k,cmp);
		int p=0;
		for(int i=0;i<k;i++)
		{
			if(vis[e[i].u][e[i].v])
				continue;	
			else 
			{
				if(find(e[i].u)!=find(e[i].v))
				{
					data[p].a =e[i].u ;
					data[p].b =e[i].v ;
					vis[e[i].u][e[i].v]=vis[e[i].v][e[i].u]=1;
					unite(e[i].u,e[i].v);
					p++;
				}		
			}
		}
		for(int i=0;i<p;i++)
		{
			printf("%d %d\n",data[i].a ,data[i].b ); 
		}
	} 
	return 0;
}

F - 畅通工程再续

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#define MAX 99999
using namespace std;
int pre[MAX];
int n,m;
struct node
{
	int x,y;
}p[1000];

struct node1
{
	int x,y;
	double distance;
}pi[751*751];
void init(int n)
{
	for(int i=1;i<=n;i++)
	{
		pre[i]=i;
	}
}

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

bool cmp (node1 x,node1 y)
{
	return x.distance<y.distance;
}

void mix(int x,int y)
{
	int fx=find(x);
	int fy=find(y);
	if(fx!=fy)
	{
		pre[fy]=fx;
	}
}

int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		scanf("%d",&n);
		memset(pre,0,sizeof(pre));
		init(n);
		for(int i=1;i<=n;i++)
		{
			scanf("%d%d",&p[i].x,&p[i].y);
		}
		int s=0;
		for(int i=1;i<n;i++)
		 {
		 	for(int j=i+1;j<=n;j++)
		 	{
		 		pi[s].x =i;
		 		pi[s].y =j;
		 		pi[s++].distance=sqrt((p[i].x-p[j].x)*(p[i].x-p[j].x)+(p[i].y-p[j].y)*(p[i].y-p[j].y));
			 }
		 }
		 sort(pi,pi+s,cmp);
		 double ans=0;
		 for(int i=0;i<s;i++)
		 {
		 	if(find(pi[i].x )!=find(pi[i].y)&&(pi[i].distance<=1000)&&(pi[i].distance>=10))
		 	{
		 		ans+=pi[i].distance;
		 		mix(pi[i].x ,pi[i].y );
			 }
		 }
		 int flag=0;
		 for(int i=1;i<=n;i++)
		 {
		 	if(pre[i]!=pre[1])
		 	{
		 		flag=1;
			 }
		 }
		 if(flag==1)
		 {
		 	printf("oh!\n");
		 }
		 else
		 {
		 	printf("%.1lf\n",ans*100);
		 }
	}
	return 0;
}

G - Agri-Net

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#define MAX 999999
using namespace std;
int pre[100001];
int n,m;
struct node
{
	int u,v;
	int value;
}p[300000];

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

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

bool cmp (node x,node y)
{
	return x.value<y.value;
}

void mix(int x,int y)
{
	int fx=find(x);
	int fy=find(y);
	if(fx!=fy)
	{
		pre[fy]=fx;
	}
}

int main()
{
	int u,v;
	while(scanf("%d",&n)!=EOF)
	{
		int s;
		memset(pre,0,sizeof(pre));
		int k=0;
		init(n);
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++)
			{
				scanf("%d",&s);
				p[k].u=i;
				p[k].v=j;
				p[k++].value=s;
			}
		}
		int t;
	/*	scanf("%d",&t);
		for(int i=1;i<=t;i++)
		{
			scanf("%d%d",&u,&v);
			mix(u,v);
		}*/
		sort(p,p+k,cmp);
		int dis=0;
		for(int i=0;i<k;i++)
		{
			if(find(p[i].u)!=find(p[i].v))
			{
				dis+=p[i].value;
				mix(p[i].u,p[i].v);
			}
		}
		printf("%d\n",dis);
	}
	return 0;
}

H - Constructing Roads

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#define MAX 999999
using namespace std;
int pre[100001];
int n,m;
struct node
{
	int u,v;
	int value;
}p[300000];

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

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

bool cmp (node x,node y)
{
	return x.value<y.value;
}

void mix(int x,int y)
{
	int fx=find(x);
	int fy=find(y);
	if(fx!=fy)
	{
		pre[fy]=fx;
	}
}

int main()
{
	int u,v;
	while(scanf("%d",&n)!=EOF)
	{
		int s;
		memset(pre,0,sizeof(pre));
		int k=0;
		init(n);
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++)
			{
				scanf("%d",&s);
				p[k].u=i;
				p[k].v=j;
				p[k++].value=s;
			}
		}
		int t;
		scanf("%d",&t);
		for(int i=1;i<=t;i++)
		{
			scanf("%d%d",&u,&v);
			mix(u,v);
		}
		sort(p,p+k,cmp);
		int dis=0;
		for(int i=0;i<k;i++)
		{
			if(find(p[i].u)!=find(p[i].v))
			{
				dis+=p[i].value;
				mix(p[i].u,p[i].v);
			}
		}
		printf("%d\n",dis);
	}
	return 0;
}

I - Jungle Roads

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;  
int pre[27];  
struct node  
{  
    int u;  
    int v;  
    int distance;  
}p[80];  
bool cmp(node a, node b)  
{  
    return a.distance < b.distance;  
}  
int find(int x)
{
	if(pre[x]==x) return x;
	return pre[x]=find(pre[x]);
}
void init()
{
	for(int i=0;i<27;i++)
	{
		pre[i]=i;
	}
}
int main()  
{  
    int n, k, distance, number, ans;  
    char start, end;  
    while(cin >> n, n)  
    {  
    	memset(pre,0,sizeof(pre));
        ans = k = 0;  
        init();
        for(int i = 0; i < n- 1; i++)  
        {  
            cin >> start >> number;  
            for(int j = 0; j < number; j++)  
            {  
                cin >> end >> distance;  
                p[k].u = start - 'A';  
                p[k].v = end - 'A';  
                p[k++].distance = distance;  
            }  
        }  
        sort(p, p + k, cmp);  
        for(int i = 0; i < k; i++)  
        {  
            int x = find(p[i].u);  
            int y = find(p[i].v);  
  
            if(x != y)  
            {  
                ans = ans + p[i].distance;  
                pre[y] = x;  
            }  
        }  
        cout << ans << endl;  
    }  
    return 0;  
}

J - Truck History

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#define MAX 2000*2000
using namespace std;  
int pre[MAX];  
struct node1
{
	char str[100];
}a[2001];
struct node  
{  
    int u;  
    int v;  
    int distance;  
}p[MAX];  
bool cmp(node a, node b)  
{  
    return a.distance < b.distance;  
}  
int find(int x)
{
	if(pre[x]==x) return x;
	return pre[x]=find(pre[x]);
}
void init(int n)
{
	for(int i=0;i<n;i++)
	{
		pre[i]=i;
	}
}
int main()  
{  
    int n;
  //  getchar();
    while(scanf("%d",&n)!=EOF&&n!=0)
    {
    	getchar();
    	init(n);
    	for(int i=0;i<n;i++)
    	{
    		gets(a[i].str);
		}
		int k=0;
		for(int i=0;i<n-1;i++)
		{
			for(int j=i;j<n;j++)
			{
				int num=0;
				p[k].u=i;
				p[k].v=j;
				for(int s=0;s<7;s++)
				{
					if(a[i].str[s]!=a[j].str[s])
					{
						num++;
					}
				}
				p[k++].distance=num;
			}
		}
		sort(p,p+k,cmp);
		int ans=0;
		for(int i = 0; i < k; i++)  
        {  
            int x = find(p[i].u);  
            int y = find(p[i].v);  
            if(x != y)  
            {  
                ans = ans + p[i].distance;  
            //    printf("%d    !!!\n",p[i].distance);
                pre[y] = x;  
            }  
        }  
        printf("The highest possible quality is 1/%d.\n",ans);
	}
    return 0;  
}

 

K - 最小生成树一·Prim算法 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define ll long long
#define line cout<<"-------------------------"<<endl;
#define clr(a) memset(a,0,sizeof(a))

const int MAXN = 1e6+10;
const int INF = 0x3f3f3f3f;
const int Mod = 1e9+7;
const int N = 1010;

int n,num;
ll ans ;
int mp[N][N],pre[MAXN];
struct node{
    int u,v;
    int cost;
}p[MAXN];

bool cmp (node a,node b){
    return a.cost < b.cost;
}
void init(){
    for(int i=0;i<=num;i++)
        pre[i] = i;
}
int find(int x){
    if(pre[x] ==  x) return x;
    return pre[x] = find(pre[x]);
}
int main(){
    while(scanf("%d",&n)!=EOF){
        num = 0;
        ans = 0;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                scanf("%d",&mp[i][j]);
                if(i > j){
                    p[num].u = i;
                    p[num].v = j;
                    p[num++].cost = mp[i][j];
                }
            }
        }
        sort(p,p+num,cmp);
        init();
        for(int i=0;i<num;i++){
            int dx = find(p[i].u);
            int dy = find(p[i].v);
            if(dx != dy){
                pre[dy] = dx;
                ans += p[i].cost;
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

L - 最小生成树二·Kruscal算法

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
#define ll long long
#define clr(a) memset(a,0,sizeof(a))

const int maxn =  1e6+10;

int n,m,ans;
int pre[maxn];
struct node{
    int u,v;
    int cost;
}p[maxn];
void init(){
    for(int i=0;i<=n;i++)
        pre[i] = i;
}
int find(int x){
    if(x == pre[x]) return x;
    return pre[x] = find(pre[x]);
}
bool cmp(node a,node b){
    return a.cost < b.cost;
}
int main(){
    while(scanf("%d%d",&n,&m)!=EOF){
        clr(p);
        ans = 0;
        int u,v,cost;
        init();
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&u,&v,&cost);
            p[i].u = u;
            p[i].v = v;
            p[i].cost = cost;
        }
        sort(p,p+m,cmp);
        for(int i=0;i<m;i++){
            int dx = find(p[i].u);
            int dy = find(p[i].v);
            if(dx != dy){
                ans += p[i].cost;
                pre[dy] = dx;
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

 

算法练习：最小生成树 (Minimum Spanning Tree)
weixin_30540691的博客
06-07 574
（注：此贴是为了回答同事提出的一个问题而匆匆写就，算法代码只求得出答案为目的，效率方面还有很大的改进空间） 最小生成树是指对于给定的带权无向图，需要生成一个总权重最小的连通图。其问题描述及算法可以详见：https://en.wikipedia.org/wiki/Minimum_spanning_tree以下我选用其中一个简单的算法描述，编写 Python 代码尝试解决此问题。 下面是同事...
最小生成树基础与习题
weixin_43870697的博客
07-23 3035
目录 图的几个基础概念 Kruskal算法 算法思想 模板 Prim算法 算法思想 模板 例题 A.POJ-1251 Jungle Roads B.POJ-1287 Networking C:POJ-2031 Building a Space Station D:ZOJ-1586 QS Network E:POJ-2349 Arctic...
最小生成树练习题
最新发布
2402_87646581的博客
05-19 850
又到了一年一度的明明生日了，明明想要买 B 样东西，巧的是，这 B 样东西价格都是 A 元。但是，商店老板说最近有促销活动，也就是：如果你买了第 I 样东西，再买第 J 样，那么就可以只花 KI,J​ 元，更巧的是，KI,J​ 竟然等于 KJ,I​。现在明明想知道，他最少要花多少钱。
最小生成树练习1
qq_43450892的博客
02-11 152
今天就做点kruskal的水题，晚一会儿继续做 POJ1251（水水水） #include<cstdio> #include<iostream> #include<algorithm> #include<cmath> #define M 15005 using namespace std; struct edge { int u; i...
最小生成树习题
m0_53203911的博客
05-18 218
最短网络 #include<iostream> #include<cstring> using namespace std; const int N=110; int g[N][N]; int dist[N]; int n; bool st[N]; int prim(){ int res=0; memset(dist,0x3f,sizeof dist); dist[1]=0; for(int i=1;i<=n;i++){ int
smallest_tree.rar_最小生成树_最小生成树 C++
09-19
在压缩包中的"www.pudn.com.txt"可能是算法的源代码注释或者相关说明，而"8.11 最小生成树"可能是一个包含具体例子或练习题的文本文件，帮助理解最小生成树的实现和应用。 学习C++实现的最小生成树算法，不仅可以...
使用C语言实现最小生成树求解的简单方法
09-03
最小生成树是图论中的一个重要概念，用于找到一个无向图中权重最小的边集，这些边连接了图中的所有节点，且不包含任何环路。在实际应用中，如网络设计、交通运输规划等场景中都有广泛的应用。本文将探讨如何使用...
最小生成树--普利姆算法（例题）
weixin_54202978的博客
05-31 2631
7-10 公路村村通 (30 分) 现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。 输入格式: 输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。 输出格式: 输出村村通需要的最低成本。如果输入数据不足以保证畅通，则输出−1，表示需要建设更多公路。 输入样例: 6
最小生成树例题及其总结
热门推荐
tangzhide123yy的博客
11-02 1万+
目录： 洛谷 P2820 局域网 POJ 2421 Constructing Roads 洛谷 P1111 修复公路 洛谷 P2700 逐个击破 洛谷 P1197 [JSOI2008]星球大战 洛谷 P2502 [HAOI2006]旅行 关于最小生成树的问题差不多有如下几个： 1.模板（加一点修改，比如给的所有边的总边权-最小生成树的总边权或者有些边已经建好，求其他的）如第一
最小生成树练习(最短路径练习1）
m0_64045085的博客
05-18 417
最短路径练习
最小生成树习题集(prime,krushal)
weixin_43736492的博客
08-11 8672
Jungle Roads Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 36699 Accepted: 17228 Description The Head Elder of the tropical island of Lagrishan has a problem. A burst of foreign aid mo...
图结构练习——最小生成树
LsMrSUN的博客
08-08 491
图结构练习——最小生成树 Time Limit: 1000ms   Memory limit: 65536K  有疑问？点这里^_^ 题目描述  有n个城市，其中有些城市之间可以修建公路，修建不同的公路费用是不同的。现在我们想知道，最少花多少钱修公路可以将所有的城市连在一起，使在任意一城市出发，可以到达其他任意的城市。   输入  输入包含多组数据，格式如下
最小生成树练习总结
Two_Punch的博客
01-06 489
最小生成树 最小生成树简称MST（Minimum Spanning Tree）,最小生成树算法有Prim算法和Kruskal算法，prim算法其实就是在dijkstra算法上面稍微修改一哈，当然也可以加heap优化，而Kruskal就有点意思了，因为这个算法在解决判断环的问题的时候用了并查集。还是先来书上的描述 书上的代码： 说实话这个并查集用的是真的溜~ poj2421 poj1287 这...
最小生成树训练
Don't Carry
07-10 238
最小生成树训练 文章目录最小生成树训练写在前面高速公路题目描述代码局域网题目描述代码繁忙的都市题目描述代码写在结尾 写在前面 本次练习都是较为简单的最小生成树，利用好Prim以及克鲁斯克拉就可以AC了，本文只讲代码，不理解的同学最好前往 最小生成树 查询 高速公路 题目描述 某个城市有N座村庄。为了方便各村庄的交流，该城市的市长打算在城市间建造一些道路来连接这些城市。建造连接不同村庄的道路的费用可能不一样，而且有一些村庄之间是不可以建造道路的。现在给出M条建造道路的计划，你从中选一些道路来建设，使得整个城市
洛谷P1194 买礼物
10-28 811
题目描述又到了一年一度的明明生日了，明明想要买B样东西，巧的是，这B样东西价格都是A元。 但是，商店老板说最近有促销活动，也就是： 如果你买了第I样东西，再买第J样，那么就可以只花K[I,J]元，更巧的是，K[I,J]竟然等于K[J,I]。 现在明明想知道，他最少要花多少钱。输入输出格式输入格式：第一行两个整数，A,B。 接下来B行，每行B个数，第I行第J个为K[I,J]。 我们保证K[I
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值