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

最新推荐文章于 2019-10-06 13:09:02 发布
最新推荐文章于 2019-10-06 13:09:02 发布
阅读量158 收藏
点赞数 1
分类专栏： 最小生成树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41855962/article/details/96565393
版权

F - Truck History

 建图：每两个字符串之间的相同位置不同字符的个数

prim

#include<stdio.h>
#include<iostream>
#include<string.h>
#define INF 0x3f3f3f3f
using namespace std;
/*
*  数组tree[]用来记录最小生成树的节点
*  数组lowdis[]记录从起点到其余所有点的距离并不断更新
*  数组map[][]记录所有数据两点之间的距离
*  n是所有节点的数目，begin_1是起点
*  Mindis是最小生成树的长度
主函数中输入前需要：
for(int i=1; i<=n; i++)
{
    for(int j=1; j<=n; j++)
        if(i==j) a[i][j]=0;
        else a[i][j]=INF;
}
*/
const int N = 2000+10;
int tree[N];
int b[N];
int lowdis[N];
int a[N][N];
int n;
int begin_1;
void prime()
{
    int i,j,Min,Mindis=0,next;
    memset(tree,0,sizeof(tree));
    for(i=1;i<=n;i++)
    {
        lowdis[i]=a[begin_1][i];//用lowdis[]数组记录下从起点到剩下所有点的距离
    }
    tree[begin_1]=1;//标记起点（即最小生成树中的点）
    for(i=1;i<n;i++)
    {
        Min=INF;
        for(j=1;j<=n;j++)
        {
            if(!tree[j]&&Min>lowdis[j])
            {
                Min=lowdis[j];//求出从当前起点到其余所有点的距离中最短的
                next=j;
            }
        }
        Mindis+=Min;//记录下整条最小树的长度
        tree[next]=1;
        for(j=1;j<=n;j++)
        {
            if(!tree[j]&&lowdis[j]>a[next][j])
            lowdis[j]=a[next][j];//更新lowdis[]数组
        }
    }
    printf("The highest possible quality is 1/%d.\n",Mindis);
}
void init(){
    for(int i=1; i<=n; i++){
        for(int j=1; j<=n; j++)
            if(i==j) a[i][j]=0;
            else a[i][j]=INF;
    }
}
int main(){
    int i,j,k,t;
    char str[N][100];
	while(~ scanf("%d",&n))
	{
	    init();
		if(n == 0)
		break;
		for(i = 1;i<=n;i ++)
		{
			scanf("%s",str[i]);
			for(j = 1;j<=i;j ++)
			{
				t = 0;
				for(k = 0;k<7;k ++)
				{
					if(str[i][k]!=str[j][k])
					t ++;
					a[i][j] = a[j][i] = t;
				}
			}
		}
		begin_1 = 1;
        prime();
	}
    return 0;
}

G - Arctic Network

求最小生成树第K大（小）边的题目。

prim 中的lowdis【】数组对应输出就可以了

#include<stdio.h>
#include<iostream>
#include<string.h>
#define INF 0x3f3f3f3f
#include<math.h>
#include<algorithm>
using namespace std;
/*
*  数组tree[]用来记录最小生成树的节点
*  数组lowdis[]记录从起点到其余所有点的距离并不断更新
*  数组map[][]记录所有数据两点之间的距离
*  n是所有节点的数目，begin_1是起点
*  Mindis是最小生成树的长度
主函数中输入前需要：
for(int i=1; i<=n; i++)
{
    for(int j=1; j<=n; j++)
        if(i==j) map_1[i][j]=0;
        else map_1[i][j]=INF;
}
*/
const int N = 500+10;
int tree[N];
double lowdis[N];
double map_1[N][N];
int n,m;
int begin_1;
int k;
void prime()
{
    int i,j,next;
    double Min,Mindis = 0;
    memset(tree,0,sizeof(tree));
    for(i=1;i<=n;i++)
    {
        lowdis[i]=map_1[begin_1][i];//用lowdis[]数组记录下从起点到剩下所有点的距离
    }
    tree[begin_1]=1;//标记起点（即最小生成树中的点）
    for(i=1;i<n;i++)
    {
        Min=INF;
        for(j=1;j<=n;j++)
        {
            if(!tree[j]&&Min>lowdis[j])
            {
                Min=lowdis[j];//求出从当前起点到其余所有点的距离中最短的
                next=j;
            }
        }
        Mindis+=Min;//记录下整条最小树的长度
        tree[next]=1;
        for(j=1;j<=n;j++)
        {
            if(!tree[j]&&lowdis[j]>map_1[next][j])
            lowdis[j]=map_1[next][j];//更新lowdis[]数组
        }
    }
    sort(lowdis+1,lowdis+1+n);
    printf("%.2f\n",lowdis[n-k+1]);
}
void init(){
    for(int i=1; i<=n; i++){
        for(int j=1; j<=n; j++)
            if(i==j) map_1[i][j]=0;
            else map_1[i][j]=INF;
    }
}
struct node{
    double x,y;
}t1[N];
int main(){
    int t;
    cin>>t;
    while(t --)
    {

        cin>>k>>n;
        init();
        for(int i=1; i<=n; i++){
            cin>>t1[i].x>>t1[i].y;
        }
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<i; j++)
            {

                    double xx = sqrt((t1[i].x-t1[j].x)*(t1[i].x-t1[j].x)+(t1[i].y-t1[j].y)*(t1[i].y-t1[j].y));
                    map_1[i][j] = map_1[j][i] = xx;
            }
        }
        begin_1 = 1;
        prime();
    }
    return 0;
}

H - Highways

 输出建边的路径

lowdis加个标记记录下，输出就可以了，加个fa【】数组同理，，v表示他的父亲节点是什么

#include<stdio.h>
#include<iostream>
#include<string.h>
#define INF 0x3f3f3f3f
#include<math.h>
#include<algorithm>
using namespace std;
/*
*  数组tree[]用来记录最小生成树的节点
*  数组lowdis[]记录从起点到其余所有点的距离并不断更新
*  数组map[][]记录所有数据两点之间的距离
*  n是所有节点的数目，begin_1是起点
*  Mindis是最小生成树的长度
主函数中输入前需要：
for(int i=1; i<=n; i++)
{
    for(int j=1; j<=n; j++)
        if(i==j) map_1[i][j]=0;
        else map_1[i][j]=INF;
}
*/
const int N = 2000+10;
int tree[N];
//double lowdis[N];
double map_1[N][N];
int n,m;
int begin_1;
int k;
struct node{
    double len;
    int v;
}lowdis[N];
void prime()
{
    int i,j,next;
    double Min,Mindis = 0;
    memset(tree,0,sizeof(tree));
    for(i=1;i<=n;i++)
    {
        lowdis[i].v = 1;
        lowdis[i].len=map_1[begin_1][i];//用lowdis[]数组记录下从起点到剩下所有点的距离
    }
    tree[begin_1]=1;//标记起点（即最小生成树中的点）
    int cnt = 0;
    for(i=1;i<n;i++)
    {
        Min=INF;
        for(j=1;j<=n;j++)
        {
            if(!tree[j]&&Min>lowdis[j].len)
            {
                Min=lowdis[j].len;//求出从当前起点到其余所有点的距离中最短的
                next=j;
            }
        }
        Mindis+=Min;//记录下整条最小树的长度
        tree[next]=1;
        for(j=1;j<=n;j++)
        {
            if(!tree[j]&&lowdis[j].len>map_1[next][j])
            {
                lowdis[j].len=map_1[next][j];//更新lowdis[]数组
                lowdis[j].v = next;
            }
        }
    }

    for(int i=1; i<=n; i++)
    {
        if(lowdis[i].len>0)
        printf("%d %d\n",i,lowdis[i].v);
    }
}
//void init(){
//    for(int i=1; i<=n; i++){
//        for(int j=1; j<=n; j++)
//            if(i==j) map_1[i][j]=0;
//            else map_1[i][j]=INF;
//    }
//}
struct node1{
    double x,y;
}t1[N];
int main(){
    scanf("%d",&n);
    {
//        init();
        for(int i=1; i<=n; i++){
            scanf("%lf%lf",&t1[i].x,&t1[i].y);
        }
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<i; j++)
            {
                    double xx = sqrt((t1[i].x-t1[j].x)*(t1[i].x-t1[j].x)+(t1[i].y-t1[j].y)*(t1[i].y-t1[j].y));
                    map_1[i][j] = map_1[j][i] = xx;
            }
        }
        int m;
        scanf("%d",&m);
        while(m --)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            map_1[x][y] = map_1[y][x] = -1;
        }
        begin_1 = 1;
        prime();
    }
    return 0;
}

I - Agri-Net

 模板，，直接套就可以了

#include<stdio.h>
#include<iostream>
#include<string.h>
#define INF 0x3f3f3f3f
using namespace std;
/*
*  数组tree[]用来记录最小生成树的节点
*  数组lowdis[]记录从起点到其余所有点的距离并不断更新
*  数组map[][]记录所有数据两点之间的距离
*  n是所有节点的数目，begin_1是起点
*  Mindis是最小生成树的长度
主函数中输入前需要：
for(int i=1; i<=n; i++)
{
    for(int j=1; j<=n; j++)
        if(i==j) map_1[i][j]=0;
        else map_1[i][j]=INF;
}
*/
const int N = 1000+10;
int tree[N];
int lowdis[N];
int map_1[N][N];
int n;
int begin_1;
void prime()
{
    int i,j,Min,Mindis=0,next;
    memset(tree,0,sizeof(tree));
    for(i=1;i<=n;i++)
    {
        lowdis[i]=map_1[begin_1][i];//用lowdis[]数组记录下从起点到剩下所有点的距离
    }
    tree[begin_1]=1;//标记起点（即最小生成树中的点）
    for(i=1;i<n;i++)
    {
        Min=INF;
        for(j=1;j<=n;j++)
        {
            if(!tree[j]&&Min>lowdis[j])
            {
                Min=lowdis[j];//求出从当前起点到其余所有点的距离中最短的
                next=j;
            }
        }
        Mindis+=Min;//记录下整条最小树的长度
        tree[next]=1;
        for(j=1;j<=n;j++)
        {
            if(!tree[j]&&lowdis[j]>map_1[next][j])
            lowdis[j]=map_1[next][j];//更新lowdis[]数组
        }
    }
    printf("%d\n",Mindis);
}
void init(){
    for(int i=1; i<=n; i++){
        for(int j=1; j<=n; j++)
            if(i==j) map_1[i][j]=0;
            else map_1[i][j]=INF;
    }
}
int main(){
    while(cin>>n && n)
    {
        init();
        for(int i=1; i<=n; i++){
            for(int j=1; j<=n; j++)
            {
                scanf("%d",&map_1[i][j]);
            }
        }
        begin_1 = 1;
        prime();
    }
    return 0;
}

J - Borg Maze

最小生成树+BFS

题意：n*m的矩阵，空格代表可以走，#表示墙，A和S代表其中的点

建图：把图中各个字母之间的BFS的路径值存为边权值，

bfs，，坑，，

vj交不了，去poj交的

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <bitset>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <algorithm>
using namespace std;
#define mem(a,b) memset(a,(b),sizeof(a))
#define CL(a, b) memset(a, b, sizeof(a))
#define debug(x) cout<<"debug"<<x<<"\n"
#define sc scanf
#define pr printf
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
#define ll long long
int gcd(int a,int b)
{
    return b==0?a:gcd(b,a%b);
}
const int N = 2600+10;
struct node{
    int x,y,step;
};
queue<node>mmp;
int a[60][60];
int tree[N];
int lowdis[N];
int map_1[N][N];
int n;
int begin_1;
char maze[60][60];
int vis[60][60];
int dir[][4]={{-1,0},{0,-1},{0,1},{1,0}};
void prime()
{
    int i,j,Min,Mindis=0,next;
    memset(tree,0,sizeof(tree));
    memset(lowdis,0,sizeof(lowdis));
    for(i=1;i<=n;i++)
    {
        lowdis[i]=map_1[begin_1][i];//用lowdis[]数组记录下从起点到剩下所有点的距离
    }
    tree[begin_1]=1;//标记起点（即最小生成树中的点）
    for(i=1;i<n;i++)
    {
        Min=INF;
        for(j=1;j<=n;j++)
        {
            if(!tree[j]&&Min>lowdis[j])
            {
                Min=lowdis[j];//求出从当前起点到其余所有点的距离中最短的
                next=j;
            }
        }
        Mindis+=Min;//记录下整条最小树的长度
        tree[next]=1;
        for(j=1;j<=n;j++)
        {
            if(!tree[j]&&lowdis[j]>map_1[next][j])
            lowdis[j]=map_1[next][j];//更新lowdis[]数组
        }
    }
    printf("%d\n",Mindis);
}
void init(){
    for(int i=1; i<=n; i++){
        for(int j=1; j<=n; j++)
            if(i==j) map_1[i][j]=0;
            else map_1[i][j]=INF;
    }
}
void init_vis(int n1,int m1)
{
    for(int i=0; i<n1; i++)
    {
        for(int j=0; j<m1; j++)
        {
            if(maze[i][j] == '#')
            {
                vis[i][j] = 1;
            }
            else
            {
                vis[i][j] = 0;
            }
        }
    }
}
void bfs(int x,int y)
{
    int u,v;
    while(!mmp.empty())
    {
        mmp.pop();
    }
    node qq;
    qq.x = x;
    qq.y = y;
    qq.step = 0;
    u = a[x][y];
    vis[x][y] = 1;
    mmp.push(qq);
    while(!mmp.empty())
    {
        node mm;
        int xx,yy,ss;
        mm = mmp.front();
        mmp.pop();
        xx = mm.x;
        yy = mm.y;
        ss = mm.step;
        if(a[xx][yy] != -1)
        {
            v = a[xx][yy];
            map_1[u][v] = ss;
        }
        for(int i=0; i<4; i++)
        {
            if(!vis[xx+dir[i][0]][yy+dir[i][1]])
            {
                mm.x = xx+dir[i][0];
                mm.y = yy+dir[i][1];
                mm.step = ss+1;
                vis[mm.x][mm.y] = 1;
                mmp.push(mm);
            }
        }
    }
}
int main()
{

    int t;
    scanf("%d",&t);
    int n1,m1;
    while(t --)
    {
        int cnt = 0;
        memset(a,-1,sizeof(a));
        scanf("%d%d",&m1,&n1);
        gets(maze[0]);//就是这里，我把它换成fflush（stdin）就不行
        for(int i=0; i<n1; i++)
        {
            gets(maze[i]);
            for(int j=0; j<m1; j++)
            {
                if(maze[i][j] == 'A' || maze[i][j] == 'S')
                {
                    a[i][j] = ++cnt;
                }
            }
        }
        n = cnt;
        init();
        for(int i=0; i<n1; i++)
        {
            for(int j=0; j<m1; j++)
            {
                if(a[i][j] != -1)
                {
                    init_vis(n1,m1);

                    bfs(i,j);
                }
            }
        }
        begin_1 = 1;
        prime();
    }
    return 0;
}

K - The Unique MST

 次小生成树（模板题）

题意：判断最小生成树是否唯一

最小生成树的结果和次小生成树的结果比对就，可以判断最小生成树是否唯一

#include<stdio.h>
#include<iostream>
#include<string.h>
#define INF 0x3f3f3f3f
using namespace std;
/*
*  数组tree[]用来记录最小生成树的节点
*  数组lowdis[]记录从起点到其余所有点的距离并不断更新
*  数组map[][]记录所有数据两点之间的距离
*  n是所有节点的数目，begin_1是起点
*  Mindis是最小生成树的长度
主函数中输入前需要：
for(int i=1; i<=n; i++)
{
    for(int j=1; j<=n; j++)
        if(i==j) map_1[i][j]=0;
        else map_1[i][j]=INF;
}
*/
const int N = 200+10;
int tree[N];
int lowdis[N];
int map_1[N][N];
int n;
int begin_1;
/*新开的*/
int Max[N][N]; //Max[i][j]表示在最小生成树中从i到j的路径中的最大边权
bool used[N][N];
int pre[N];
int MST,_MST;
int ans ;
int prime()
{
    int i,j,Min,Mindis=0,next;
    for(i=1;i<=n;i++)
    {
        pre[i] = 1;
        lowdis[i]=map_1[begin_1][i];//用lowdis[]数组记录下从起点到剩下所有点的距离
    }
    tree[begin_1]=1;//标记起点（即最小生成树中的点）
    pre[begin_1] = -1;
    for(i=1;i<n;i++)
    {
        Min=INF;
        int p = -1;
        for(j=1;j<=n;j++)
        {
            if(!tree[j]&&Min>lowdis[j])
            {
                Min=lowdis[j];//求出从当前起点到其余所有点的距离中最短的
                p = j;
            }
        }
        Mindis+=Min;//记录下整条最小树的长度
        tree[p]=1;
        used[p][pre[p]] = used[pre[p]][p] = false;
        for(j=1;j<=n;j++)
        {
            if(tree[j])
            {
                Max[j][p] = Max[p][j] = max(Max[pre[p]][j],lowdis[p]);
            }
            else
            {
                if(map_1[p][j]<lowdis[j])
                {
                    lowdis[j] = map_1[p][j];
                    pre[j] = p;
                }
            }
        }
    }
    return Mindis;
}
int second_prim()
{
    int ans=INF;
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
            if(used[i][j]) ans=min(ans,MST+map_1[i][j]-Max[i][j]);
    return ans;
}
void init(){
    memset(tree,0,sizeof(tree));
    memset(used,false,sizeof(used));
    memset(Max,-1,sizeof(Max));
    for(int i=1; i<=n; i++){
        for(int j=1; j<=n; j++)
            if(i==j) map_1[i][j]=0;
            else map_1[i][j]=INF;
    }
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--)
    {

        int m;
        scanf("%d%d",&n,&m);
        init();
        for(int i=0; i<m; i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            map_1[a][b]=map_1[b][a]=c;
            used[a][b]=used[b][a]=true;
        }
        begin_1 = 1;
        MST=prime();
        _MST=second_prim();
        if(MST==_MST) printf("Not Unique!\n");
        else printf("%d\n",MST);
    }
    return 0;
}

L - 还是畅通工程

 模板题：

#include<stdio.h>
#include<iostream>
#include<string.h>
#define INF 0x3f3f3f3f
using namespace std;
/*
*  数组tree[]用来记录最小生成树的节点
*  数组lowdis[]记录从起点到其余所有点的距离并不断更新
*  数组map[][]记录所有数据两点之间的距离
*  n是所有节点的数目，begin_1是起点
*  Mindis是最小生成树的长度
主函数中输入前需要：
for(int i=1; i<=n; i++)
{
    for(int j=1; j<=n; j++)
        if(i==j) map_1[i][j]=0;
        else map_1[i][j]=INF;
}
*/
const int N = 100+10;
int tree[N];
int lowdis[N];
int map_1[N][N];
int n;
int begin_1;
void prime()
{
    int i,j,Min,Mindis=0,next;
    memset(tree,0,sizeof(tree));
    for(i=1;i<=n;i++)
    {
        lowdis[i]=map_1[begin_1][i];//用lowdis[]数组记录下从起点到剩下所有点的距离
    }
    tree[begin_1]=1;//标记起点（即最小生成树中的点）
    for(i=1;i<n;i++)
    {
        next = -1;
        Min=INF;
        for(j=1;j<=n;j++)
        {
            if(!tree[j]&&Min>lowdis[j])
            {
                Min=lowdis[j];//求出从当前起点到其余所有点的距离中最短的
                next=j;
            }
        }
        Mindis+=Min;//记录下整条最小树的长度
        tree[next]=1;
        for(j=1;j<=n;j++)
        {
            if(!tree[j]&&lowdis[j]>map_1[next][j])
            lowdis[j]=map_1[next][j];//更新lowdis[]数组
        }
    }
    printf("%d\n",Mindis);
}
void init(){
    for(int i=1; i<=n; i++){
        for(int j=1; j<=n; j++)
            if(i==j) map_1[i][j]=0;
            else map_1[i][j]=INF;
    }
}
int main(){
    while(cin>>n && n)
    {
        init();
        for(int i=1; i<=n*(n-1)/2; i++){
            int a,b,c;
            cin>>a>>b>>c;
            map_1[a][b] = map_1[b][a] = min(map_1[a][b],c);
        }
        begin_1 = 1;
        prime();
    }
    return 0;
}

M - Jungle Roads

 同A题

N - 畅通工程再续

 模板题

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<math.h>
#define INF 1000000.0
using namespace std;
/*
*  数组tree[]用来记录最小生成树的节点
*  数组lowdis[]记录从起点到其余所有点的距离并不断更新
*  数组map[][]记录所有数据两点之间的距离
*  n是所有节点的数目，begin_1是起点
*  Mindis是最小生成树的长度
主函数中输入前需要：
for(int i=1; i<=n; i++)
{
    for(int j=1; j<=n; j++)
        if(i==j) map_1[i][j]=0;
        else map_1[i][j]=INF;
}
*/
const int N = 200+10;
int tree[N];
double lowdis[N];
double map_1[N][N];
int n;
int begin_1;
double prime()
{
    int i,j,next;
    double Mindis=0;
    memset(tree,0,sizeof(tree));
    for(i=1; i<=n; i++)
    {
        lowdis[i]=map_1[begin_1][i];//用lowdis[]数组记录下从起点到剩下所有点的距离
    }
    tree[begin_1]=1;//标记起点（即最小生成树中的点）
    for(i=1; i<n; i++)
    {
        double Min=INF;
        int next = -1;
        for(j=1; j<=n; j++)
        {
            if(!tree[j]&&Min>lowdis[j])
            {
                Min=lowdis[j];//求出从当前起点到其余所有点的距离中最短的
                next=j;
            }
        }
        Mindis+=Min;//记录下整条最小树的长度
        tree[next]=1;
        for(j=1; j<=n; j++)
        {
            if(!tree[j]&&lowdis[j]>map_1[next][j])
                lowdis[j]=map_1[next][j];//更新lowdis[]数组
        }
    }
    return Mindis;
}
void init()
{
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=n; j++)
            if(i==j) map_1[i][j]=0;
            else map_1[i][j]=INF;
    }
}

struct point
{
    double x,y;
} p[N];
double len(point a,point b)
{
    double x=a.x-b.x;
    double y=a.y-b.y;
    return sqrt(x*x+y*y);
}
int main()
{
    int t;
    //freopen("N.txt","r",stdin);
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        init();
        for(int i=1; i<=n; i++)
        {
            scanf("%lf %lf",&p[i].x,&p[i].y);
            for(int j=1; j<i; j++)
            {
                double Len=len(p[i],p[j]);
                if(Len>=10&&Len<=1000)	map_1[i][j]=map_1[j][i]=Len;
            }
        }
        begin_1 = 1;
        double ans=prime();
        if(ans!=INF)
        {
            printf("%.1f\n",ans*100);
        }
        else
        {
            printf("oh!\n");
        }
    }
    return 0;
}

 

POJ 2031 Building a Space Station(kuangbin带你飞 专题六：最小生成树)
01-31 357
大概题意就是要有n个空间站，给出三维坐标以及半径（是个球）..要每两个空间站之间都能互相通信啥的...问建立的最小花费是多少..花费就是两个空间站的距离...如果小于0当做0.. 两球之间的距离等于两球心之间的距离减去两球的半径...就能算出球面之间的距离了..然后最小生成树走起 #include #include #include #include #include #include usi
POJ 3026 Borg Maze(kuangbin带你飞 专题六：最小生成树，完结)
02-01 404
没看题，直接看了样例，大概意思就是给了一张迷宫吧，要把所有的A和S全部链接起来需要的最小边权...就是求最小生成树....but...，边的顶点和距离完全要自己解决...顶点编号直接从在图上跑了一遍给编了序号1-k，代表第几个点，-1代表墙，0代表可走的地方，对每个点进行一次bfs，并且在bfs过程中建立这个点对其他点的边..最后跑完最小生成树就行了. 不得不说调试了好久...以为是bfs写搓了
[kuangbin带你飞]专题六 最小生成树
weixin_34212762的博客
09-11 92
A. POJ 1251 Jungle Roads 模板题 #include<iostream> #include<stdio.h> #include<string.h> #include<math.h> #include<algorithm> #include<vector> #include<...
先来先服务短作业优先高响应比调度作业C语言实现
fushengguan的博客
11-27 3390
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include&lt;dos.h&gt; #include&lt;time.h&gt; #include&lt;conio.h&gt; #include&lt;string.h&gt; #define INF 1000000.0 typedef char string[10]; struct ...
最长上升子序列问题
ACM_hades的博客
04-18 351
题目描述： 又有一长为n的数列：a0,a1,…,an−1a_0,a_1,…,a_{n-1}a0​,a1​,…,an−1​.求出这个序列中最长的上升子序列长度。上升子序列指的是对于任意i&lt;ji&lt;ji<j都满足ai&lt;aja_i&lt;a_jai​<aj​。 限制条件： i≤n≤1000i≤n≤1000i≤n≤1000 0≤ai≤100...
hdu1162 Eddy's picture (prim最小生成树)
不可不戒
07-17 674
#include #include #include #include #define INF 1000000.0 #define MAXN 102 using namespace std; //最小生成树 double map[MAXN][MAXN],dist[MAXN]; double px[MAXN],py[MAXN]; int visited[MAXN]; double dist
QAQ……#define INF 0x3f3f3f3f 原来是定义成无穷大
Karen_Yu_的博客
11-28 7508
经常在参观大佬的博客的时候看到这种写法，百思不得其解， “0x3f3f3f3f ”是什么？/*虽然，似乎，好像刚刚看过进制转换……就当我选择性失忆吧*/ ------------------- 0x3f3f3f3f的十进制是1061109567，也就是10^9级别的（和0x7fffffff（32-bit int的最大值）一个数量级），而一般场合下的数据都是小于10^9的，所以它可以作为无穷
[kuangbin带你飞]专题六 最小生成树 题解+总结
放荡者的茶会
10-06 1881
kuangbin带你飞：点击进入新世界 最短路算法模板：点击进入新世界 总结： 本人算是初学者中的初学者，欢迎交流~ kuangbin的专题确实是理解最短路的一大途径，这篇博客主要记录题解，顺便总结最短路的题型。 A.模板题 参考1 . 6 . 10 B.变形最短路 （求最大边权的最小值or最小边权的最大值） 参考2 . 3 C.变形最短路 （求往返最短路的最大值） 参考4 D....
[kuangbin带你飞]专题六 最小生成树 A~E
qq_41855962的博客
07-20 210
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; ...
poj 1860 Currency Exchange ([kuangbin带你飞]专题四 最短路练习)
Strive
11-10 494
Description Several currency exchange points are working in our city. Let us suppose that each point specializes in two particular currencies and performs exchange operations only with these curren
[kuangbin带你飞]专题六 最小生成树 G - Arctic Network
_Vampire的博客
07-31 39
G - Arctic Network 题目链接：https://vjudge.net/contest/66965#problem/G 题目： 国防部(DND)希望通过无线网络连接几个北部前哨站。在建立网络时将使用两种不同的通信技术：每个前哨站都有一个无线电收发器，一些前哨站还有一个卫星信道。任何带卫星频道的两个前哨站都可以通过卫星进行通信，无论其位置如何。否则，两个前哨只有当它们之间的距...
KMP总结归纳 题型汇总(kuangbin带你飞专题16)
vaeloverforever的博客
08-27 722
前序：花了好几天才把带你飞系列的KMP专题(地址：https://vjudge.net/contest/246969#overview搞定，刷了很多题，发现KMP可以用来解决这几类问题： ①单个字符串匹配问题（s1在s2中匹配）：这个用strstr(const char* big, const char* small)函数也可以，这个函数返回small在big函数中首次出现的地址，没有出现就返回...
组合数学之六 —— 差分序列&Stirling数
Coco_T的博客
01-20 6570
前言：好久没有学数学了 前几天loli给高一的讲课涉及到了本章内容，所以来普及一波 差分序列 基本概念 设 是一个序列，我们定义的（一阶）差分序列为： 很简单吧，就是我们经常使用的差分啊 但是我们在叙述ta的定义的时候，加了一个词：一阶 有一阶就有二阶，有二阶就有三阶~ppp阶啊： ppp阶差分序列： 我们定义一个序列的0阶差分序列就是ta自己： 我们可以把一个序...
MATLAB-四连杆机构的仿真+项目源码+文档说明
11-17
<项目介绍> - 四连杆机构的仿真 --m3_1.m: 位置问题求解 --m2_1.m: 速度问题求解 --FourLinkSim.slx: Simlink基于加速度方程的仿真 --FourLinkSim2.slx: Simscape简化模型仿真 --FourLinkSim3.slx: Simscape CAD模型仿真 - 不懂运行，下载完可以私聊问，可远程教学 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。 --------
ridge_regression:用于岭回归的python代码（已实现以预测下个月的CO2浓度）
11-17
ridge_regression 用于岭回归的python代码（已实现以预测下个月的CO2浓度） 资料可用性 文件 Ridge.py ：标准函数和Ridge回归函数window_make.py ：使用滑动窗口方法制作大小为p（窗口大小）的时间序列列表。 Final_version.ipynb ：使用Co2数据对代码进行实验
Polygon3-3.0.8-cp35-cp35m-win_amd64.whl.rar
11-17
python whl离线安装包 pip安装失败可以尝试使用whl离线安装包安装 第一步 下载whl文件，注意需要与python版本配套 python版本号、32位64位、arm或amd64均有区别 第二步 使用pip install XXXXX.whl 命令安装，如果whl路径不在cmd窗口当前目录下，需要带上路径 WHL文件是以Wheel格式保存的Python安装包， Wheel是Python发行版的标准内置包格式。 在本质上是一个压缩包，WHL文件中包含了Python安装的py文件和元数据，以及经过编译的pyd文件， 这样就使得它可以在不具备编译环境的条件下，安装适合自己python版本的库文件。 如果要查看WHL文件的内容，可以把.whl后缀名改成.zip，使用解压软件（如WinRAR、WinZIP）解压打开即可查看。 为什么会用到whl文件来安装python库文件呢？ 在python的使用过程中，我们免不了要经常通过pip来安装自己所需要的包， 大部分的包基本都能正常安装，但是总会遇到有那么一些包因为各种各样的问题导致安装不了的。 这时我们就可以通过尝试去Python安装包大全中（whl包下载）下载whl包来安装解决问题。
【java毕业设计】风俗文化管理系统源码（ssm+mysql+说明文档+LW）.zip
11-17
功能说明： 系统主要分为系统管理员和用户两个部分，系统管理员主要功能包括首页,个人中心,用户管理,节日风俗管理,饮食风俗管理，服饰风俗管理，礼仪风俗管理，信仰风俗管理，建筑风俗管理,我的收藏管理，留言板管理，论坛管理，系统管理。 环境说明： 开发语言：Java 框架：ssm，mybatis JDK版本：JDK1.8 数据库：mysql 5.7及以上 数据库工具：Navicat11及以上 开发软件：eclipse/idea Maven包：Maven3.3及以上 服务器：tomcat7及以上
中国城市温度历史数据（2000-2020）-最新全集.zip
最新发布
11-17
中国城市温度历史数据（2000-2020）-最新全集.zip
ACM算法模板：最小树形图详解
在给定的信息中，我们关注的是"最小树形图"这个主题，它通常指的是求解最小生成树的问题，这是一种经典的图论算法。在这个问题中，我们给定一个加权无向图，目标是找到一个边的子集，这些边连接了所有的顶点，并且这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值