经典算法｜自幂数算法优化｜39位1秒多，应该够用了

已于 2022-11-01 18:02:53 修改
阅读量644 收藏 7
点赞数 6
分类专栏： 算法 文章标签： 算法 java 自幂数 水仙花数
于 2022-11-01 17:59:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fjzeng/article/details/127627277
版权

上一篇http://t.csdn.cn/oYybh，指数级算法，求8位自幂数还可以，但是再外后就有点算不过来了，需要优化

题目抽象

n位自幂数符合条件：

a1*(10^(n-1)) + a2*(10^(n-2)) + an*(10^0)=a1^n+a2^n+....+an^n,

其中a1~an为0～9的随机数

思路

由题目抽象可知，符合条件的数字为：0～9随机数的n次幂乘以出现次数 之和。

所以可以转化为求0-9出现次数的组合，根据符合条件选取计算选取符合条件数字的方法

数据准备

/**
     * 存放0～9出现次数
     */
    private static int[] selected = new int[10];
    /**
     * 10的（0～n）次幂
     */
    private static BigInteger[] powerOf10;
    /**
     * (0~9)的n次幂
     */
    private static BigInteger[] powerOfN = new BigInteger[10];
    /**
     * 使用二位数组存储(0~9)的n次幂*出现次数，i标识一维（(0~9)的n次幂），j标识二维（（0～9出现的慈善））
     */
    private static BigInteger[][] preTable;
    /**
     * 二位数组，存储n位数最小值与preTable对应位置数的差值
     */
    private static BigInteger[][] preTable2;
    /**
     * 存储对应preTable位置数字位数n的最小值的位数n-1
     */
    private static int[][] preTable3;

    /**
     * 当前所求数字长度
     */
    private static int length;

    /**
     * 初始化基础数据
     * @param n
     */
    private static void initPre(int n)
    {
        powerOf10 = new BigInteger[n + 1];
        powerOf10[0] = BigInteger.ONE;
        length = n;

        for (int i = 1; i <= n; i++){
            powerOf10[i] = powerOf10[i - 1].multiply(BigInteger.TEN);
        }
        for(int i=0;i<10;i++){
            powerOfN[i] = BigInteger.valueOf(i).pow(n);
        }

        preTable = new BigInteger[10][n + 1];
        preTable2 = new BigInteger[10][n + 1];
        preTable3 = new int[10][n + 1];

        for (int i = 0; i < 10; i++)
        {
            for (int j = 0; j <= n; j++)
            {
                //数据中存在j个i
                preTable[i][j] = powerOfN[i].multiply(BigInteger.valueOf(j));
                preTable2[i][j] = powerOf10[length - 1].subtract(preTable[i][j]);

                //符合条件数字，将位数存储进去
                if(powerOf10[n].compareTo(preTable[i][j])>0){
                    preTable3[i][j] = preTable[i][j].toString().length()-1;
                }
            }
        }
    }

核心算法

/**
     * 获取符合条件的自幂数
     * @param n n位数
     * @param list 符合条件数
     */
    public static void zmnumGet(int n,List<BigInteger> list){
        initPre(n);
        search(9, BigInteger.ZERO, n,list);
    }


    /**
     * 提前检查是否符合条件
     * @param currentIndex 当前选择的数字（0～9）
     * @param sum 当前数
     * @param leftNum 剩余可选数字（0～9）
     * @return
     */
    private static boolean preCheck(int currentIndex, BigInteger sum, int leftNum)
    {
        if (sum.compareTo(preTable[currentIndex][leftNum])<0){
            return true;
        }


        BigInteger max = sum.add(preTable[currentIndex][leftNum]);
        max = max.divide(powerOf10[preTable3[currentIndex][leftNum]]);
        sum = sum.divide(powerOf10[preTable3[currentIndex][leftNum]]);
        while (!max.equals(sum))
        {
            max = max.divide(BigInteger.TEN);
            sum = sum.divide(BigInteger.TEN);
        }

        if (max.equals(BigInteger.ZERO)){
            return true;
        }


        int[] counter = getCounter(max);

        for (int j = 9; j > currentIndex; j--){
            if (counter[j] > selected[j]){
                return false;
            }
        }

        for (int i = 0; i <= currentIndex; i++){
            leftNum -= counter[i];
        }

        return leftNum >= 0;
    }

    /**
     * 搜索自幂数（核心方法）
     * 递归
     * @param currentIndex 当前选择的数字（0～9）
     * @param sum 当前数
     * @param leftNum 剩余可选数字（0~9）
     * @param fitList 已找到自幂数列表
     */
    private static void search(int currentIndex, BigInteger sum, int leftNum,List<BigInteger> fitList)
    {
        //必须在最大值内
        if (sum.compareTo(powerOf10[length])>=0){
            return;
        }

        if (leftNum == 0)
        {
            // 数字在范围内，且符合条件
            if (sum.compareTo(powerOf10[length - 1])>=0 && check(sum)){
                fitList.add(sum);
            }
            return;
        }

        if (!preCheck(currentIndex, sum, leftNum)){
            return;
        }


        if (sum.compareTo(preTable2[currentIndex][leftNum])<0){
            return;
        }


        if (currentIndex == 0)
        {
            selected[0] = leftNum;
            search(-1, sum, 0,fitList);
            selected[currentIndex] = 0;
        }
        else
        {
            for (int i = leftNum; i >= 0 ; i--)
            {
                selected[currentIndex] = i;
                search(currentIndex - 1, sum.add(preTable[currentIndex][i]), leftNum - i,fitList);
            }
        }
    }

    /**
     * 验证是否符合条件
     * @param sum
     * @return
     */
    private static boolean check(BigInteger sum)
    {
        int[] counter = getCounter(sum);
        for (int i = 0; i < 10; i++)
        {
            if (selected[i] != counter[i]){
                return false;
            }
        }

        return true;
    }

    /**
     * 统计大数的（0～9）数字数量
     * @param value
     * @return
     */
    public static int[] getCounter(BigInteger value)
    {
        int[] counter = new int[10];
        char[] sumChar = value.toString().toCharArray();

        for (int i = 0; i < sumChar.length; i++){
            counter[sumChar[i] - '0']++;
        }

        return counter;
    }

验证结果

/**
     * 验证当前位自幂数是否正确
     * @param n
     * @param valueList
     * @return
     */
    public static List<BigInteger> test(int n,List<BigInteger> valueList){
        powerOf10 = new BigInteger[n + 1];
        powerOf10[0] = BigInteger.ONE;

        for(int i=0;i<10;i++){
            powerOfN[i] = BigInteger.valueOf(i).pow(n);
        }
        List<BigInteger> falseList = new ArrayList<>();
        for(BigInteger value : valueList){
            int[] aa = getCounter(value);
            BigInteger sum = BigInteger.ZERO;
            for(int i=0;i<aa.length;i++){
                sum = sum.add(powerOfN[i].multiply(BigInteger.valueOf(aa[i])));
            }
            if(!sum.equals(value)){
                falseList.add(value);
            }
        }
        return falseList;
    }
    public static void main(String[] args) {

        List<Long> times = new ArrayList<>();
        for(int i=1;i<60;i++){
            StopWatch stopWatch = new StopWatch();
            stopWatch.start();
            List<BigInteger> list = new ArrayList<>();
            zmnumGet(i,list);
            stopWatch.stop();
            Long tc = stopWatch.getTime(TimeUnit.MILLISECONDS);
            list.sort(new Comparator<BigInteger>() {
                @Override
                public int compare(BigInteger o1, BigInteger o2) {
                    return o1.compareTo(o2);
                }
            });
            List<BigInteger> falseList = test(i,list);
            log.info("耗时：{}毫秒,{}位自幂数({}个):{}, 错误数字：{}",tc,i,list.size(),list,falseList);
            times.add(tc);

        }
        playPng(times,"zmsget");
    }


    public static void playPng(List<Long> tlist,String name){
        LineChat lineChat = new LineChat();
        lineChat.setH1Title("自幂数算法复杂度");
        lineChat.setH2Title("时间复杂度");
        lineChat.setXName("N维度");
        lineChat.setYName("T时间");
        List<RowFlied> list = new ArrayList<>();
        String colKey = "时间";
        for(int i=1;i<=tlist.size();i++){
            RowFlied rowFlied = new RowFlied();
            rowFlied.setColKey(colKey);
            rowFlied.setX((double) i);
            StopWatch startWatch = new StopWatch();
            startWatch.start();
            rowFlied.setY((double)tlist.get(i-1));
//            log.info("构造数据，消耗时间（微秒）:{}",startWatch.getTime(TimeUnit.MILLISECONDS));
            list.add(rowFlied);
        }

        lineChat.setRowFlieds(list);

        ChatUtils.lineChat(lineChat,name);
    }

输出结果：

耗时：0毫秒,1位自幂数(9个):[1, 2, 3, 4, 5, 6, 7, 8, 9], 错误数字：[]
耗时：0毫秒,2位自幂数(0个):[], 错误数字：[]
耗时：1毫秒,3位自幂数(4个):[153, 370, 371, 407], 错误数字：[]
耗时：2毫秒,4位自幂数(3个):[1634, 8208, 9474], 错误数字：[]
耗时：2毫秒,5位自幂数(3个):[54748, 92727, 93084], 错误数字：[]
耗时：1毫秒,6位自幂数(1个):[548834], 错误数字：[]
耗时：1毫秒,7位自幂数(4个):[1741725, 4210818, 9800817, 9926315], 错误数字：[]
耗时：2毫秒,8位自幂数(3个):[24678050, 24678051, 88593477], 错误数字：[]
耗时：3毫秒,9位自幂数(4个):[146511208, 472335975, 534494836, 912985153], 错误数字：[]
耗时：8毫秒,10位自幂数(1个):[4679307774], 错误数字：[]
耗时：7毫秒,11位自幂数(8个):[32164049650, 32164049651, 40028394225, 42678290603, 44708635679, 49388550606, 82693916578, 94204591914], 错误数字：[]
耗时：11毫秒,12位自幂数(0个):[], 错误数字：[]
耗时：16毫秒,13位自幂数(0个):[], 错误数字：[]
耗时：25毫秒,14位自幂数(1个):[28116440335967], 错误数字：[]
耗时：41毫秒,15位自幂数(0个):[], 错误数字：[]
耗时：39毫秒,16位自幂数(2个):[4338281769391370, 4338281769391371], 错误数字：[]
耗时：53毫秒,17位自幂数(3个):[21897142587612075, 35641594208964132, 35875699062250035], 错误数字：[]
耗时：77毫秒,18位自幂数(0个):[], 错误数字：[]
耗时：186毫秒,19位自幂数(4个):[1517841543307505039, 3289582984443187032, 4498128791164624869, 4929273885928088826], 错误数字：[]
耗时：187毫秒,20位自幂数(1个):[63105425988599693916], 错误数字：[]
耗时：107毫秒,21位自幂数(2个):[128468643043731391252, 449177399146038697307], 错误数字：[]
耗时：187毫秒,22位自幂数(0个):[], 错误数字：[]
耗时：219毫秒,23位自幂数(5个):[21887696841122916288858, 27879694893054074471405, 27907865009977052567814, 28361281321319229463398, 35452590104031691935943], 错误数字：[]
耗时：213毫秒,24位自幂数(3个):[174088005938065293023722, 188451485447897896036875, 239313664430041569350093], 错误数字：[]
耗时：213毫秒,25位自幂数(5个):[1550475334214501539088894, 1553242162893771850669378, 3706907995955475988644380, 3706907995955475988644381, 4422095118095899619457938], 错误数字：[]
耗时：268毫秒,26位自幂数(0个):[], 错误数字：[]
耗时：338毫秒,27位自幂数(5个):[121204998563613372405438066, 121270696006801314328439376, 128851796696487777842012787, 174650464499531377631639254, 177265453171792792366489765], 错误数字：[]
耗时：409毫秒,28位自幂数(0个):[], 错误数字：[]
耗时：446毫秒,29位自幂数(4个):[14607640612971980372614873089, 19008174136254279995012734740, 19008174136254279995012734741, 23866716435523975980390369295], 错误数字：[]
耗时：531毫秒,30位自幂数(0个):[], 错误数字：[]
耗时：679毫秒,31位自幂数(3个):[1145037275765491025924292050346, 1927890457142960697580636236639, 2309092682616190307509695338915], 错误数字：[]
耗时：866毫秒,32位自幂数(1个):[17333509997782249308725103962772], 错误数字：[]
耗时：830毫秒,33位自幂数(2个):[186709961001538790100634132976990, 186709961001538790100634132976991], 错误数字：[]
耗时：1062毫秒,34位自幂数(1个):[1122763285329372541592822900204593], 错误数字：[]
耗时：1269毫秒,35位自幂数(2个):[12639369517103790328947807201478392, 12679937780272278566303885594196922], 错误数字：[]
耗时：1088毫秒,36位自幂数(0个):[], 错误数字：[]
耗时：1374毫秒,37位自幂数(1个):[1219167219625434121569735803609966019], 错误数字：[]
耗时：1437毫秒,38位自幂数(1个):[12815792078366059955099770545296129367], 错误数字：[]
耗时：1292毫秒,39位自幂数(2个):[115132219018763992565095597973971522400, 115132219018763992565095597973971522401], 错误数字：[]
耗时：1582毫秒,40位自幂数(0个):[], 错误数字：[]
耗时：1373毫秒,41位自幂数(0个):[], 错误数字：[]
耗时：1294毫秒,42位自幂数(0个):[], 错误数字：[]
耗时：1128毫秒,43位自幂数(0个):[], 错误数字：[]
耗时：940毫秒,44位自幂数(0个):[], 错误数字：[]
耗时：958毫秒,45位自幂数(0个):[], 错误数字：[]
耗时：802毫秒,46位自幂数(0个):[], 错误数字：[]
耗时：582毫秒,47位自幂数(0个):[], 错误数字：[]
耗时：512毫秒,48位自幂数(0个):[], 错误数字：[]
耗时：351毫秒,49位自幂数(0个):[], 错误数字：[]
耗时：224毫秒,50位自幂数(0个):[], 错误数字：[]
耗时：153毫秒,51位自幂数(0个):[], 错误数字：[]
耗时：105毫秒,52位自幂数(0个):[], 错误数字：[]
耗时：55毫秒,53位自幂数(0个):[], 错误数字：[]
耗时：24毫秒,54位自幂数(0个):[], 错误数字：[]
耗时：13毫秒,55位自幂数(0个):[], 错误数字：[]
耗时：5毫秒,56位自幂数(0个):[], 错误数字：[]
耗时：1毫秒,57位自幂数(0个):[], 错误数字：[]
耗时：0毫秒,58位自幂数(0个):[], 错误数字：[]
耗时：0毫秒,59位自幂数(0个):[], 错误数字：[]

计算出的结果验证无误，39位自幂数用时：1292毫秒

注：

优化思路参考：水仙花数算法讨论（https://bbs.csdn.net/topics/360185693）

fjza1168
关注
  • 6
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
从自幂数计算谈算法优化方法
代号4101的专栏
01-10 6755
第一章  前言 1.1  参考文献         郭继展,郭勇,苏辉《程序算法与技巧精选》,机械工业出版社,2008年5月第一版,ISBN 978-7-111-23816-4,第7.3节：求自幂数——用数组预作乘法提高速度100倍。 1.2  写此文章的目的         （1）想用自己的语言总结书上的内容；         （2）用自己的笔记本电脑测试下各个方法间，效率差距
Java自幂数计算及其算法改进
kuntagang的专栏
11-26 1790
在n进制中，所有小于n的正整数都为自幂数，比如2进制中1是自幂数，3进制中1和2都是自幂数，4进制中1，2和3都是自幂数…改进:我们可以将幂次方的结果放在一个数组中，每次使用的时候，都调用这个数组的值，而不用每次都重复计算一次。北斗七星数共有4个：1741725，4210818，9800817，9926315；例如：在十进制中，153是一个三位数，各个数位的3次幂之和为1。独身数共有9个: 1，2，3，4，5，6，7，8，9；水仙花数共有4个：153，370，371，407；六合数只有1个：548834；
【C#】自幂数
博客
12-15 619
在一个固定的进制中，一个n位自然数等于自身各个数位上数字的n次幂之和，则称此数为自幂数。
自幂数9位数查找之算法优化（C语言）（水仙数是4位数自幂数）
Sticker的博客
11-26 1234
自幂数的9位数查找之优化（C语言） 这是一篇C语言有关自幂数查找的优化过程，目前笔者最好结果是8位数用时7.007秒，9位数用时79.079。 期待有更棒的结果。 思维导图先上！！！ 一，明确自幂数 1.什么是自幂数？ 自幂数是指一个 n 位数，它的每个位上的数字的 n 次幂之和等于它本身。（水仙数是一个4位数自幂数） （例如：当n为3时，有1^3 + 5^3 + 3^3 = 153，153即是...
请编程输出 1~7 位的所有自幂数
最新发布
hnjzsyjyj的专栏
04-28 334
● 本算法代码，在计算 8 位及以上的自幂数时，相当卡，需优化。故本算法代码只用来计算1~7 位的所有自幂数。 ●一个 n 位的自然数，若它各位上的数字的 n 次幂之和等于它本身，则称之为 n 位自幂数。
全网最快的自幂数计算方法 可计算至30位左右
qq_41763186的博客
03-08 3077
水仙花数是指，一个3位数，它的每位数的3次幂之和等于它本身。水仙花数有4个：153, 370, 371, 407。 而自幂数是水仙花数的扩展，它指的是一个n位数，它的每位数的n次幂之和等于它本身。 大一的时候，C语言老师曾让我们编写程序计算5位数以内的自幂数。当时我们的思路是穷举。例如计算5位数的自幂数，穷举10000~99999内的所有数，找出符合条件的数即可。 但是，若数字很大，例如10位及以...
PHP常用的排序和查找算法
01-20
本文汇总了常见的php排序算法和查找，在进行算法设计的时候有不错的借鉴价值。现分享给大家供参考之用。具体如下： <?.../** ...//这个优化之后效率会很高，一般够用 for($i=0;$i<count($arr)-1;
基于java的netty实现的可靠udp网络库(kcp算法).rar
06-23
一、需求分析 目前网上已经有非常多的KCP的原理机制、以及各种版本的KCP实现的相关资料。我在之前做了两篇文章的KCP相关分析，分别是原理机制和性能测试实践。 我们当前的项目是一个对实时性要求比较高的游戏，理论...
MATLAB R2016a数字图像处理算法分析与实现
11-07
R2016a版本是MATLAB的一个重要迭代，包含了更多的新功能和优化，使得图像处理更加高效和便捷。 本书涵盖了以下几个核心知识点： 1. **图像基础**：首先，书中会介绍图像的基本概念，如像素、图像类型（灰度图像、...
利用雪花算法生成uuid
07-15
1. **时间戳**：占41位，用于记录自纪元以来的毫秒数。由于二进制表示，可以表示大约69年的时间，因为2^41 / (1000 * 60 * 60 * 24 * 365) ≈ 69.2年。考虑到计算机系统的闰秒处理，这个范围基本够用。 2. **工作...
取最大、最小数（含思维过程图）
05-20
C语言 最大数 最小数
【自幂数】一个神奇的数字
JZJ_LYH的博客
08-09 3214
自幂数是一个非常有趣和神奇的数字概念。本文将介绍如何求常见的水仙花数以及四叶玫瑰数、五角星数等常见自幂数。
高薪就业面试题
06-02
针对java基础、java面向对象编程、框架设计、设计模式等就业面试题讲解。本视频涵盖了入门级Java程序员和多年经验的高级开发者面试时会遇到的一些问题，包含了一些超级容易回答的问题，同时包含经验丰富的 Java 程序员也会棘手的问题。，适合中高级程序员观看
51nod-【1015 水仙花数】
有梦的博客
10-28 414
1015 水仙花数 基准时间限制：1 秒 空间限制：131072 KB 分值: 5 难度：1级算法题  收藏  关注 水仙花数是指一个 n 位数 ( n >= 3 )，它的每个位上的数字的 n 次幂之和等于它本身。（例如：1^3 + 5^3 + 3^3 = 153） 给出一个整数M，求 >= M的最小的水仙花数。
寻找自幂数
qq_42048450的博客
10-07 952
题目要求： 用户输入数字的位数，然后满足各个位数n次方相加等于该数字。（自幂数或者自恋数） 例如 算法思路： 输入位数n 计算n位数的起始值和终止值start =，end =，i=start； 分离出个位，十位，百位的值：m=i(参数代替保证值的不变)； d=m%10(取个位)；sum =sum+； m=m/10(重复取余步骤4)直到m=0停止； 判断sum =i，显示i; ...
简单搜索（多位自幂数）+数列网站
TT4191105的博客
06-12 360
题目： 我们定义n位自幂数为： 如果x是n位数，x的各位的n次方的也为x,那么x为n位自幂数 求n位自幂数有哪些，0< n <=19，x > 0，排序后输出 时限3000ms。 解法1：打表 首先，如果拿到一个数列，可以先试试这个网站：OEIS，输入数列串，就会返回通项公式同时给出表，可以以后直接打表用。 解法2：搜索 ...
求n位自幂数
JuniusZ的博客
09-05 1191
无意中看到介绍水仙花数，即一个3位数的各位数字的3次方和等该数本身 实际上就是自幂数的一种，感觉有点意思，写个脚本试了下 #!/usr/bin/python # -*- coding: utf-8 -*- import sys, time def deco(func): def inner(*args, **kwargs): b_time = time.time()...
快速寻找9位数内的自幂数
LBH_goto_peak的博客
02-11 484
自幂数：自幂数是指一个 n 位数，它的每个位上的数字的 n 次幂之和等于它本身。(例如:当n为3时，153即是n为3时的一个自幂数) 自幂数包括:独身数、水仙花数、四叶玫瑰数、五角星数、六合数、北斗七星数、八仙数、九九重阳数、十全十美数。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

fjza1168

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值