最小公倍数、最大公因数、因式分解（素数-幂）

最新推荐文章于 2024-09-07 12:59:11 发布

不知道为什么换名字

最新推荐文章于 2024-09-07 12:59:11 发布

阅读量98

点赞数 3

文章标签： java

本文链接：https://blog.csdn.net/qq_51748637/article/details/138506518

版权

本文介绍了如何使用Java编程实现因式分解算法，包括计算最大公因数和最小公倍数的方法，通过递归和树映射结构存储因子。同时提到代码存在简化空间，可通过优化避免多余的遍历步骤。

摘要由CSDN通过智能技术生成


    /** 因式分解
     * @param a 要被分解的数
     * @return Map(素数，幂)
     * */
    public static TreeMap<Integer,Integer> factorization(int a){
        TreeMap<Integer,Integer> map = new TreeMap<>();
        factorization0(Math.abs(a),map);
        if(a<0){
            map.put(-1,1);
        }else if(a == 0){
            map.put(0,1);
        }
        return map;
    }

    private static void factorization0(int a, Map<Integer,Integer> list){
        for(int i = 2; i <= a; i++){
            if(a%i == 0){
                list.put(i, list.getOrDefault(i, 0) + 1);
                factorization0(a/i,list);//回调
                break;
            }
        }
    }

最大公因数：

    /**
     * 最大公因数
     * */
    public static int maxCommonFactor(int...nums){
        int ans = 1;
        TreeMap<Integer,Integer> map = new TreeMap<>();//用来保存所有的
        //对所有数严格因式分解（）：
        int[] mins = new int[nums.length];
        int[] maxs = new int[nums.length];
        TreeMap[] maps = new TreeMap[nums.length];
        for(int i = 0; i < nums.length; i++){
            maps[i] = factorization(nums[i]);
            mins[i] = (int) maps[i].firstKey();
            maxs[i] = (int) maps[i].lastKey();
        }
        //排序
        Arrays.sort(mins);
        Arrays.sort(maxs);
        //
        int[] range = {mins[mins.length-1],maxs[0]};
        for(int key =range[0];key<=range[1];key++){//遍历
            boolean f = true;
            int pow = -1;
            for(int j = 0; j < nums.length; j++){
                f = maps[j].containsKey(key);
                if(!f){
                    break;
                }else{ //比1
                    if(pow == -1){//没有初始化
                        pow = (int) maps[j].get(key);
                    }else{
                        pow = Math.min(pow,(int) maps[j].get(key));//取两者中最小的那个
                    }
                }
            }
            if(f){//如果没有退出
                ans =  ans * (int)Math.pow(key,pow);
            }
        }


        return ans;
    }

最小公倍数

    /**
     * 计算最小公倍数
     * */
    public static int minCommonMultiple(int... nums){
        int ans = 1;
        TreeMap<Integer,Integer> map = new TreeMap<>();//用来保存所有的
        //对所有数严格因式分解（）：
        int[] mins = new int[nums.length];
        int[] maxs = new int[nums.length];
        TreeMap[] maps = new TreeMap[nums.length];
        for(int i = 0; i < nums.length; i++){
            maps[i] = factorization(nums[i]);
            mins[i] = (int) maps[i].firstKey();
            maxs[i] = (int) maps[i].lastKey();
        }
        //排序
        Arrays.sort(mins);
        Arrays.sort(maxs);
        //
        int[] range = {mins[0],maxs[maxs.length-1]};
        for(int key =range[0];key<=range[1];key++){//遍历
            boolean f = false;
            int pow = -1;
            for(int j = 0; j < nums.length; j++){
                if(maps[j].containsKey(key)){//如果存在
                     f = maps[j].containsKey(key);
                    if(pow == -1){//没有初始化
                        pow = (int) maps[j].get(key);
                    }else{
                        pow = Math.max(pow,(int) maps[j].get(key));//取两者中最小的那个
                    }
                }
            }
            if(f){//如果存在
                ans =  ans * (int)Math.pow(key,pow);
            }
        }


        return ans;

    }

加紧时间赶出来的，细节方面没有太多优化，优化可以省掉多余的遍历环节。