算法设计与分析: 3-12 圈乘运算问题

最新推荐文章于 2024-03-21 21:08:59 发布
原创 最新推荐文章于 2024-03-21 21:08:59 发布 · 3.2k 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#圈乘运算问题 #动态规划 #算法 #Java

博客探讨了圈乘运算问题，定义为X⨂⨂Y等于X的数字之和乘以Y的最大和最小数字。文章提供了两种Java实现，旨在解决如何找到使用最少圈乘运算得到特定值K的算法。内容引用自王晓东的《计算机算法设计与分析》。

3-12 圈乘运算问题

问题描述

关于整数的 2 元圈乘运算⨂⨂定义为
(X⨂⨂Y)=10 进制整数 X 的各位数字之和××10进制整数Y 的最大数字++Y的最小数字。 例如，(9⨂30)=9*3+0=27。
对于给定的10进制整数X和K，由X和⨂⨂运算可以组成各种不同的表达式。试设计一个算法，计算出由 X 和⨂⨂运算组成的值为 K 的表达式最少需用多少个⨂⨂运算。

Java: version 1

import java.util.Scanner;

public class QuanChengYunSuan {
    private static int kk;
    private static int len;
    private static int big;
    private static int[][] num;

    private static String s1,s2;

    private static int MAX = 100000;

    public static void main(String[] args){
        if(input())
            init();
        else
            return;

        compute();
    }

    private static void compute(){
        boolean flag = true;
        while (flag){
            flag = false;
            for(int i=0; i<big; i++)
                if(num[i][0] < MAX)
                    for(int k=0; k<big; k++)
                        if(num[k][0] < MAX){
                            int j = num[i][3]*num[k][2]+num[k][1];
                            if(num[i][0]+num[k][0]+1 < num[j][0]){
                                num[j][0] = num[i][0]+num[k][0]+1;
                                flag = true;
                            }
                        }
        }
        if(num[kk][0] < MAX)
            out(num[kk][0]);
        else
            out(-1);
    }

    private static boolean input(){
        Scanner input = new Scanner(System.in);

        s1 = input.next();
        s2 = input.next();

        if(s1.equals(s2)){
            out(0);
            return false;
        }

        len = s1.length();
        big = 81*len+9;
        if(big < 171)
            big = 171;

        int biglen = (int)Math.ceil(Math.log10(big));
        if(s2.length() > biglen) {
            out(-1);
            return false;
        }
        kk = Integer.parseInt(s2);
        if(kk > big){
            out(-1);
            return false;
        }

        return true;
    }

    private static int ctoi(char x){
        return (int)x - 48;
    }

    private static void out(int x){
        if(x >= 0)
            System.out.println("The number of X is: "+x);
        else
            System.out.println("No answer!");
    }

    private static void init(){
        num = new int[++big][4];
        for(int i=0; i<big; i++){
            num[i][0] = MAX;
            num[i][1] = MAX;
            num[i][2] = 0;
            num[i][3] = 0;
        }

        for(int i=0; i<len; i++)
            count(ctoi(s1.charAt(i)), 0);

        num[0][0] = 0;

        for(int i=1; i<big; i++){
            int t = i;
            while (t > 0){
                int j = t%10;
                t /= 10;
                count(j, i);
            }
        }
    }

    private static void count(int i, int j){
        if(i < num[j][1])
            num[j][1] = i;
        if(i > num[j][2])
            num[j][2] = i;
        num[j][3] += i;
    }
}

Java: version 2

import java.util.Scanner;

public class QuanChengYunSuan2 {

    public static int kk,len,big,biglen,sum;
    public static int[] leftn;
    public static int[][] rightn;

    public static String s1;
    public static String s2;

    private static int MAX = 1000000;

    public static void main(String[] args){
        if(input())
            init();
        else
            return;

        compute();
    }

    private static void compute(){
        int a, b, c, best = MAX;
        int[] abc = new int[3];
        boolean flag = true;
        while (flag){
            flag = false;
            for(int i=0; i<=biglen; i++)
                if(leftn[i] < MAX)
                    for(int j=0; j<10; j++)
                        for(int k=0; k<=j; k++)
                            if(rightn[k][j] < MAX){
                                int num;
                                if(i > 0)
                                    num = i*j+k;
                                else
                                    num = sum*j+k;

                                trans(num, abc);
//                                a = abc[0];
//                                b = abc[1];
//                                c = abc[2];
                                int curr = leftn[i] + rightn[k][j] + 1;
                                if(curr < leftn[abc[2]]){
                                    leftn[abc[2]] = curr;
                                    flag = true;
                                }
                                if(curr < rightn[abc[0]][abc[1]]){
                                    rightn[abc[0]][abc[1]] = curr;
                                    flag = true;
                                }
                                if(num == kk && curr < best){
                                    best = curr;
                                    flag = true;
                                }
                            }
        }
        if(best < MAX)
            out(best);
        else
            out(-1);
    }

    private static void trans(int t, int[] abc){
        abc[0] = MAX;
        abc[1] = 0;
        abc[2] = 0;
        while (t > 0){
            int j = t%10;
            t /= 10;
            count(j, abc);
        }
    }

    private static boolean input(){
        Scanner input = new Scanner(System.in);

        s1 = input.next();
        s2 = input.next();

        if(s1.equals(s2)){
            out(0);
            return false;
        }

        len = s1.length();
        big = 81*len+9;
        if(big < 171)
            big = 171;

        biglen = (int)Math.ceil(Math.log10(big));
        if(s2.length() > biglen) {
            out(-1);
            return false;
        }
        kk = Integer.parseInt(s2);
        if(kk > big){
            out(-1);
            return false;
        }

        return true;
    }

    private static void init(){
        biglen *= 9;
        rightn = new int[10][10];

        for(int i=0; i<10; i++)
            for(int j=0; j<10; j++)
                rightn[i][j] = MAX;

        leftn = new int[biglen+1];
        for(int i=1; i<=biglen; i++)
            leftn[i] = MAX;

        int a = MAX, b = 0;
        sum=0;
        int[] abc = new int[3];
        abc[0] = a;
        abc[1] = b;
        abc[2] = sum;
        leftn[0]=0;

        for(int i=0; i<len; i++)
            count(ctoi(s1.charAt(i)), abc);

        a = abc[0];
        b = abc[1];
        sum = abc[2];

        rightn[a][b] = 0;
        if(sum <= biglen)
            leftn[sum] = 0;
    }

    private static int ctoi(char x){
        return (int)x - 48;
    }

    private static void out(int x){
        if(x >= 0)
            System.out.println("The number of X is: "+x);
        else
            System.out.println("No answer!");
    }

    private static void count(int i, int[] abc){
        if(i < abc[0])
            abc[0] = i;
        if(i > abc[1])
            abc[1] = i;
        abc[2] += i;
    }
}

Input & Output

3 12
The number of X is: 1

Reference

王晓东《计算机算法设计与分析》（第3版）P92-93

【算法设计与分析】经典常考三十三道例题&AC代码
米莱虾
11-13 1万+
小虾目前大三，我校在大一下开设《数据结构》这门课，大二上开了《算法设计与分析》这门课，很庆幸这两门课的上机考试总成绩一门100，一门99，最后总分也都90+。下文会给出机试的33道题目＆AC代码＆注释供大家参考。 《算法设计与分析》用的是屈婉玲老师的教材，上机习题用的是王晓东前辈的，开授这门课的教授表示：考虑到算法具有一定的难度，并不适合所有的学生，只讲授和考察四个专题的内容（贪心、递归与分治、动态规划、回溯与分值限界）
算法设计与分析第三章习题(1-10)参考代码
a123321a1233211的博客
10-26 563
3-1 独立任务最优调度问题 问题描述： 独立任务最优调度，又称双机调度问题：用两台处理机A和B处理n个作业。设第i个作业交给机器A处理时所需要的时间是a[i]，若由机器B来处理，则所需要的时间是b[i]。现在要求每个作业只能由一台机器处理，每台机器都不能同时处理两个作业。设计一个动态规划算法，使得这两台机器处理完这n个作业的时间最短（从任何一台机器开工到最后一台机器停工的总的时间）。研究一个实例：n=6, a = {2, 5, 7, 10, 5, 2}, b = {3, 8, 4, 11, 3, 4}.
实现3-9圈乘运算问题.cpp
06-01
实现3-9圈乘运算问题.cpp
圈乘运算问题
horizon_zore的博客
10-29 2745
思路源于Will_Lee_Buaa #include using namespace std; int NumLen(int x){//统计位数 int len = 0; while (x>0){ len++; x /= 10; } return len; } void Init(int* a, int x){//作初始化 int min = 10; int max =
北京理工大学数据结构与算法设计实验报告
08-05
数据结构与算法设计是计算机科学的核心课程之一，它涉及到如何高效地存储和处理数据，以及如何设计和分析解决问题的算法。在这个北京理工大学的实验报告中，主要涉及了四个实验，涵盖了链表、计算器、二叉树遍历以及...
运算问题
index_Bug的博客
04-26 210
<!DOCTYPE html> <html> <head> <meta charset="utf-8" /> <title></title> </head> <style type="text/css"> #num1,#num2,#result{ width: 100px; } </sty...
第十五章 动态规划——矩阵链乘法
weixin_34150830的博客
11-06 280
前言：今天接着学习动态规划算法，学习如何用动态规划来分析解决矩阵链乘问题。首先回顾一下矩阵乘法运算法，并给出C++语言实现过程。然后采用动态规划算法分析矩阵链乘问题并给出C语言实现过程。 1、矩阵乘法 　 　　       　　 　　从定义可以看出：只有当矩阵A的列数与矩阵B的行数相等时A×B才有意义。一个m×r的矩阵A左乘一个r×n的矩阵B，会得到一个m×n的矩阵C。在计算机中，...
乘法问题(动态规划)
Domacles
06-29 2008
乘法问题               ★☆   输入文件：chf.in   输出文件：chf.out   简单对比 时间限制：1 s   内存限制：128 MB 问题描述 设有一个长度为 N 的数字字符串，分成 K+1 个部分，使得 K+1 个部 分的乘积最大。 例如 N=6 ，且数字字符串为 ‘ 310143 ' ， K=3. 此时可能有的情况有以 下各种： 3 ＊
圆圈中一个加号/乘号是什么运算符
最新发布
再来一下！
03-21 1万+
在数学和计算机科学中，圆圈中的加号通常表示集合的并运算。这意味着将两个集合合并为一个新的集合，其中包含两个原始集合中的所有唯一元素。例如，如果有两个集合A和B，则A ∪ B表示将A和B中的所有元素组合成一个新的集合。在数学和计算机科学中，圆圈中的乘号通常表示集合的交运算。这意味着找到两个集合之间的共同元素，并将它们组合成一个新的集合。例如，如果有两个集合A和B，则A ∩ B表示A和B中共同的元素组成的新集合。
【总结】《算法设计与分析》第三章动态规划
慢慢前行，跨越预言
08-31 3286
第 3章  动态规划 习题总结 算法实现题 3-0 独立任务最优调度问题  {} 算法实现题 3-1 最少硬币问题  {} 算法实现题 3-2 序关系计数问题  {} 算法实现题 3-3 多重幂计数问题  {} 算法实现题 3-4 编辑距离问题  {} 算法
矩阵运算中一个圆圈中间一个乘号的运算是什么
zxc123qwer的博客
11-23 7284
在学习CNN的时候，发现卷积层的映射关系的式子（其中X为输入，W为卷积核，Y为输出）： 其中有个圆圈中间一个乘号的运算符不认识，查了之后知道这个叫克罗内克积，是张量积的一种特殊形式。 举例： （图片来自百度百科 qwq） ...
矩阵运算中一个圆圈里面一个乘号是什么运算？—— 克罗内克积
热门推荐
caoyuan666的博客
06-16 6万+
看论文里是否看到过这个符号：⨂ 是否意为是之前学的异或，不过发现是矩阵之间的运算，那这是什么呢？找了好久，才发现，是克罗内克积 1、定义 数学上，克罗内克积是两个任意大小的矩阵间的运算。克罗内克积是张量积的特殊形式，以德国数学家利奥波德·克罗内克命名。 2、举例 ...
算法笔记 - 矩阵连乘问题 动态规划
JiangNanMax的博客
12-25 1584
算法笔记 - 矩阵连乘问题 动态规划 Intro 下午课上提到了矩阵连乘，这是个经典的动态规划问题，复习一下。 主要就是自底向上的思路，枚举每个区间，子问题的最优解最后得到整体最优解（注意枚举的常见写法）。 状态转移方程： m(i,j)={0i=jmini≤k<j{m(i,k)+m(k+1,j)+ai(x)∗ak(y)∗aj(y)}i<jm(i, j)=\begin{cases} & 0 & i=j \\ & min_{i \leq k < j
动态规划数组连乘问题 详细过程+有注释的C代码
XinxingZh的博客
10-31 983
一个矩阵的列数等于另一个矩阵的行数，两个矩阵可以相乘。例如，一个 1×2的矩阵A 和一个 2×3的矩阵B相乘，得到一个1×3的矩阵，运算次数为1×2×3=6，同理，一个4×10的矩阵和一个10×35的矩阵相乘，运算次数为4×10×35=1400。多个矩阵相乘时，运算顺序不同，需要的运算次数也不同。
动态规划（四）矩阵连乘法
coolwriter的博客
04-12 6943
所谓矩阵链乘法是指当一些矩阵相乘时，如何加括号来改变乘法顺序从而来降低乘法次数。例如有三个矩阵连乘：A1*A2*A3，其维数分别为：10*100，100*5，5*50.如果按照（（A1*A2）A3）来计算的话，求（A1*A2）要10*100*5=5000次乘法，再乘以A3需要10*5*50=2500次乘法，因此总共需要7500次乘法。如果按照（A1（A2*A3））来计算的话，求（A2*A3）要10...
运算规则
qq_45719413的博客
12-28 1179
运算规则就是进位或借位规则，这个类似于一般计算机书籍中“位权“”的概念，例如对于十进制来说，该规则是“满十进一，借一当十”，也就是低位的数字满十了向高位进一，从高位借到的一，相当于低位上的十。其它的进制也是这样，对于二进制来说，就是“满二进一，借一当二”，八进制和十六进制也是这样。 在数学上表示一个数字是几进制，通常使用如下格式：[数值]进制数，例如[10]2 表示二进制数值 10。 ...
Barrett与Montgomery模乘算法原理及硬件实现
Barrett与Montgomery模乘算法是现代密码学中用于高效实现大整数模乘运算的两种核心优化技术，广泛应用于公钥密码系统（如RSA、ECC）中的模幂运算。这两种算法的核心思想在于通过数学变换和预处理机制，避免传统模乘...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值