最小生成树，POJ和HDU几道题目的解题报告（基于自己的模板）

tham_ tham_ 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 900+累计阅读 927平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄12年
关注
原创 最新推荐文章于 2026-03-25 01:28:44 发布 927 阅读 AI 写同款· GEO 优化 ›
[kuangbin带你飞]专题六 做题顺序与题解 【最小生成树】 随便说点： 博主正在刷kuangbin专题的题目，初学者，没接触过什么算法，刷题的初衷是备战蓝桥杯，后来发现了算法资料大多是针对acm的，挑选kuangbin专题入门也是如此，毕竟这样分类看起来比较有目的的刷题。 所以有的代码比较冗余，越往后面的题解代码变化越大， 代码的风格和算法思想也是在一步步的学习和进步，多多包容，互相借鉴。 建议做题顺序： 做最小生成树专题没最短路和并查集专题时那么吃力... 阅读详情

首先POJ题目：

链接：1251 Jungle Roads

题目大意：纯求最小生成树，结果为最小权值边的和。采用邻接表

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
using namespace std;

#define maxn 30  //最大顶点个数
int n;       //顶点数，边数

struct arcnode  //边结点
{
    int vertex;     //与表头结点相邻的顶点编号
    int weight;     //连接两顶点的边的权值
    arcnode * next; //指向下一相邻接点
    arcnode() {}
    arcnode(int v,int w):vertex(v),weight(w),next(NULL) {}
};

struct vernode      //顶点结点，为每一条邻接表的表头结点
{
    int vex;    //当前定点编号
    arcnode * firarc;   //与该顶点相连的第一个顶点组成的边
}Ver[maxn];

void Init()  //建立图的邻接表需要先初始化，建立顶点结点
{
    for(int i = 1; i <= n; i++)
    {
        Ver[i].vex = i;
        Ver[i].firarc = NULL;
    }
}

void Insert(int a, int b, int w)   //头插法，效率更高，但不能去重边
{
    arcnode * q = new arcnode(b, w);
    if(Ver[a].firarc == NULL)
        Ver[a].firarc = q;
    else
    {
        arcnode * p = Ver[a].firarc;
        q->next = p;
        Ver[a].firarc = q;
    }
}
struct node     //保存key值的结点
{
    int v;
    int key;
    friend bool operator<(node a, node b)   //自定义优先级，key小的优先
    {
        return a.key > b.key;
    }
};

#define INF 0xfffff    //权值上限
int parent[maxn];   //每个结点的父节点
bool visited[maxn]; //是否已经加入树种
node vx[maxn];      //保存每个结点与其父节点连接边的权值
priority_queue<node> q; //优先队列stl实现
void Prim(int s)    //s表示根结点
{
    for(int i = 1; i <= n; i++) //初始化
    {
        vx[i].v = i;
        vx[i].key = INF;
        parent[i] = -1;
        visited[i] = false;
    }
    vx[s].key = 0;
    q.push(vx[s]);
    while(!q.empty())
    {
        node nd = q.top();  //取队首，记得赶紧pop掉
        visited[nd.v] = true;
        q.pop();
        arcnode * p = Ver[nd.v].firarc;
        while(p != NULL)    //找到所有相邻结点，若未访问，则入队列
        {
            if(!visited[p->vertex] && p->weight < vx[p->vertex].key)
            {
                parent[p->vertex] = nd.v;
                vx[p->vertex].key = p->weight;
                vx[p->vertex].v = p->vertex;
                q.push(vx[p->vertex]);
            }
            p = p->next;
        }
    }
}
void Show()     //打印图的邻接表（有权值）
{
    for(int i = 1; i <= n; i++)
    {
        cout << Ver[i].vex;
        arcnode * p = Ver[i].firarc;
        while(p != NULL)
        {
            cout << "->(" << p->vertex << "," << p->weight << ")";
            p = p->next;
        }
        cout << "->NULL" << endl;
    }
}
int main()
{
    int k, d;
    char x, y;
    while(cin >> n && n!=0)
    {
        Init();
        for(int i = 1; i < n; i++)
        {
            cin >> x >> k;
            while(k--)
            {
                cin >> y >> d;
                Insert(x-'A'+1, y-'A'+1, d);
                Insert(y-'A'+1, x-'A'+1, d);
            }
        }
        Prim(1);
        int ans = 0;
        for(int i = 1; i <= n; i++)
            ans += vx[i].key;
        printf("%d\n", ans);
    }
    return 0;
}

链接：1258 Agri-Net

题目大意：求最小生成树，邻接矩阵实现

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;

#define maxn 110
#define INF 100020    //预定于的最大值
int n;   //顶点数、边数
int g[maxn][maxn];      //邻接矩阵表示

struct node     //保存key值的结点
{
    int v;
    int key;
    friend bool operator<(node a, node b)   //自定义优先级，key小的优先
    {
        return a.key > b.key;
    }
};
int parent[maxn];   //每个结点的父节点
bool visited[maxn]; //是否已经加入树种
node vx[maxn];      //保存每个结点与其父节点连接边的权值
priority_queue<node> q; //优先队列stl实现
void Prim(int s)    //s表示根结点
{
    for(int i = 1; i <= n; i++) //初始化
    {
        vx[i].v = i;
        vx[i].key = INF;
        parent[i] = -1;
        visited[i] = false;
    }
    vx[s].key = 0;
    q.push(vx[s]);
    while(!q.empty())
    {
        node nd = q.top();  //取队首，记得赶紧pop掉
        q.pop();
        if(visited[nd.v] == true)   //深意，因为push机器的可能是重复但是权值不同的点，我们只取最小的
            continue;
        int st = nd.v;
        //cout << nd.v << " " << nd.key << endl;
        visited[nd.v] = true;
        for(int j = 1;  j <= n; j++)
        {
            if(j!=st && !visited[j] && g[st][j] < vx[j].key)    //判断
            {
                parent[j] = st;
                vx[j].key = g[st][j];
                q.push(vx[j]);

            }
        }
    }
}
int main()
{
    while(~scanf("%d", &n))
    {
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
            {
                scanf("%d", &g[i][j]);
                if(g[i][j] == 0)
                    g[i][j] = INF;
            }
        Prim(1);
        int ans = 0;
        for(int i = 1; i <= n; i++)
            ans += vx[i].key;
        printf("%d\n", ans);

    }
    return 0;
}

链接：1789 Truck History

题目大意：n种卡车，互相之间的差别为同一位置上不同字母的个数，这相当于每个点的权值，根据这个权值来求最小生成树。

代码，采用邻接矩阵：

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;

#define maxn 2020
#define INF 10    //预定于的最大值
int n;   //顶点数、边数
int g[maxn][maxn];      //邻接矩阵表示

struct node     //保存key值的结点
{
    int v;
    int key;
    friend bool operator<(node a, node b)   //自定义优先级，key小的优先
    {
        return a.key > b.key;
    }
};
bool visited[maxn]; //是否已经加入树种
node vx[maxn];      //保存每个结点与其父节点连接边的权值
priority_queue<node> q; //优先队列stl实现
void Prim(int s)    //s表示根结点
{
    for(int i = 1; i <= n; i++) //初始化
    {
        vx[i].v = i;
        vx[i].key = INF;
        visited[i] = false;
    }
    vx[s].key = 0;
    q.push(vx[s]);
    while(!q.empty())
    {
        node nd = q.top();  //取队首，记得赶紧pop掉
        q.pop();
        if(visited[nd.v] == true)   //深意，因为push机器的可能是重复但是权值不同的点，我们只取最小的
            continue;
        int st = nd.v;
        visited[nd.v] = true;
        for(int j = 1;  j <= n; j++)
        {
            if(j!=st && !visited[j] && g[st][j] < vx[j].key)    //判断
            {
                vx[j].key = g[st][j];
                q.push(vx[j]);
            }
        }
    }
}
char tk[2020][8];
int main()
{
    while(scanf("%d", &n), n)
    {
        for(int i = 1; i <= n; i++)
            scanf("%s", tk[i]);
        for(int i = 1; i < n; i++)
        {
            for(int j = i+1; j <= n; j++)
            {
                int cnt = 0;
                for(int k = 0; k < 7; k++)
                    if(tk[i][k] != tk[j][k])
                        cnt++;
                g[i][j] = g[j][i] = cnt;
            }
        }
        Prim(1);
        int ans = 0;
        for(int i = 1; i <= n; i++)
            ans += vx[i].key;
        printf("The highest possible quality is 1/%d.\n", ans);
    }
    return 0;
}

链接：2485 Highways

题目大意：依然是最小生成树，输出权值最大的边。

代码：

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;

#define maxn 510
#define INF 0xffffff    //预定于的最大值
int n;   //顶点数、边数
int g[maxn][maxn];      //邻接矩阵表示

struct node     //保存key值的结点
{
    int v;
    int key;
    friend bool operator<(node a, node b)   //自定义优先级，key小的优先
    {
        return a.key > b.key;
    }
};
bool visited[maxn]; //是否已经加入树中
node vx[maxn];      //保存每个结点与其父节点连接边的权值
priority_queue<node> q; //优先队列stl实现
void Prim(int s)    //s表示根结点
{
    for(int i = 1; i <= n; i++) //初始化
    {
        vx[i].v = i;
        vx[i].key = INF;
        visited[i] = false;
    }
    vx[s].key = 0;
    q.push(vx[s]);
    while(!q.empty())
    {
        node nd = q.top();  //取队首，记得赶紧pop掉
        q.pop();
        if(visited[nd.v] == true)   //深意，因为push机器的可能是重复但是权值不同的点，我们只取最小的
            continue;
        int st = nd.v;
        visited[nd.v] = true;
        for(int j = 1;  j <= n; j++)
        {
            if(j!=st && !visited[j] && g[st][j] < vx[j].key)    //判断
            {
                vx[j].key = g[st][j];
                q.push(vx[j]);
            }
        }
    }
}
int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= n; j++)
                scanf("%d", &g[i][j]);
            g[i][i] = INF;
        }
        Prim(1);
        int ans = 0;
        for(int i = 1; i <= n; i++)
            if(vx[i].key > ans)
                ans = vx[i].key;
        printf("%d\n", ans);

    }
    return 0;
}

HDOJ

链接：1863 畅通工程

题目大意：求全省畅通最低成本，最小生成树，判断能否生成一棵树，如果能输出最小代价，不能输出 ？ 

代码，采用邻接表：

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;

#define maxn 110  //最大顶点个数
int n, m;       //顶点数，边数

struct arcnode  //边结点
{
    int vertex;     //与表头结点相邻的顶点编号
    int weight;     //连接两顶点的边的权值
    arcnode * next; //指向下一相邻接点
    arcnode() {}
    arcnode(int v,int w):vertex(v),weight(w),next(NULL) {}
};

struct vernode      //顶点结点，为每一条邻接表的表头结点
{
    int vex;    //当前定点编号
    arcnode * firarc;   //与该顶点相连的第一个顶点组成的边
}Ver[maxn];

void Init()  //建立图的邻接表需要先初始化，建立顶点结点
{
    for(int i = 1; i <= n; i++)
    {
        Ver[i].vex = i;
        Ver[i].firarc = NULL;
    }
}

void Insert(int a, int b, int w)   //头插法，效率更高，但不能去重边
{
    arcnode * q = new arcnode(b, w);
    if(Ver[a].firarc == NULL)
        Ver[a].firarc = q;
    else
    {
        arcnode * p = Ver[a].firarc;
        q->next = p;
        Ver[a].firarc = q;
    }
}

struct node     //保存key值的结点
{
    int v;
    int key;
    friend bool operator<(node a, node b)   //自定义优先级，key小的优先
    {
        return a.key > b.key;
    }
};

#define INF 999999999    //权值上限
int parent[maxn];   //每个结点的父节点
bool visited[maxn]; //是否已经加入树种
node vx[maxn];      //保存每个结点与其父节点连接边的权值
priority_queue<node> q; //优先队列stl实现
void Prim(int s)    //s表示根结点
{
    for(int i = 1; i <= n; i++) //初始化
    {
        vx[i].v = i;
        vx[i].key = INF;
        parent[i] = -1;
        visited[i] = false;
    }
    vx[s].key = 0;
    q.push(vx[s]);
    while(!q.empty())
    {
        node nd = q.top();  //取队首，记得赶紧pop掉
        q.pop();
        if(visited[nd.v] == true)
            continue;
        visited[nd.v] = true;
        arcnode * p = Ver[nd.v].firarc;
        while(p != NULL)    //找到所有相邻结点，若未访问，则入队列
        {
            if(!visited[p->vertex] && p->weight < vx[p->vertex].key)
            {
                parent[p->vertex] = nd.v;
                vx[p->vertex].key = p->weight;
                vx[p->vertex].v = p->vertex;
                q.push(vx[p->vertex]);
            }
            p = p->next;
        }
    }
}
int main()
{
    int a, b, w;
    while(scanf("%d%d", &m, &n), m)
    {
        Init();
        while(m--)
        {
            scanf("%d%d%d", &a, &b, &w);
            if(a != b)
            {
                Insert(a, b, w);
                Insert(b, a, w);
            }
        }
        Prim(1);
        int cnt = 0, ans = 0;
        for(int i = 1; i <= n; i++)
        {
            if(parent[i] == -1)
                cnt++;
            ans += vx[i].key;
        }
        if(cnt >= 2)
            printf("?\n");
        else
            printf("%d\n", ans);

    }
    return 0;
}

链接：1875 畅通工程再续

题目大意：依然是最小生成树，但是点换成了坐标表示，权值表示为两点的距离，求最小权值的和。

代码，邻接表：

#include <iostream>
#include <cstdio>
#include <cmath>
#include <queue>
using namespace std;

#define maxn 110  //最大顶点个数
int n;       //顶点数，边数

struct arcnode  //边结点
{
    int vertex;     //与表头结点相邻的顶点编号
    double weight;     //连接两顶点的边的权值
    arcnode * next; //指向下一相邻接点
    arcnode() {}
    arcnode(int v,double w):vertex(v),weight(w),next(NULL) {}
};

struct vernode      //顶点结点，为每一条邻接表的表头结点
{
    int vex;    //当前定点编号
    arcnode * firarc;   //与该顶点相连的第一个顶点组成的边
}Ver[maxn];

void Init()  //建立图的邻接表需要先初始化，建立顶点结点
{
    for(int i = 1; i <= n; i++)
    {
        Ver[i].vex = i;
        Ver[i].firarc = NULL;
    }
}

void Insert(int a, int b, double w)  //尾插法，插入以a为起点，b为终点，权为w的边，效率不如头插，但是可以去重边
{
    arcnode * q = new arcnode(b, w);
    if(Ver[a].firarc == NULL)
        Ver[a].firarc = q;
    else
    {
        arcnode * p = Ver[a].firarc;
        q->next = p;
        Ver[a].firarc = q;
    }
}

struct node     //保存key值的结点
{
    int v;
    double key;
    friend bool operator<(node a, node b)   //自定义优先级，key小的优先
    {
        return a.key > b.key;
    }
};

#define INF 1e10    //权值上限
#define eps 1e-9
int parent[maxn];   //每个结点的父节点
bool visited[maxn]; //是否已经加入树种
node vx[maxn];      //保存每个结点与其父节点连接边的权值
priority_queue<node> q; //优先队列stl实现
void Prim(int s)    //s表示根结点
{
    for(int i = 1; i <= n; i++) //初始化
    {
        vx[i].v = i;
        vx[i].key = INF;
        parent[i] = -1;
        visited[i] = false;
    }
    vx[s].key = 0;
    q.push(vx[s]);
    while(!q.empty())
    {
        node nd = q.top();  //取队首，记得赶紧pop掉
        q.pop();
        if(visited[nd.v] == true)
            continue;
        visited[nd.v] = true;
        arcnode * p = Ver[nd.v].firarc;
        while(p != NULL)    //找到所有相邻结点，若未访问，则入队列
        {
            if(!visited[p->vertex] && p->weight < vx[p->vertex].key)
            {
                parent[p->vertex] = nd.v;
                vx[p->vertex].key = p->weight;
                vx[p->vertex].v = p->vertex;
                q.push(vx[p->vertex]);
            }
            p = p->next;
        }
    }
}
void Show()     //打印图的邻接表（有权值）
{
    for(int i = 1; i <= n; i++)
    {
        cout << Ver[i].vex;
        arcnode * p = Ver[i].firarc;
        while(p != NULL)
        {
            cout << "->(" << p->vertex << "," << p->weight << ")";
            p = p->next;
        }
        cout << "->NULL" << endl;
    }
}
struct Point
{
    int x, y;
}PT[maxn];
double dis(Point p1, Point p2)
{
    return 100.0*sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
}
int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        for(int i = 1; i <= n; i++)
            scanf("%d%d", &PT[i].x, &PT[i].y);
        Init();
        for(int i = 1; i < n; i++)
            for(int j = i+1; j <= n; j++)
            {
                double d = dis(PT[i], PT[j]);
                if(1000.00 - d > eps || d -100000.00 > eps)
                    continue;
                Insert(i, j, d);
                Insert(j, i, d);
            }
        Prim(1);
        int cnt = 0;
        double ans = 0;
        for(int i = 1; i <= n; i++)
        {
            if(parent[i] == -1)
                cnt++;
            ans += vx[i].key;
            if(cnt == 2)
                break;
        }
        if(cnt == 2)
            printf("oh!\n");
        else
            printf("%.1lf\n", ans);
    }
    return 0;
}

链接：1879

题目大意：这道题问题在于其中有些边已经存在，即有些路已经被修建好了，我们只需要将已经建好的边的权值置为0就必定会加入到最小生成树中

问题：这道题用Prim暂时还没过，应该是有什么坑数据，还在钻研

下面贴Kruskal的代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

#define maxn 110
struct eage
{
    int u, v, w;
}EG[5050];
int parent[maxn];
int n, m;
bool cmp(eage a, eage b)
{
    return a.w < b.w;
}
int Find(int x)
{
    if(parent[x] == -1) return x;
    return Find(parent[x]);
}
void Kruskal()
{
    for(int i = 1; i <= n; i++)
        parent[i] = -1;
    sort(EG+1, EG+m+1, cmp);
    int ans = 0;
    for(int i = 1; i <= m; i++)
    {
        int x = Find(EG[i].u);
        int y = Find(EG[i].v);
        if(x != y)
        {
            ans += EG[i].w;
            parent[x] = y;
        }
    }
    printf("%d\n", ans);
}
int main()
{
    int w, f;
    while(scanf("%d", &n), n)
    {
        m = n*(n-1)/2;
        for(int i = 1; i <= m; i++)
        {
            scanf("%d%d%d%d", &EG[i].u, &EG[i].v, &w, &f);
            if(f == 1)
                w = 0;
            EG[i].w = w;
        }
        Kruskal();
    }
    return 0;
}


收录于
Algorithm

当前文章被收录于：

Algorithm
30 篇文章 0 人学习
订阅专栏 查看详情
Data_Structure

当前文章被收录于：

Data_Structure
20 篇文章 0 人学习
订阅专栏 查看详情
标签
#POJ和HDU的图论最小生成树相关练习 #最小生成树练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
计算机组成原理（第三版）唐朔飞-第六章计算机的运算方法-课后习题(1-16) 阅读详情

相关推荐

低速信号设计之 ESPI 篇

ESPI 是 Intel 推出的增强型串行外设接口，基于 SPI 发展而来，新增 Reset# 和 Alert# 信号，采用点对点主从通信模型，最高速率达 33MHz，支持半双工与 DMA 传输。 其物理接口含 10 条线路，通信协议分物理层、数据链路层等四层。布局布线需关注信号完整性、电源完整性，还得考虑与 SPI 的兼容性。 ESPI 广泛应用于计算机系统（连接 BIOS、电源管理器等）和工业控制领域，具有引脚少、功耗低等优势，但设计复杂且存在兼容性挑战。

qq_16237389的博客 1385

从拉普拉斯矩阵说到谱聚类

从谱聚类说到拉普拉斯矩阵 0 引言 11月1日上午，机器学习班第7次课，邹博讲聚类（PPT），其中的谱聚类引起了自己的兴趣，他从最基本的概念：单位向量、两个向量的正交、方阵的特征值和特征向量，讲到相似度图、拉普拉斯矩阵，最后讲谱聚类的目标函数和其算法流程。 课后自己又琢磨了番谱聚类跟拉普拉斯矩阵，打算写篇博客记录学习心得， 若有不足或建议，欢迎随时不吝指出，thanks。

结构之法 算法之道 8万+

手把手用ROS实现Ego-Planner动态避障：无人机撞树问题终结方案

本文详细介绍了如何在ROS和Gazebo仿真环境中，通过配置和调优Ego-Planner算法，实现无人机的动态避障功能。文章深入解析了其基于局部梯度优化的核心思想，提供了从环境搭建、参数详解到代码集成的完整实践指南，并分享了实战排错经验，旨在彻底解决无人机在复杂动态场景中的碰撞问题。

weixin_29031161的博客 1633

prim最小生成树算法原理

prim 最小生成树算法原理 主要需要了解算法的原理、算法复杂度、优缺点 、刻画和度量指标 评价等 可以查阅相关的文献，这部分内容主要整合了两篇博客的内容 分别是：http://blog.youkuaiyun.com/tham_/article/details/46048907 这一篇重点在于算法的复杂度 http://blog.youkuaiyun.com/hnust_xiehonghao/article/deta

LynnUCAS的专栏 1万+

【四旋翼】pixhawk2.4.8-地面站配置-APM固件-四旋翼从装机到试飞

因为MP版本和APM版本的适配问题，真的真的是很大一个坑。最好先走别人走过的路，走通了再去自由发挥，不然白白浪费时间。下面提供我试飞成功过的版本。下面提供任意版本固件和地面站的下载方法。

xifan的博客 3万+

实战指南：在UE5中高效集成Entt(ECS)框架

本文提供了一份在虚幻引擎5中高效集成Entt ECS框架的实战指南。针对UE5项目在处理大规模动态实体时的性能瓶颈，详细讲解了如何通过数据驱动的ECS架构进行优化。内容包括前期环境准备、核心构建步骤、创建首个ECS子系统以及与UE原生系统的数据同步技巧，旨在帮助开发者快速掌握集成方法，提升游戏逻辑的执行效率。

weixin_29002209的博客 158

HDU上一道最小生成树模板题的练习

Statistics Eddy's picture Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 65536/32768K (Java/Other) Total Submission(s) : 7   Accepted Submission(s) : 4 Font: Times New Roman | Verdana |

u011481752的专栏 899

TSMaster如何用珠海创芯CAN卡实现高效CAN通信（附完整驱动安装指南）

本文详细介绍了如何使用TSMaster软件与珠海创芯CAN卡实现高效CAN通信，包括驱动安装、系统配置、ControlCAN.dll替换及TSMaster集成配置等关键步骤。通过实战指南和故障排除技巧，帮助工程师快速搭建稳定可靠的CAN通信测试环境，适用于汽车电子和工业控制等领域。

weixin_29201859的博客 482

最小生成树Prim模板

Prim适用于稠密图，对于给定坐标求最小生成树的题目再合适不过。 e.g.  畅通工程再续 http://acm.hdu.edu.cn/showproblem.php?pid=1875 Freckles http://poj.org/problem?id=2560 这里贴出Hdu 1875 的代码 #include "iostream" #include "stdio.h"

Rachel Zhang的专栏 4589

日前日内多阶段多时间尺度源荷储协调调度（matlab代码）

多阶段多时间尺度的协调调度的优势是考虑新能源出力的波 动性与随机性，需求响应负荷的不确定性会对电网制定的日前调度计划准确性造成影响，也就是能够更加精准的进行调度和分析，优化结果的可用性更强。在这方面论文里面，金力的《考虑特性分布的储能电站接入的电网多时间尺度源储荷协调调度策略》就考虑了日前日内实时三个阶段调度，每个阶段考虑了不同负荷需求响应策略，同时考虑了负荷波动性的影响，具有很强的参考意义。 目录 一、模型 二、程序运行 三、程序链接 一、模型 负荷需求响应考虑电价型和激励型两种，电.

zhangxd212489的博客 7915

字节系,ali系,ks,pdd最新抓包方案

各大厂安卓逆向

qq_38759383的博客 1145

最小生成树详解+经典例题

零、邻接表的构建与使用： https://www.cnblogs.com/icode-girl/p/5273209.html 这个大佬讲的很好； 附代码：（邻接表创建与遍历） #include<iostream> #include<cstdio> using namespace std; int u[31],v[31],w[31],fir[31],sec[31]; int ...

Bearing in mind forever！ 6924

微信小程序 - 真机调试请求异常 Provisional headers are shown，微信小程序开发者工具调试没问题就真机测试时出现请求报错（微信小程序请求接口提示Provisional h）

微信小程序开发 Request Headers: Provisional headers are shown，微信开发工具请求正常,真机调试和上线之后出现 Provisional headers are shown，微信小程序开发工具调试没问题，真机调试Provisional headers are shown，在开发工具调试，请求正常没问题，使用真机调试，请求异常，微信小程序真机调试时后台是本地服务器，显示“Provisional headers are shown”问题解决，微信小程序websocket

🏆 前端领域优质创作者 1万+

模板题目（更新ing）

并查集： Poj-1182 食物链 // 思路：对每个节点维护其到根节点的偏移量（偏移量代表种类关系）。 // par[x]表示x的根节点，rel[x]表示x与根节点的偏移量。 // rel[x]=0表示x与根节点为同类，1表示根节点吃x，2代表x吃根节点。 // 同类/不同类时，如何判断关系是否矛盾以及如何合并两顶点所在的集合。 #include&amp;amp;amp;amp;amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;amp;

ó 259

Camera2Demo

在Camera2 的基础上进行封装，使得Camera2一堆初始化逻辑与Activity分离，降低耦合度，完成预览拍照并保存的操作

VC中sqlite的使用

在VC中对sqlite的使用，实现数据库大批数据的快速插入，读取数据库中的数据在ListCtrl中显示

BZOJ、HDU、POJ等评测平台的部分题目梳理

题目

Hawo11的博客 1149

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明，包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

hdu图论题目分类

=============================以下是最小生成树+并查集====================================== 【HDU】 1213 How Many Tables 基础并查集★ 1272 小希的迷宫 基础并查集★ 1325&&poj1308 Is It A Tree? 基础并查集★ 1856 More is better ...

weixin_30625691的博客 251

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

HDU——1863 畅通工程（最小生成树问题）

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1863 题意：有m个村庄，还给出了n条道路的具体信息。问你能否使m个村庄畅通，且最小花费是多少？ 解题思路：这道题关键是在于最小花费，即求生成树的最小权值之和。也就是求最小生成树，由于数据量比较小，我们使用Prim算法或Kruskal算法都行，我这里使用的是Prim算法。 AC代码： /* *邮箱：unique_powerhouse@qq.com *blog:https://me.youkuaiyun.com/hzf070

pursuit的博客 625

|题目分类|BZOJ、Poj、Hdu题目分类

BZOJ:[数论]BZOJ 1477：裸的扩展欧几里得算法 [线段树]BZOJ 1593：经典线段树模型 [2-SAT]BZOJ 1823：2-SAT经典模型 [平衡树]BZOJ 2028：求大于x的最小值，set可以过 [树形DP]BZOJ 2060：经典树形DP模型 [2-SAT]BZOJ 2199：2-SAT经典模型 [树形DP, 缩点]BZOJ 2427：缩点后跑树上背包 [平

博客停更，请到"再见，优快云"文章中找新博客地址 2744

HDU1232畅通工程 POJ1611 嫌犯 并查集问题（c/c++实现）

HDU1232畅通工程 题目概述： http://acm.hdu.edu.cn/showproblem.php?pid=1232 并查集模板： #define N 9999 int f[N];//存放当前下表位置的父亲 void init(int n){ //初始化每个人的爸爸为自己 for(int i=0;i<n;i++){ f[i]=i; } return; } int Fin...

我要夺回那失落的荣光 364

专题六 最小生成树

文章目录专题六 最小生成树POJ 1251 Jungle RoadsPOJ 1287 NetworkingPOJ 2031 Building a Space StationPOJ 2421 Constructing RoadsZOJ 1586 QS NetworkPOJ 1789 Truck HistoryPOJ 2349 Arctic NetworkPOJ 1751 HighwaysPOJ 1258 Agri-NetPOJ 3026 Borg MazePOJ 1679 The Unique MSTHDU

m0_49959202的博客 329

CSUST 7月31日 并查集 & 最小生成树

这一次的练习基本都是一个模板，一个代码改来改去可以A几道题。这次题目也充满滑稽性，还有就是大部分都是中文题，看着舒服多了，不用去死抠某个单词的意思是什么，也不会因为担心哪句话看不懂而影响做题思路，更重要的是不会看着头晕。 练习地址：http://acm.hust.edu.cn/vjudge/contest/view.action?cid=85388#overview Problem A

平爷ZXP 738

最小生成树

最小生成树         一个有 n 个结点的连通图的最小生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的权值总和最小的边。 刘汝佳>P343详细介绍了最小生成树相关的知识。         下面直接给出Kruskal算法的模板： #include #include #include #include #include using namespace std

code 2339

hdu 图论的题目（转）

=============================以下是最小生成树+并查集====================================== 【HDU】 1213 How Many Tables 基础并查集★ 1272 小希的迷宫 基础并查集★ 1325&&poj1308 Is It A Tree? 基础并查集★ 1856 More is better

莫道青天真无道，能逍遥时且逍遥！ 7264

POJ 2485 Highways && HDU1102（20/200）

题目链接：Highways 没看题，看了输入输出。就有种似曾相识的感觉，果然和HDU1102 题相似度99%，可是也遇到一坑 cin输入居然TLE，cin的缓存不至于这么狠吧，题目非常水。矩阵已经告诉你了。就敲个模板就是了，5分钟。1A 题意就是打印，最小生成树的最大边权。改了改输入，水过 这个题完了。我的个人POJ计划进度以完毕 20/200，这当中主要是图论的题...

weixin_34357962的博客 92

图论_图论好题题号

【HDU】 1213 How Many Tables 基础并查集★ 1272 小希的迷宫 基础并查集★ 1325&&poj1308 Is It A Tree? 基础并查集★ 1856 More is better 基础并查集★ 1102 Constructing Roads 基础最小生成树★ 1232 畅通工程 基础并查集★ 1233 还是畅通工程 基础最小生成树★ 1863 畅通

janvinal的专栏 903

最小生成树+并查集模板

#include #include #include #include using namespace std; #define inf 0x3f3f3f3f int a[2001][2001]; struct node { char b[8]; } s[2001]; int qz(char x[],char y[]) { int sum=0,i; for(i=0;i<7;

xunalove的博客 614
上一篇： 图算法 最小生成树邻接表 Kruskal算法（并查集）
下一篇： 图算法 单源最短路径 Dijkstra算法（邻接表/邻接矩阵+优先队列STL)
点赞 1
评论 0
书签 书签 0
tham_
tham_
博客等级 码龄12年 233粉丝 105原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值