light oj 1024 - Eid 大整数乘法

In a strange planet there are n races. They are completely different as well as their food habits. Each race has a food-eating period. That means the ith race eats after every xi de-sec (de-sec is the unit they use for counting time and it is used for both singular and plural). And at that particular de-sec they pass the whole day eating.

The planet declared the de-sec as ‘Eid‘ in which all the races eat together.

Now given the eating period for every race you have to find the number of de-sec between two consecutive Eids.

Input

Input starts with an integer T (≤ 225), denoting the number of test cases.

Each case of input will contain an integer n (2 ≤ n ≤ 1000) in a single line. The next line will contain n integers separated by spaces. The ith integer of this line will denote the eating period for the ith race. These integers will be between 1 and 10000.

Output

For each case of input you should print a line containing the case number and the number of de-sec between two consecutive Eids. Check the sample input and output for more details. The result can be big. So, use big integer calculations.

Sample Input

Output for Sample Input


2

3

2 20 10

4

5 6 30 60


Case 1: 20

Case 2: 60

题意分析:求出所有数的最小公倍数,转化为求出每一个数包含的素因子,多个数某一素因子相同取包含这一素因子最多的那一个,最后累乘起来

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<algorithm>
#define LL long long
using namespace std;
bool book[10005];
int pri[2101], s=0, ss;
int sum[10005], ans[2001], b[1005];
void inin()
{
    memset(book, true, sizeof(book));
    for(int i=2; i<=10000; i++)
    {
        if(book[i]){pri[s++]=i;
        for(int j=i+i; j<=10000; j+=i)
            book[j]=false;
        }
    }
}
int multiply()
{
    int p=0;
    ans[p]=1;
    for(int i=0; i<ss; i++)
    {
        int q=0;
        for(int j=0; j<=p; j++)
        {
            int qq=ans[j]*b[i]+q;
            q=qq/10000;
            ans[j]=qq%10000;//每四位存一下,节省空间节省时间
        }
        if(q>0)
            ans[++p]=q;
    }
    return p;
}
int main()
{
    int T, t=1, a;
    inin();
    scanf("%d", &T);
    while(T--)
    {
        ss=0;
        int n;
        scanf("%d", &n);
        memset(sum, 0, sizeof(sum));
        for(int i=0; i<n; i++)
        {
            scanf("%d", &a);
            for(int j=0; j<s; j++)
            {
                int q=0;
                while(a%pri[j]==0)
                {
                    q++;
                    a/=pri[j];
                }
                sum[pri[j]]=max(q,sum[pri[j]]);
            }
        }
        for(int i=0; i<s; i++)
        {
            int m=1;
            for(int k=0; k<sum[pri[i]]; k++)
                m*=pri[i];
            if(m>1)b[ss++]=m;
        }
        int mm=multiply();
        printf("Case %d: ", t++);
        printf("%d", ans[mm]);
        for(int i=mm-1; i>=0; i--)printf("%04d", ans[i]);
        printf("\n");
    }
    return 0;
}

还可以用java大整数搞一搞,经济实惠方便

    import java.util.*;
    import java.io.BufferedInputStream;
    import java.math.*;
    public class Main {
        public static void main(String[] args) {
            Scanner in=new Scanner(System.in);
            int T=in.nextInt();
            int t=1;
            while(T-->0)
            {
                BigInteger ans=BigInteger.ONE;
                int n=in.nextInt();
                while(n-->0)
                {
                    BigInteger a=in.nextBigInteger();
                    ans=ans.multiply(a).divide(ans.gcd(a));
                }
                System.out.print("Case"+" "+(t++)+":"+" ");
                System.out.println(ans);
                System.gc();
            }
            in.close();
        }
    }

原文地址:https://www.cnblogs.com/zhulei2/p/8184398.html

时间: 2024-10-11 03:34:43

light oj 1024 - Eid 大整数乘法的相关文章

POJ 1001 解题报告 高精度大整数乘法模版

题目是POJ1001 Exponentiation  虽然是小数的幂 最终还是转化为大整数的乘法 这道题要考虑的边界情况比较多 做这道题的时候,我分析了 网上的两个解题报告,发现都有错误,说明OJ对于错误的判断还不够严厉. 对边界情况的讨论其实应该是思维严密的表现,当然这并不能表明我写的一点错误都没有,只是多多分析一下还是很有好处的. #include <iostream> #include <fstream> #include <string> #include &l

大整数乘法python3实现

由于python具有无限精度的int类型,所以用python实现大整数乘法是没意义的,但是思想是一样的.利用的规律是:第一个数的第i位和第二个数大第j位相乘,一定累加到结果的第i+j位上,这里是从0位置开始算的.代码如下: import sys def list2str(li): while li[0]==0: del li[0] res='' for i in li: res+=str(i) return res def multi(stra,strb): aa=list(stra) bb=l

分治法解大整数乘法

在某些情况下,需要处理很大的整数,它无法在计算机中精确的表述和处理.若要精确的表示大整数,就必须使用软件的方法来实现大整数的运算.最常用的解决大整数运算的方法是使用一个二重循环,其算法时间复杂度为O(m*n)(其中m,n分别为两个大整数的长度):而选用分治方法则可以将算法时间复杂度降到O(n^(log3))(两个大整数的长度同为n).但分治方法的算法实现较为复杂,针对这个问题,本文借助标准C++实现了分治方法求解大整数乘法的算法. 下面分别介绍两种算法原理,及其实现: 1.使用二重循环控制两个数

大整数乘法问题

数组可以实现的算法很多,典型应用就是大整数相乘问题.利用的思想非常巧妙,感觉和链表实现多项式运算有异曲同工,大整数相乘主要避免计算机存储精度不够的时候.按照基本的乘法运算实现即可! 主要注意返回指针类型,和关键点k=i的技巧. /*! * \file 算法之美--大整数乘法问题.cpp * * \author ranjiewen * \date 2016/12/04 15:58 * * */ #include <iostream> using namespace std; #define SI

题目:大整数乘法、除法,楼梯走法,数组中不同数字,超过一半数字(好)

大整数乘法,可以用单个数字想乘,跟踪进位信息来处理. 大整数除法,可以先把除数增大到跟被除数相同的量级,然后累计相减.比如 555 / 3,就先把3增大到300,555能够减1次,那么结果+100,被除数变成255,依次进行. 楼梯走法:一次走一级,或者走两级.没什么难度. 数组中不同数字:如果是2n+1数组找出不同的那个数字,用异或就可以. 如果是找出超出一般数目的数字,用遍历,看到不一样的,就一起删除,这样的方式. 上网搜了一下,找出了更好的方法: 用变量记录备选数字,一个计数器记录该数字剩

使用快速傅里叶变换计算大整数乘法

我们知道,两个 N 位数字的整数的乘法,如果使用常规的算法,时间复杂度是 O(N2).然而,使用快速傅里叶变换,时间复杂度可以降低到 O(N logN loglogN). 假设我们要计算以下两个 N 位数字的乘积: a = (aN-1aN-2...a1a0)10 = aN-1x10N-1 + aN-2x10N-2 + ... + a1x101 + a0x100 b = (bN-1bN-2...b1b0)10 = bN-1x10N-1 + bN-2x10N-2 + ... + b1x101 + b

poj2389-Bull Math(大整数乘法)

一,题意: 大整数乘法模板题二,思路: 1,模拟乘法(注意"逢十进一") 2,倒序输出(注意首位0不输出) 三,步骤: 如:555 x 35 = 19425  5 5 5  5 5 5 x   3 5 x    3 5 -----------   ==>    ----------   2 7 7 5 25 25 25    + 1 6 6 5   +15 15 15 -------------  -----------------    1 9 4 2 5 15 40 40 2

大整数乘法 python实现

def recursive_multiply(x, y, n):   if n==1:     return x*y  else:    a = x/pow(10, n/2)    b = x-a*pow(10, n/2)    c = y/pow(10, n/2)   d = y-c*pow(10, n/2) ac = recursive_multiply(a, c, n/2)   bd = recursive_multiply(b, d, n/2)   p = recursive_multi

高精度计算-大整数乘法

大整数乘法 问题描述 求两个不超过 200 位的非负整数的积. 输入数据 有两行,每行是一个不超过 200 位的非负整数,没有多余的前导 0. 输出要求 一行,即相乘后的结果.结果里不能有多余的前导 0,即如果结果是 342,那么就不能 输出为 0342. 输入样例 12345678900 98765432100 输出样例 1219326311126352690000 解题思路 乘法规律,一个数的第i位和另一个数的第j位相乘,一定会累加到结果的第i+j位,结果的数组一个数组元素存2位数,最后对结