素数伴侣(匈牙利算法)

最新推荐文章于 2024-04-28 22:17:26 发布
最新推荐文章于 2024-04-28 22:17:26 发布
阅读量402 收藏 1
点赞数
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mediterraneansea/article/details/130256844
版权

素数伴侣

题目描述

若两个正整数的和为素数，则这两个正整数称之为“素数伴侣”，如2和5、6和13，它们能应用于通信加密。现在密码学会请你设计一个程序，从已有的 N （ N 为偶数）个正整数中挑选出若干对组成“素数伴侣”，挑选方案多种多样，例如有4个正整数：2，5，6，13，如果将5和6分为一组中只能得到一组“素数伴侣”，而将2和5、6和13编组将得到两组“素数伴侣”，能组成“素数伴侣”最多的方案称为“最佳方案”，当然密码学会希望你寻找出“最佳方案”。

输入:

有一个正偶数 n ，表示待挑选的自然数的个数。后面给出 n 个具体的数字。

输出:

输出一个整数 K ，表示你求得的“最佳方案”组成“素数伴侣”的对数。

数据范围： 1≤n≤100 ，输入的数据大小满足 2≤val≤30000

解题思路

方案一

采用暴力破解+素数缓存

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 获取n
        int n = in.nextInt();
        // 存储输入列表
        List<Integer> list = new ArrayList<>();
        // 素数缓存
        Set<Integer> cache = new HashSet<>();
        while (in.hasNextInt()) {
            list.add(in.nextInt());
        }
        int sum = process(list,cache);
        System.out.println(sum);
    }

暴力递归函数

private static int process(List<Integer> list, Set<Integer> cache) {
    if (list.size() < 2){
        return 0;
    }
    int max = 0;
    /**
     * 每次都以下标为0的元素开始与后面的元素进行相加操作得到素数值
     */
    for (int i = 1; i < list.size(); i++) {
        int sum = 0;
        int num = list.get(0)+list.get(i);
        if (isPrem(num,cache)){
            sum++;
        }
        /**
         * 由于下标为0和下标为i的元素已经被使用，因此要在下一次递归中要从集合中移除这两个元素
         * 但是对于下次循环该集合的元素要还原，因此这里做一个集合的拷贝操作
         */
        List<Integer> copy = new ArrayList<>(list);
        /**
         * 从后往前移除元素，防止下标越界
         */
        list.remove(i);
        list.remove(0);
        /**
         * 下一次递归时，集合中不含有已经计算的元素，递归函数会得到这种匹配方式种的最大匹配素数个数
         */
        sum+=process(list,cache);
        /**
         * 这一次循环的匹配规则的最大值和其他循环的匹配规则相比较取最大值
         */
        max = Math.max(max,sum);
        /**
         * 还原集合，进入下一次匹配规则
         */
        list = copy;
    }
    return max;
}

素数判单函数带缓存

private static boolean isPrem(Integer num,Set<Integer> cache){
    //从缓存中获取
    if (cache.contains(num)){
        return true;
    }
    //4以及内的定是素数
    if (num < 4){
        cache.add(num);
        return true;
    }
    //偶数必不是素数
    if (num % 2 == 0){
        return false;
    }
    //素数判断
    for (int i = 3; i <= Math.sqrt(num); i++) {
        if (num % i == 0){
            return false;
        }
    }
    cache.add(num);
    return true;
}

测试用例

20923 22855 2817 1447 29277 19736 20227 22422 24712 27054 27050 18272 5477 27174 13880 15730 7982 11464 27483 19563 5998 16163

用时:1497879ms

方案二

​ 既然这个题目可以使用暴力递归的方式进行求解，那么先想想这个递归树中是否会存在很多重复的计算，如果有就可以采用缓存的机制来进行优化，拿空间换取时间。

采用缓存+素数缓存

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 获取n
        int n = in.nextInt();
        // 存储输入列表
        List<Integer> list = new ArrayList<>();
        // 素数缓存
        Set<Integer> cache = new HashSet<>();
        // dp缓存
        Map<String,Integer> dp = new HashMap<>();
        while (in.hasNextInt()) {
            list.add(in.nextInt());
        }
        //首先无论数据顺序如何都不影响结果，为了增加重复概率所以这里将数据排序了，由于数组长度过小其实排序不是很影响性能
        Collections.sort(list);
        int sum = process(list,cache,dp);
        System.out.println(sum);
    }

带缓存的递归函数

private static int process(List<Integer> list, Set<Integer> cache, Map<String, Integer> dp) {
    if (list.size() < 2){
        return 0;
    }
    /**
    * 如果有内容直接从缓存中获取数据
    */
    if (dp.containsKey(list.toString())){
        return dp.get(list.toString());
    }
    int max = 0;
    /**
     * 每次都以下标为0的元素开始与后面的元素进行相加操作得到素数值
     */
    for (int i = 1; i < list.size(); i++) {
        int sum = 0;
        int num = list.get(0)+list.get(i);
        if (isPrem(num,cache)){
            sum++;
        }
        /**
         * 由于下标为0和下标为i的元素已经被使用，因此要在下一次递归中要从集合中移除这两个元素
         * 但是对于下次循环该集合的元素要还原，因此这里做一个集合的拷贝操作
         */
        List<Integer> copy = new ArrayList<>(list);
        /**
         * 从后往前移除元素，防止下标越界
         */
        list.remove(i);
        list.remove(0);
        /**
         * 下一次递归时，集合中不含有已经计算的元素，递归函数会得到这种匹配方式种的最大匹配素数个数
         */
        sum+=process(list,cache);
        /**
         * 这一次循环的匹配规则的最大值和其他循环的匹配规则相比较取最大值
         */
        max = Math.max(max,sum);
        /**
         * 还原集合，进入下一次匹配规则
         */
        list = copy;
    }
    // 向缓存中获取数据
    dp.put(list.toString(),max);
    return max;
}

素数判单函数带缓存

private static boolean isPrem(Integer num,Set<Integer> cache){
    //从缓存中获取
    if (cache.contains(num)){
        return true;
    }
    //4以及内的定是素数
    if (num < 4){
        cache.add(num);
        return true;
    }
    //偶数必不是素数
    if (num % 2 == 0){
        return false;
    }
    //素数判断
    for (int i = 3; i <= Math.sqrt(num); i++) {
        if (num % i == 0){
            return false;
        }
    }
    cache.add(num);
    return true;
}

测试用例

20923 22855 2817 1447 29277 19736 20227 22422 24712 27054 27050 18272 5477 27174 13880 15730 7982 11464 27483 19563 5998 16163

用时:269ms(通过)

1507 6611 20966 571 1023 9390 16632 16742 12152 18621 4670 25368 15333 7461 12737 24979 10819 1505 13802 20395 6112 18161 23373 9154 14116 24391 27280 27686

用时:6237ms(超时)

方案三

​ 从效果上看采用缓存性能得到了极大的提升，起码提升了接近5000倍，然后上述缓存法唯一的优化点在于排序这里可以采用，数组存储，再添加元素的时候直接进行排序，这样就可保证不需要再次进行O(logN)的时间复杂度的排序了。但是，我们需要知道，这里N的数量并不多，排序这里的消耗基本忽略不计。

​ 笔者到这里，已经黔驴技穷了。测试用例确实还是跑不过。查阅解析后发现这个题目不应该采用动态规划的解题思路，

​ 由于素数的性质导致只有两种数之和才会产生素数，即奇数和偶数相加。因此这个题目就可转换为：求解奇数列表中的数据和偶数列表数据的最大匹配数的问题。对于这个问题有一个比较好的算法就是-----匈牙利算法。哈哈，后知后觉，素数伴侣，题目就在暗示匈牙利算法这种求匹配的算法。

​ 尴尬的是，笔者确实是第一次听到这个算法，略微了解后好像明白了。但是，有感觉说不清楚，就不在这里误人子弟了。

​

采用匈牙利算法

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    // 获取n
    int n = in.nextInt();
    //存放奇数
    List<Integer> odd = new ArrayList<>();
    //存放偶数
    List<Integer> even = new ArrayList<>();
    while (in.hasNextInt()) { // 注意 while 处理多个 case
       Integer num = in.nextInt();
       if (num % 2 == 0) {
          even.add(num);
       } else {
          odd.add(num);
      }
    }
    //一个小优化，如果全为奇数或者全为偶数，必然不可能有素数伴侣
    if (even.size() == 0 || odd.size() == 0) {
       System.out.println(0);
      return;
    }
    // 素数缓存
    Set<Integer> cache = new HashSet<>();    
   	//构建二分图
    boolean[][] map = getMap(odd, even, set);
    //匈牙利算法求解最后的答案    
    int result = hungarian(map);
    System.out.println(result);
}

构建二分图

/**
 * 构建奇偶匹配成素数的二分图
 * @param odd 奇数集合
 * @param even 偶数集合
 * @param cache 缓存
 * @return 构建奇偶匹配成素数的二分图
 */
private static boolean[][] getMap(List<Integer> odd, List<Integer> even, Set<Integer> cache) {
    boolean[][] result = new boolean[odd.size()][even.size()];
    for (int i = 0; i < odd.size(); i++) {
        for (int j = 0; j < even.size(); j++) {
            if (isPrem(odd.get(i) + even.get(j), cache)) {
                result[i][j] = true;
            }
        }
    }
    return result;
}

匈牙利算法

private static int hungarian(boolean[][] map) {
	int sum = 0;
    //记录下已经匹配的行号，用于回溯
    Integer[] rowRecode = new Integer[even.size()];
    for (int i = 0; i < map.length; i++) {
        //记录下这列是否被访问过
        Integer[] vis = new Integer[even.size()];
        if (match(i, map, row, vis)) {
           sum++;
        }
    }
    return sum;
}
private static boolean match(int row, boolean[][] map, Integer[] rowRecode, Integer[] vis) {
    for (int i = 0; i < map[row].length; i++) {
        if (map[row][i] && vis[i] == null ) {
            vis[i] = 1;
            //如果这列没有匹配的行则将该列的行号记录为当前行，
            //如果有则回溯已被占用行，如果已被占用行存在下一个匹配值则替换
            if (rowRecode[i] == null || match(rowRecode[i], map, rowRecode, vis)) {
                rowRecode[i] = row;
                return true;
            }
        }
    }
    return false;
}

素数判单函数带缓存

private static boolean isPrem(Integer num,Set<Integer> cache){
    //从缓存中获取
    if (cache.contains(num)){
        return true;
    }
    //4以及内的定是素数
    if (num < 4){
        cache.add(num);
        return true;
    }
    //偶数必不是素数
    if (num % 2 == 0){
        return false;
    }
    //素数判断
    for (int i = 3; i <= Math.sqrt(num); i++) {
        if (num % i == 0){
            return false;
        }
    }
    cache.add(num);
    return true;
}

测试用例

1507 6611 20966 571 1023 9390 16632 16742 12152 18621 4670 25368 15333 7461 12737 24979 10819 1505 13802 20395 6112 18161 23373 9154 14116 24391 27280 27686

用时:1ms(通过)

​

Re:从零开始的码农生活
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
二分图(匈牙利算法)归纳.md
05-02
二分图(匈牙利算法)归纳.md
华为机试--最佳素数伴侣
ZuoFengYeCao的博客
12-28 588
题目描述 题目描述 若两个正整数的和为素数，则这两个正整数称之为“素数伴侣”，如2和5、6和13，它们能应用于通信加密。现在密码学会请你设计一个程序，从已有的N（N为偶数）个正整数中挑选出若干对组成“素数伴侣”，挑选方案多种多样，例如有4个正整数：2，5，6，13，如果将5和6分为一组中只能得到一组“素数伴侣”，而将2和5、6和13编组将得到两组“素数伴侣”，能组成“素数伴侣”最多的方案称为“最佳...
素数伴侣-动态规划
引力空间
07-14 4829
描述:  题目描述 若两个正整数的和为素数，则这两个正整数称之为“素数伴侣”，如2和5、6和13，它们能应用于通信加密。现在密码学会请你设计一个程序，从已有的N（N为偶数）个正整数中挑选出若干对组成“素数伴侣”，挑选方案多种多样，例如有4个正整数：2，5，6，13，如果将5和6分为一组中只能得到一组“素数伴侣”，而将2和5、6和13编组将得到两组“素数伴侣”，能组成“素数伴侣”最多的方案称为“最
最大二分匹配：最大“素数伴侣”问题
福尔魔勋 的 博客
08-26 602
而最大二分匹配问题是多源多汇问题的一个特例，所以它可以完全使用“多源多汇”问题的流网络的解决方法来解决，其中最关键的环节在于寻找“增广路径”。“多源多汇”问题，一共3个集合，源点集合S，汇点集合D，其它点集合P。最大二分匹配问题没有集合P，只有集合S和集合D。同样，最大二分匹配最关键的环节还是寻找“增广路径”。
匈牙利算法-最大匹配
weixin_40540942的博客
07-12 366
若两个正整数的和为素数，则这两个正整数称之为“素数伴侣”，如2和5、6和13，它们能应用于通信加密。现在密码学会请你设计一个程序，从已有的 N （ N 为偶数）个正整数中挑选出若干对组成“素数伴侣”，挑选方案多种多样，例如有4个正整数：2，5，6，13，如果将5和6分为一组中只能得到一组“素数伴侣”，而将2和5、6和13编组将得到两组“素数伴侣”，能组成“素数伴侣”最多的方案称为“最佳方案”，当然密码学会希望你寻找出“最佳方案”。输出一个整数 K ，表示你求得的“最佳方案”组成“素数伴侣”的对数。
【算法题】素数伴侣-用匈牙利算法解决二分图匹配问题
qq_24052051的博客
11-03 896
【算法题】素数伴侣-用匈牙利算法解决二分图匹配问题
素数伴侣（牛客）
归根结底不优秀的博客
05-13 3717
题目描述：（二分图最大匹配问题） 若两个正整数的和为素数，则这两个正整数称之为“素数伴侣”，如2和5、6和13，它们能应用于通信加密。现在密码学会请你设计一个程序，从已有的N（N为偶数）个正整数中挑选出若干对组成“素数伴侣”，挑选方案多种多样，例如有4个正整数：2，5，6，13，如果将5和6分为一组中只能得到一组“素数伴侣”，而将2和5、6和13编组将得到两组“素数伴侣”，能组成“素数伴侣”最多的方案称为“最佳方案”，当然密码学会希望你寻找出“最佳方案”。 输入描述： 有一个正偶数N（N≤100.
素数伴侣
github_36268254的博客
11-30 920
题目描述 题目描述 若两个正整数的和为素数，则这两个正整数称之为“素数伴侣”，如2和5、6和13，它们能应用于通信加密。现在密码学会请你设计一个程序，从已有的N（N为偶数）个正整数中挑选出若干对组成“素数伴侣”，挑选方案多种多样，例如有4个正整数：2，5，6，13，如果将5和6分为一组中只能得到一组“素数伴侣”，而将2和5、6和13编组将得到两组“素数伴侣”，能组成“素数伴侣”最多的方案称为“最
素数伴侣HJ28
shy的博客
03-27 308
最大匹配
素数判定算法的实现
01-20
2. 原始算法 素数的定义是，除了能被1和它本身整除而不能被其他任何数整除的数。根据素数定义 只需要用2到n-1去除n，如果都除不尽，则n是素数，否则，只要其中有一个数能整除则n不是素数。 代码如下: bool is_...
基础算法-python判断素数
11-09
python判断素数 def is_prime(n): # 判断素数的函数 """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False""" if n return False # 0、1、负数以及偶数都不是素数 for i in range(2, ...
C++判断素数，基础算法题
08-23
用C/C++来判断一个数是否为素数，详细源码和注释
VB 设计质数判断程序及算法
08-18
这是使用VB 设计的质数判断程序及算法, 适用于数学及科学研究。功能有: 1.输入一个数, 通过一定的算法, 判断其是否为质数。 2.给定一个范围, 导出该范围内的所有质数表。
算法学习(5)-图的遍历
knoci的博客
04-28 832
使用深度优先搜索来遍历这个图的过程具体是：首先从一个未走到过的顶点作为起始顶点， 比如以1号顶点作为起点。沿1号顶点的边去尝试访问其它未走到过的顶点， 首先发现2 号顶点还没有走到过， 于是来到了2 号顶点。再以2 号顶点作为出发点继续尝试访问其它未走到过的顶点， 这样又来到了4号顶点。再以4 号顶点作为出发点继续尝试访问其它未走到过的顶点。但是， 此时沿4号顶点的边， 已经不能访问到其它未走到过的顶点了， 所以要返回到2号顶点。
Rapidly exploring Random Trees(RRT)类算法
qq_35635374的博客
04-28 219
认知有限，望大家多多包涵，有什么问题也希望能够与大家多交流，共同成长！本文先对Rapidly exploring Random Trees(RRT)类算法做个简单的介绍，具体内容后续再更，其他模块可以参考去我其他文章提示：以下是本篇文章正文内容（1）优点快速随机树算法是一种较为迅捷搜索的方式，增量式的构建树其优点明显，主要体现在针对性的找一条从起点到终点的路径其较强较快的搜索能力，【防盗标记–盒子君hzj】并且运用快速拓展随机树的路径规划对路径运行环境没有限制要求。（2）缺点。
算法训练营第十一天 | LeetCode 20 有效的括号、LeetCode 1047 删除字符串中的所有相邻重复项
qq_63149342的博客
04-27 146
注意用的是字符串数组作为输入，而我们要用int型进行计算，这时候就要用到一个string转int类型的库函数stoi函数，aoti是字符数组转int类型。一个是最后循环结束后要判断栈内存是否为空，一个是出栈时要判断栈是否为空，总的来说是考验对于栈内存空间的掌控吧。这一题考栈的性质，相邻字符用未进栈的元素和进栈的元素进行模拟即可，相同且栈不为空即出栈，否则进栈，之后将栈内元素全部导入一个字符串，还要注意要写一个反转函数翻转下即可。LeetCode 1047 删除字符串中的所有相邻重复项。
代码随想录算法训练营第三十八天
最新发布
weixin_41902984的博客
04-28 213
又又又欠两天债，不过回家了，一切可以按部就班，明天慢慢补吧，今天先做一课的内容。然后就是如果一次可以上m个阶梯的话应该怎么做，先把伪代码放上来。其实就是斐波那契数，不过需要理解一下过程。还好还好，动态规划第一天不太难。746. 使用最小花费爬楼梯。509. 斐波那契数。
Golang | Leetcode Golang题解之第56题合并区间
weixin_66442839的博客
04-28 496
Golang | Leetcode Golang题解之第56题合并区间
判断素数概率测试算法python
12-02
根据引用[1]，Miller-Rabin素性测试或Rabin-Miller素性测试是一种概率素性测试算法，用于判断给定数字是否可能为素数。下面是一个使用Python实现的Miller-Rabin素性测试算法的例子： ```python import random def ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值