第三章图论（六）

最新推荐文章于 2024-05-18 14:30:20 发布
最新推荐文章于 2024-05-18 14:30:20 发布
阅读量187 收藏
点赞数
分类专栏： 算法提高课
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QinLaoDeMaChu/article/details/106387187
版权

最小生成树的扩展应用

在这里插入图片描述
例题：新的开始
在这里插入图片描述
【输入样例】
4
5
4
4
3
0 2 2 2
2 0 3 3
2 3 0 4
2 3 4 0
【输出样例】
9
在这里插入图片描述
————————————————————————————————————————————————————

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    static int INF = Integer.MAX_VALUE >> 1;
    static int N = 310;
    static int n;
    static int[][] w = new int[N][N];
    static int[] dist = new int[N];
    static boolean[] st = new boolean[N];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        for (int i = 1; i <= n; i++) {
            w[0][i] = sc.nextInt();
            w[i][0] = w[0][i];
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                w[i][j] = sc.nextInt();
            }
        }
        System.out.println(prim());
    }

    private static int prim() {
        Arrays.fill(dist, INF);
        dist[0] = 0;
        int res = 0;
        for (int i = 0; i < n + 1; i++) {
            int t = -1;
            for (int j = 0; j <= n; j++) {
                if (!st[j] && (t == -1 || dist[t] > dist[j])) {
                    t = j;
                }
            }
            res += dist[t];
            st[t] = true;
            for (int j = 0; j <= n; j++) {
                dist[j] = Math.min(dist[j], w[t][j]);
            }
        }
        return res;
    }
}

例题：北极通讯网络
在这里插入图片描述

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
    static int INF = Integer.MAX_VALUE >> 1;
    static int N = 510;
    static int M = N * N / 2;
    static int n;
    static int k;
    static int m;
    static Edge[] e = new Edge[M];
    static Pair[] q = new Pair[M];
    static int[] p = new int[N];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        k = sc.nextInt();
        for (int i = 0; i < n; i++) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            q[i] = new Pair(x, y);
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < i; j++) {
                e[m++] = new Edge(i, j, get_dist(q[i], q[j]));
            }
        }
        Arrays.sort(e, 0, m, new Comparator<Edge>() {
            @Override
            public int compare(Edge o1, Edge o2) {
                if (o1.w <= o2.w) {
                    return -1;
                } else {
                    return 1;
                }
            }
        });
        for (int i = 0; i < n; i++) {
            p[i] = i;
        }
        int cnt = n;
        double res = 0;
        for (int i = 0; i < m; i++) {
            if (cnt <= k) break;
            int a = find(e[i].a);
            int b = find(e[i].b);
            double w = e[i].w;
            if (a != b) {
                p[a] = b;
                cnt--;
                res = w;
            }
        }
        System.out.printf("%.2f\n", res);
    }

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

    private static double get_dist(Pair a, Pair b) {
        int dx = a.x - b.x;
        int dy = a.y - b.y;
        return Math.sqrt(dx * dx + dy * dy);
    }
}
class Pair{
    int x;
    int y;

    public Pair(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
class Edge{
    int a;
    int b;
    double w;

    public Edge(int a, int b, double w) {
        this.a = a;
        this.b = b;
        this.w = w;
    }
}

例题：346. 走廊泼水节
在这里插入图片描述

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
    static int N = 6010;
    static int n;
    static Edge[] e = new Edge[N];
    static int[] p = new int[N];
    static int[] size = new int[N];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
        while (T-- > 0) {
            n = sc.nextInt();
            for (int i = 0; i < n - 1; i++) {
                int a = sc.nextInt();
                int b = sc.nextInt();
                int w = sc.nextInt();
                e[i] = new Edge(a, b, w);
            }
            Arrays.sort(e, 0, n - 1, new Comparator<Edge>() {
                @Override
                public int compare(Edge o1, Edge o2) {
                    return o1.w - o2.w;
                }
            });
            for (int i = 1; i <= n; i++) {
                p[i] = i;
                size[i] = 1;
            }
            int res = 0;
            for (int i = 0; i < n - 1; i++) {
                int a = find(e[i].a);
                int b = find(e[i].b);
                int w = e[i].w;
                if (a != b) {
                    res += (size[a] * size[b] - 1) * (w + 1);
                    size[b] += size[a];
                    p[a] = b;
                }
            }
            System.out.println(res);
        }
    }

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

class Edge{
    int a;
    int b;
    int w;

    public Edge(int a, int b, int w) {
        this.a = a;
        this.b = b;
        this.w = w;
    }
}

在这里插入图片描述

例题：秘密的牛奶运输
【题目描述】
Farmer John 要把他的牛奶运输到各个销售点。运输过程中，可以先把牛奶运输到一些销售点，再由这些销售点分别运输到其他销售点。 运输的总距离越小，运输的成本也就越低。低成本的运输是 Farmer John 所希望的。不过，他并不想让他的竞争对手知道他具体的运输方案，所以他希望采用费用第二小的运输方案而不是最小的。现在请你帮忙找到该运输方案。
【输入】
第一行是两个整数 N,M，表示顶点数和边数；
接下来 M行每行 3 个整数，x,y,z，表示一条路的两端 x,y 和距离 z。
【输出】
仅一行，输出第二小方案。
【输入样例】
4 4
1 2 100
2 4 200
2 3 250
3 4 100
【输出样例】
450
【提示】
数据范围：
对于全部数据，1≤N≤2000,1≤M≤20000,1≤z≤109​​ ，数据可能有重边。
——————————————————————————————————————————————————————

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
    static int N = 510;
    static int M = 10010;
    static int n;
    static int m;
    static Edge[] edge = new Edge[M];
    static int[] p = new int[N];
    static int[][] dist = new int[N][N];
    static int[] h = new int[N];
    static int[] e = new int[N * 2];
    static int[] w = new int[N * 2];
    static int[] ne = new int[N * 2];
    static int idx;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        Arrays.fill(h, -1);
        for (int i = 0; i < m; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            int w = sc.nextInt();
            edge[i] = new Edge(a, b, w);
        }
        Arrays.sort(edge, 0, m, new Comparator<Edge>() {
            @Override
            public int compare(Edge o1, Edge o2) {
                return o1.w - o2.w;
            }
        });
        for (int i = 1; i <= n; i++) {
            p[i] = i;
        }
        long sum = 0;
        for (int i = 0; i < m; i++) {
            int a = edge[i].a;
            int b = edge[i].b;
            int w = edge[i].w;
            int pa = find(a);
            int pb = find(b);
            if (pa != pb) {
                p[pa] = pb;
                sum += w;
                add(a, b, w);
                add(b, a, w);
                edge[i].f = true;
            }
        }
        for (int i = 1; i <= n; i++) {
            dfs(i, -1, 0, dist[i]);
        }
        long res = (long) 1e18;
        for (int i = 0; i < m; i++) {
            if (!edge[i].f) {
                int a = edge[i].a;
                int b = edge[i].b;
                int w = edge[i].w;
                if (w > dist[a][b]) {
                    res = Math.min(res, sum + w - dist[a][b]);
                }
            }
        }
        System.out.println(res);
    }

    private static void dfs(int u, int fa, int maxd, int[] d) {
        d[u] = maxd;
        for (int i = h[u]; i != -1; i = ne[i]) {
            int j = e[i];
            if (j != fa) {
                dfs(j, u, Math.max(maxd, w[i]), d);
            }
        }
    }

    private static void add(int a, int b, int c) {
        e[idx] = b;
        w[idx] = c;
        ne[idx] = h[a];
        h[a] = idx++;
    }

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

class Edge{
    int a;
    int b;
    int w;
    boolean f = false;

    public Edge(int a, int b, int w) {
        this.a = a;
        this.b = b;
        this.w = w;
    }
}
码畜也有梦想
关注
专栏目录
第7章 图论1
08-03
3. **混合图**：同时包含有向边和无向边。 4. **平凡图**：仅包含一个节点，没有边。 5. **零图**：没有节点和边的图。 【度数】是描述节点连接情况的量。在无向图中，节点的度数是与其相邻的边的数量。在有向图中...
10第10章 图论模型(Python 程序及数据).zip
09-03
在本压缩包“10第10章 图论模型(Python 程序及数据).zip”中，主要涵盖了图论这一计算机科学领域的知识，并结合Python编程语言进行了实践。图论是数学的一个分支，它研究如何用图形表示实体及其相互关系，而Python则...
第十一周测验（二分法）
yanyanwenmeng的博客
09-02 2182
8208 矩形分割 http://noi.openjudge.cn/ch0111/03/ 8211 派 http://noi.openjudge.cn/ch0111/05/ 8209 月度开销 http://noi.openjudge.cn/ch0111/06/ 8210 河中跳房子 http://noi.openjudge.cn/ch0111/10/ 1458 Aggressive cows h...
LOJ10068 秘密的牛奶运输
weixin_30613433的博客
03-10 573
LOJ10068秘密的牛奶运输 题目描述 Farmer John 要把他的牛奶运输到各个销售点。运输过程中，可以先把牛奶运输到一些销售点，再由这些销售点分别运输到其他销售点。 运输的总距离越小，运输的成本也就越低。低成本的运输是 Farmer John 所希望的。不过，他并不想让他的竞争对手知道他具体的运输方案，所以他希望采用费用第二小的运输方案而不是最小的。现在请你帮忙找到该...
《数据结构》上机实验(第八章) —图 Ⅰ
Miss Z的博客
09-14 2440
图的应用
NUPT- DFS 算法题1047
nuptxiaoli
07-21 655
/* 第一行为两个整数n、e，表示图顶点数和边数。 以下e行每行两个整数，表示一条边的起点、终点，保证不重复、不失败。 1≤n≤20，0≤e≤190 */ #include using namespace std; int Graph[20][20]; int vis[20]; int u,v; //如果当前的节点和其他的未访问过的节点相邻，则访问这个节点，并将其设置为访问过
图论-第六章
qq_51347024的博客
12-30 4161
可平面图：若图G（可能交叉）可嵌入平面（能在平面画出图示的关系），则称G是可平面图（不一定是平面嵌入）平面嵌入（n个）：可平面图G在平面上画出的无交叉边的图示（可以有曲线）平面图（平面嵌入的一个，n个是同构的）：可平面图的任何一个平面嵌入都称为一个平面图例子图e不是可平面图，即为不可平面图。
第六章 图论
qq_43527718的博客
08-02 1267
数据结构定义和算法之第七章图论
acwing算法提高课第三章图论
最新发布
2301_79203206的博客
05-18 2087
包括单源最短路的建图方式、单源最短路的综合应用、单源最短路的扩展应用、Floyd算法、最小生成树、最小生成树的扩展应用、负环、差分。AcWing 920. 最优乘车 可以。AcWing 903. 昂贵的聘礼 可以。AcWing 346. 走廊泼水节 可以。AcWing 393. 雇佣收银员 可以。AcWing 164. 可达性统计 可以。AcWing 341. 最优贸易 可以。AcWing 343. 排序 可以。AcWing 1170. 排队布局 可以。
第六章--图论 板子
qq_45678698的博客
10-10 538
无
图论学习 第一章
qq_45245770的博客
05-14 1029
1.邻接矩阵、布尔矩阵、邻接矩阵的性质（（1）非负性和对称性 （2）同一图的不同形式的邻接矩阵是相似矩阵 （3）如果G为简单图，则A（G）是布尔矩阵，行和（列和）等于对应顶点的度数）（4）G连通的充分必要条件：A（G）不能与方阵组成的矩阵相似。图的邻接谱的定义：图的邻接矩阵A（G）的特征值以及重数(邻接谱的表示:SpecA(G))定理14 单图A（G）的谱为Spec（G），则。定义2 G是S上的交图，如果S的基数最小，称S的基数为图G的交数，记为V(G)定义4 一个给定的图G的团图是G的团的族的交图，
第六章 图论 14 AcWing 1648. 顶点着色
T_Y_F_的博客
11-20 160
第六章 图论 14 AcWing 1648. 顶点着色
张先迪 李正良 图论及其应用课后题1-3章答案
03-09
电子科技大学，研究生课程，张先迪 李正良 图论及其应用课后题1-3章答案
电子科技大学图论及其应用第二章课后习题完整答案
03-19
以上就是《图论及其应用》第二章课后习题中涉及的主要知识点，它们深入探讨了树的性质、图的结构以及生成树、割边和自环的概念，这些都是图论中基础而重要的内容。通过理解和掌握这些知识点，可以为进一步研究图论...
(完整版)图论及其应用1-3章习题答案(电子科大).pdf
10-09
【标题】中提到的“图论及其应用1-3章习题答案”暗示了文档包含的是电子科技大学关于图论及其应用这一课程的前几章的习题解答。这门课程可能涵盖了图论的基础知识、图的表示方法、图的基本概念、图的遍历算法、连通...
第一章动态规划（十二）
QinLaoDeMaChu的博客
05-23 2759
数位DP 例题：1081.度的数量 把
第三章图论（二）
QinLaoDeMaChu的博客
05-27 587
单源最短路的综合应用 例题：新年好 【题目描述】 原题来自：CQOI 2005 重庆城里有 n 个车站，m 条双向公路连接其中的某些车站。每两个车站最多用一条公路连接，从任何一个车站出发都可以经过一条或者多条公路到达其他车站，但不同的路径需要花费的时间可能不同。在一条路径上花费的时间等于路径上所有公路需要的时间之和。 佳佳的家在车站 1，他有五个亲戚，分别住在车站 a,b,c,d,e。过年了，他需要从自己的家出发，拜访每个亲戚（顺序任意），给他们送去节日的祝福。怎样走，才需要最少的时间？ 【输入】 第一行：
第一章动态规划（十三）
QinLaoDeMaChu的博客
05-24 524
单调队列优化的DP 例题：135. 最大子序和 单调队列 1、需要求某一个区间的连续子段和，因此需要用到前缀和s[ ] 2、对于任意的 s[k] ,求以 k 结尾的区间长度不超过 m 的最大连续和，等价于求 s[k] - s[k-j]，其中 1<= j <= m，因为 a[k] 是固定的，所以即要求 s[k-j]的最小值即可。（单调队列存的是下标） import java.util.Scanner; public class Main { static int N = 300010;
第二章搜索（一）
QinLaoDeMaChu的博客
05-25 439
BFS—Flood Fill（洪水覆盖算法） BFS：求最小，最短，不会爆栈 例题：池塘计数（POJ2386） 【描述】 由于最近的降雨，水在农民约翰的田里的不同地方汇集起来，这是一个N x M (1 <= N <= 100;1 <= M <= 100)的长方形。每个方块包含水(“W”)或陆地(“.”)。农夫约翰想要算出他的田地里已经形成了多少池塘。池塘是一组有水的方格，其中一个方格被认为与所有八个相邻的方格相邻。 给出一个农民约翰的田地的图，确定他有多少池塘。 【输入】 *第1行:
数据结构第六章详解：图论与遍历算法
本章节是关于数据结构课程的第六章，主要探讨图论的相关概念和应用。图是一种重要的数据结构，它描述的是数据元素之间的多对多关系，包括线性结构、树形结构、集合和图形结构中的图。具体学习内容分为以下几个部分：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值