精华内容
下载资源
问答
  • 整数最大公约数

    千次阅读 2010-05-27 16:51:00
    关于最大公约数有最经典的欧几里得算法,下面对欧几里得算法进行基本证明: 假设用f(x,y)表示x y的最大公约数,取k=x/y,b=x%y,则x=ky+b,如果一个整数能够同时整除x和y,则必能同时整除b和y,能 够同时整除b和y...

        关于最大公约数有最经典的欧几里得算法,下面对欧几里得算法进行基本证明:

            假设用fxy)表示x y的最大公约数,取k=x/y,b=x%y,则x=ky+b,如果一个整数能够同时整除xy,则必能同时整除by,能           够同时整除by的数也必能同时整除xy,即xy的最大公约数和by的最大公约数是相同的,即有fxy=fyx%y)               (x>=y>0),如此处理便可把原问题转化为求两个更小的数的最大公约数,直到其中一个数为0,剩下的另外一个数就是两者的最大公 约数,则直接用递归实现


        然而取模在计算机中是非常昂贵的开销,尤其对超过264次方的大整数而言,那代价更是昂贵,即便改写成非递归的形式从而达到取消递归过程带来的额外资源消耗,采用欧几里得算法也不容乐观。因此应该想办法把取模运算去除。如果一个数能够同时整除xy,则必能够同时整除x-y,和y,而能够同时整除x-yy的数,也必能够同时整除xy,即xy的最大公约数与x-yy的最大公约数相同,即fxy=fx-yy

    因此有下面的代码实现:

     

    此算法有一个缺点就是如果要计算的两个数之间相差的数量级比较大,则算法实现的效率是很低的,例如gcd(2489124580, 4),可能要花数小时才能计算完。

    微软面试心得中提供了更快捷的算法,原理如下:

    原理:

    1f(x,y)=k*f(x1,y1)

    2、如果x=p*x1,假设p是素数,并且y%p!=0,那么f(x,y)=f(p*x1,y)=f(x1,y)

    由此可得到算法为:不断的对xy做除2操作,直至两者均不能被2整除,采用辗转相减法,获得一个可被2整除的数,继续做除2操作,循环,直至两数之一为0。详细描述如下:

    xy均为偶数,f(x,y) = 2*f(x/2,y/2) = 2*f(x>>1,y>>1)

    x为偶数,y为奇数,f(x,y) = f(x/2,y) = f(x>>1,y)

    x为奇数,y为偶数,f(x,y) = f(x,y/2) = f(x,y>>1)

    xy均为奇数,f(x,y) =f(y,x-y)

    代码如下:

    通过实验可知此算法的效率比第二种方法要高得多。

    代码中用到的大整数的实现以及详细的最大公约数的算法我已上传,如想下载请点击下面的链接:

    http://download.csdn.net/source/2397009 。

     

    展开全文
  • 输入一组无序的整数,编程输出其中出现次数最多的整数及其出现次数。 【输入形式】 先从标准输入读入整数的个数(大于等于1,小于等于100),然后在下一行输入这些整数,各整数之间以一个空格分隔。 【输出形式】...

    原题:

    【问题描述】

    输入一组无序的整数,编程输出其中出现次数最多的整数及其出现次数。

    【输入形式】

    先从标准输入读入整数的个数(大于等于1,小于等于100),然后在下一行输入这些整数,各整数之间以一个空格分隔。

    【输出形式】

    在标准输出上输出出现次数最多的整数及其出现次数,两者以一个空格分隔;若出现次数最多的整数有多个,则输出位置靠前的数。

    【样例输入】

    10

    0 -50 0 632 5813 -50 9 -50 0 632

    【样例输出】

    0 3

    【样例说明】

    输入了10个整数,其中出现次数最多的是0和-50,都是出现3次,但0靠前,所以输出0 3。

    【评分标准】该程序要求输出出现次数最多的整数和出现次数。

    import java.util.*;
    
    public class NumberRate {
    	public static void main(String[] args) {
    		Scanner in = new Scanner(System.in);
    
    		int num = in.nextInt(); // num表示输入的数组个数
    		int[] a = new int[num]; // 定义需要的数组
    		int Max = 0, temp = 0; // Max表示出现的次数(某个数出现的频率),temp用来标记出现次数最多的那个数的下标
    		Map<Integer, Integer> max = new HashMap<>(); // 哈希映射关系,这个数字作为其键值,对应其出现的次数
    
    		for (int i = 0; i < num; i++) {
    			a[i] = in.nextInt(); // 数组赋值
    
    			if (!max.containsKey(a[i])) { // 当键值不存在时,存入该数字
    				max.put(a[i], 0);
    			}
    			max.put(a[i], max.get(a[i]) + 1); // 统计同样的数字的出现次数
    
    			if (Max < max.get(a[i])) {
    				Max = max.get(a[i]); // 获取出现频率最高的次数
    			}
    		}
    
    		for (int i = 0; i < num; i++) {
    			if (max.get(a[i]) == Max) {
    				temp = i; // 若是多个数的频率一样则输出位置靠前的数。找出第一个出现频率最大的数
    				break;
    			}
    		}
    		System.out.println(a[temp] + " " + Max);
    	}
    }
    

    时间复杂度分析O(n+m).

    展开全文
  • 1、 给你一个整数数组 nums ,和一个表示限制的整数 limit,请你返回最长连续子数组的长度,该子数组中的任意两个元素之间的绝对差必须小于或者等于 limit 。如果存在满足条件的子数组,则返回 0 。

    给你一个整数数组 nums ,和一个表示限制的整数 limit,请你返回最长连续子数组的长度

    该子数组中的任意两个元素之间的绝对差必须小于或者等于 limit 。如果不存在满足条件的子数组,则返回 0 。

    • 示例 :
      输入:nums = [10,1,2,4,7,2], limit = 5
      输出:4
      解释:满足题意的最长子数组是 [2,4,7,2],其最大绝对差 |2-7| = 5 <= 5 。

    • 示例 2:
      输入:nums = [4,2,2,2,4,4,2,2], limit = 0
      输出:3

    • 分析

    连续子数组,组数组中最大值 - 最小值 <= limit
    设置队列中元素左边界i和右边界j,找出队列中的最大值max和最小值min(每次修改队列后都需要更改最大值最小值 ===> 考虑使用队列,规定队列的排序方式)

    • 如果新增元素与最大值最小值的差均符合条件,则右边界j右移,更新子数组的最长长度
    • 如果不符合条件,左边界向右移动

    代码:

        /**
         * 连续,子数组中最大值 - 最小值 <= limit
         * 设置队列元素的左边界i和右边界j
         * 找出这个队列中的最大值最小值
         * 如果新增元素与最大值最小值的差均符合条件,则右边界j右移
         * 如果不符合条件,左边界向右移动,同时更新最大值或最小值
         *
         * @param nums
         * @param limit
         * @return
         */
        public static int longestSubarray2(int[] nums, int limit) {
            if (nums.length == 0 || nums.length == 1) return nums.length;
            //i最左侧,j右侧元素,res结果
            int i = 0, j = 0, res = 1;
            int n = nums.length;
            PriorityQueue<Integer> min = new PriorityQueue<>();//获取最小值
            PriorityQueue<Integer> max = new PriorityQueue<>(Collections.reverseOrder());//规定队列排序的方式,获取最大值
            while (i < n && j < n) {
                if (min.size() == 0) {
                    min.add(nums[j]);
                    max.add(nums[j]);
                    j++;
                    continue;
                }
                //最大值 - 当前值  <= limit&& 最大值 - 当前值 <=limit
                if(Math.abs(nums[j]- min.peek() )<=limit && Math.abs(max.peek() - nums[j])<=limit){
                    min.add(nums[j]);
                    max.add(nums[j]);
                    res = Math.max(res,j-i+1);
                    j++;
                }else {
                    min.remove(nums[i]);
                    max.remove(nums[i]);
                    i++;
                }
            }
    
            return res;
        }
    
    展开全文
  • 今天做了一个C++练习题求两个整数的最小公倍数和最大公约数的算法及其C++实现,感觉可以做个整理笔记。 最大公约数 最大公约数(英语:Greatest Common Divisor,简写为G.C.D.;或Highest Common Factor,简写为H....

    今天碰到一道C++练习题求两个整数的最小公倍数和最大公约数的算法及其C++实现,感觉可以做个整理笔记。

    最大公约数
    最大公约数(英语:Greatest Common Divisor,简写为G.C.D.;或Highest Common Factor,简写为H.C.F.),指某几个整数共有约数中最大的一个。
    求两个整数最大公约数主要的方法:

    • 列举法:各自列出约数,再找出最大的公约数
    • 素因数分解法:两数各作素因数分解,然后取出共有的项相乘,所得的积就是这几个数的最大公约数。
    • 短除法:短除法求最大公约数,先用这几个数的公约数连续去除,一直除到所有的商互质为止,然后把所有的除数连乘起来,所得的积就是这几个数的最大公约数。
    • 辗转相除法:辗转相除法是求两个自然数的最大公约数的一种方法,也叫欧几里德算法。
      例如,求(319,377):
      ∵ 319÷377=0(余319)
      ∴(319,377)=(377,319);
      ∵ 377÷319=1(余58)
      ∴(377,319)=(319,58);
      ∵ 319÷58=5(余29),
      ∴ (319,58)=(58,29);
      ∵ 58÷29=2(余0),
      ∴ (58,29)= 29;
      ∴ (319,377)=29.
    • 扩展欧几里德算法:扩展欧几里得算法(又称扩充欧几里得算法)是用来解某一类特定的不定方程的一种方法,常用用来求解模线性方程及方程组。扩展的欧几里得算法可以用来计算模逆元,而模逆元在公钥密码学中占有举足轻重的地位。
      基本算法:对于不完全为 0 的非负整数 a,b,gcd(a,b)表示 a,b 的最大公约数,必然存在整数对 x,y ,使得 gcd(a,b)=ax+by。
      证明:设 a>b。
      1,显然当 b=0,gcd(a,b)=a。此时 x=1,y=0;
      2,ab≠0 时
      设 ax1+by1=gcd(a,b);
      bx2+(a mod b)y2=gcd(b,a mod b);
      根据朴素的欧几里德原理有 gcd(a,b)=gcd(b,a mod b);
      则:ax1+by1=bx2+(a mod b)y2;
      即:ax1+by1=bx2+(a-(a/b)*b)y2=ay2+bx2-(a/b)*by2;
      根据恒等定理得:x1=y2; y1=x2-(a/b)*y2;
      这样我们就得到了求解 x1,y1 的方法:x1,y1 的值基于 x2,y2.
      上面的思想是以递归定义的,因为 gcd 不断的递归求解一定会有个时候 b=0,所以递归可以结束。
    • 更相减损法:也叫更相减损术,是出自《九章算术》的一种求最大公约数的算法,它原本是为约分而设计的,但它适用于任何需要求最大公约数的场合。
      第一步:任意给定两个正整数;判断它们是否都是偶数。若是,则用2约简;若不是则执行第二步。
      第二步:以较大的数减较小的数,接着把所得的差与较小的数比较,并以大数减小数。继续这个操作,直到所得的减数和差相等为止。
      则第一步中约掉的若干个2与第二步中等数的乘积就是所求的最大公约数。
      其中所说的“等数”,就是最大公约数。求“等数”的办法是“更相减损”法。所以更相减损法也叫等值算法。
      例1、用更相减损术求98与63的最大公约数。
      解:由于63不是偶数,把98和63以大数减小数,并辗转相减:
      98-63=35
      63-35=28
      35-28=7
      28-7=21
      21-7=14
      14-7=7
      所以,98和63的最大公约数等于7。
      这个过程可以简单的写为:
      (98,63)=(35,63)=(35,28)=(7,28)=(7,21)=(7,14)=(7,7)=7.
      例2、用更相减损术求260和104的最大公约数。
      解:由于260和104均为偶数,首先用2约简得到130和52,再用2约简得到65和26。
      此时65是奇数而26不是奇数,故把65和26辗转相减:
      65-26=39
      39-26=13
      26-13=13
      所以,260与104的最大公约数等于13乘以第一步中约掉的两个2,即13*2*2=52。
      这个过程可以简单地写为:
      (260,104)(/2/2) =>(65,26)=(39,26)=(13,26)=(13,13)=13. (*2*2) => 52
    • Stein算法:Stein算法由J. Stein 1961年提出,这个方法也是计算两个数的最大公约数。和欧几里德算法算法不同的是,Stein算法只有整数的移位和加减法,这对于程序设计者是一个福音。
      设置A1=A、B1=B和C1=1
      1、如果An=0,Bn*Cn是最大公约数,算法结束
      2、如果Bn=0,An*Cn是最大公约数,算法结束
      3、如果An和Bn都是偶数,则An+1=An/2,Bn+1=Bn/2,Cn+1=Cn*2(注意,乘2只要把整数左移一位即可,除2只要把整数右移一位即可)
      4、如果An是偶数,Bn不是偶数,则An+1=An/2,Bn+1=Bn,Cn+1=Cn (很显然啦,2不是奇数的约数)
      5、如果Bn是偶数,An不是偶数,则Bn+1=Bn/2,An+1=An,Cn+1=Cn (很显然啦,2不是奇数的约数)
      6、如果An和Bn都不是偶数,则An+1=|An-Bn|,Bn+1=min(An,Bn),Cn+1=Cn
      7、n加1,转步骤1
      考虑欧几里德算法,最恶劣的情况是,每次迭代a=2b-1,这样,迭代后,r=b-1。如果a小于2N,这样大约需要4N次迭代。而考虑Stein算法,每次迭代后,显然A(n+1)B(n+1)≤AnBn/2,最大迭代次数也不超过4N次。也就是说,迭代次数几乎是相等的。但是,需要注意的是,对于大素数,试商法将使每次迭代都更复杂,因此对于大素数Stein将更有优势。
      以上内容整理自维基百科,百度百科

    C++实现

    • 辗转相除法:
    #include<iostream>
    int main()
    {
        int a,b,c;
        scanf("%d %d",&a,&b);
        if(a!=0&&b!=0)   //先判断输入整数中有无零值,有零值的话无法求公约数返回error;
        {
            do{
            c=a%b;
            a=b;
            b=c;
        }while(c);
        }
        else
            printf("error\n");
        printf("%d\n",a);
        return 0;
    }
    • 更相减损法:
    #include<iostream>
    #include<cmath>
    int main()
    {
        int a,b,n=0;
        scanf("%d %d",&a,&b);
        if(a!=0&&b!=0)   //先判断输入整数中有无零值,有零值的话无法求公约数返回error;
        {
            while(a%2==0&&b%2==0)
            {
                a/=2;
                b/=2;
                n++;
            }
            while(a!=b)
            {
                (a>b)?a-=b:b-=a;
            }
            a=a*pow(2,n);
            printf("%d\n",a);
        }
        else
            printf("error\n");
        return 0;
    }
    • Stein算法:
    #include<iostream>
    int gcd(int n,int m)      //适用于计算很大的数的最大公约数;
    {
        if(n==m)
            return n;
        else if(n==0)      //不明白这个算法为什么有零值还能求公约数,后头再查查
                return m;
        else if(m==0)
                return n;
        else if(m>n)
            return gcd(m,n);
        if(n%2==0)
        {
            if(m%2==0)
                return gcd(n>>1,m>>1)<<1;
            else
                return gcd(n>>1,m);
        }
        else
        {
            if(m%2==0)
                return gcd(n,m>>1);
            else
                return gcd((n-m)>>1,m);
        }
    }
    int main()
    {
        int a,b;
        scanf("%d %d",&a,&b);
        printf("%d\n",gcd(a,b));
        return 0;
    }

    最小公倍数
    最小公倍数是数论中的一个概念。若有一个数X,可以被另外两个数A、B整除,且X大于(或等于)A和B,则X为A和B的公倍数。A和B的公倍数有无限个,而所有的公倍数中,最小的公倍数就叫做最小公倍数。两个整数公有的倍数称为它们的公倍数,其中最小的一个正整数称为它们两个的最小公倍数。同样地,若干个整数公有的倍数中最小的正整数称为它们的最小公倍数。n整数 a1,a2,…,an的最小公倍数一般记作: [a1,a2,…,an],或者参照英文记法记作 lcm(a1,a2,…,an),其中lcm是英语中“最小公倍数”一词(lowest common multiple)的首字母缩写。
    例如,十天干和十二地支的混合称为一个阴历年,干支循环回归同一名称的所需时间,就是12和10的最小公倍数,即是60──一个“甲子”。
    (摘自维基百科)
    C++算法实现

    根据最大公约数来求最小公倍数,以辗转相除法为例:

    #include<iostream>
    int main()
    {
        int a,b,c,n,m;
        scanf("%d %d",&n,&m);
        if(n!=0&&m!=0)   //先判断输入整数中有无零值,有零值的话无法求公约数返回error;
        {
            a=n;
            b=m;
            do{
                c=a%b;
                a=b;
                b=c;
            }while(c);
        }
        else
            printf("error\n");
        printf("%d\n",n*m/a);
        return 0;
    }
    展开全文
  • 主要是最下面部分,x264参数介绍(二、分析和视频可用性信息) 【 翻译 】x264参数介绍(一、帧类型和码率控制) 2010年10月2日 评论 发表评论 翻译自:...
  • 食,水饮,题必须刷
  • 整数拆分(递归算法)

    千次阅读 2019-08-06 19:53:40
    所谓整数划分,是指把一个正整数n写成如下形式: ...如果{m1,m2,m3,…,mi}中的最大不超过m,即max{m1,m2,m3,…,mi} <= m,则称它属于n的一个m划分。 例如:当n=4时,它有5个划分:{4}、{3,1}、{2,2}、{2,1,1...
  • 整数拆分问题

    千次阅读 2013-09-30 15:07:06
    整数拆分问题 2013-02-28 21:41:51 分类: C/C++ ...整数分拆[编辑] ...一个正整数可以写成一些正整数的和。...其中最常见的问题就是给定正整数,求不同数组的数目,符合下面的条件:  (的大小不定)其
  • 整数分解方法

    万次阅读 多人点赞 2017-03-16 13:42:43
    题目大意:给定一个整数n,找到k个数,使得其和等于n。 如: 4=1+1+1+1 4=1+1+2; 4=1+3; 4=2+2; 4=4; 求其分解的所有可能,并输出分解表达式。 解题思路:要拆分整数n,肯定先要找到一个元素,然后我们会...
  • x264源代码简单分析:x264_slice_write()

    万次阅读 多人点赞 2015-05-17 18:36:39
    本文简单分析x264的x264_slice_write()的源代码。x264_slice_write()是x264项目的核心,它完成了编码了一个Slice的工作。根据功能的不同,该函数可以分为滤波(Filter),分析(Analysis),宏块编码(Encode)和熵...
  • 整数拆分问题的四种解法

    万次阅读 多人点赞 2015-04-01 21:17:09
    整数划分问题是算法中的一个经典命题之一   所谓整数划分,是指把一个正整数n写成如下形式: ...如果{m1,m2,m3,....,mi}中的最大不超过m,即max{m1,m2,m3,....,mi} &lt;= m,则称它属于n的一个m划分。这...
  • 将n划分成最大不超过k的划分数。  4. 将n划分成若干奇正整数之和的划分数。  5. 将n划分成若干不同整数之和的划分数。   1.将n划分成大于m的划分法:   1).若是划分多个整数可以存在相同的:  dp[n][m
  • 整数乘法算法

    万次阅读 2012-07-11 23:38:34
    X和Y都是n位的二进制整数,现在要计算它们的乘积XY。我们可以用小学所学的方法来设计一个计算乘积XY的算法,但是这样做计算步骤太多,显得效率较低。如果将每2个1位数的乘法或加法看作一步运算,那么这种方法要作O...
  • 字符串转换为整数

    千次阅读 2017-05-14 21:01:16
     输入一个表示整数的字符串,把该字符串转换成整数并输出,例如输入字符串"345",则输出整数345。 给定函数原型int StrToInt(const char *str) ,完成函数StrToInt,实现字符串转换成整数的功能,不得用库函数...
  • 关于c中的%x及其它格式化符

    万次阅读 2011-03-16 09:23:00
    格式化:%x表示按16进制输出;int a = 16;%02x:输出10;%03x:输出:010;%04x:输出:0010;
  • x264命令行参数解释

    千次阅读 2016-02-29 13:55:01
    词汇翻译: macroblock:宏区块。是一种图像压缩的术语。 宏区块是运动预测的基本单位,一张完整的图像...运行 x264 时带上 --help、--longhelp 或者 --fullhelp 即可看到帮助信息。三个选项给出的信息一个比一个详细。
  • x264源代码简单分析:编码器主干部分-1

    万次阅读 多人点赞 2015-05-11 17:10:51
    本文分析x264编码器主干部分的源代码。“主干部分”指的就是libx264中最核心的...这一部分源代码比较复杂,现在看了半天依然感觉很多地方太清晰,暂且把已经理解的地方整理出来,以后再慢慢补充还太清晰的地方。
  • x265-1.7版本-encoder/slicetype.cpp注释

    万次阅读 2016-01-23 14:24:01
    x265-1.7版本-encoder/slicetype.cpp注释
  • x265-1.8版本-encoder/slicetype.cpp注释

    万次阅读 2016-02-15 20:26:54
    x265-1.8版本-encoder/slicetype.cpp注释
  • x264参数设置详解(x264 settings)

    万次阅读 2018-02-11 12:03:37
    x264参数设置介绍x264参数的用法与目的。 x264 --fullhelpx264 设置Help(帮助)x264内置帮助文档,如需查看帮助,运行x264 加参数 –help, –longhelp 或 –fullhelp。
  • 整数划分问题

    千次阅读 2010-04-04 12:34:00
    中的最大不超过 m ,即 max(m1,m2,...,mi) ,则称它属于 n 的一个 m 划分。这里我们记 n 的 m 划分的个数为 f(n,m) 。 例如当 n=4 时,他有 5 个划分, {4},{3,1},{2,2},{2,1,1},{1,1,1,1} 。 注意 4=1+3 ...
  • JavaScript中的整数和浮点数

    千次阅读 2017-12-15 15:13:03
    JavaScript中的整数和浮点数
  • 思路1:可以用hash表来存储数组中的元素,这样我们取得一个数后,去判断sum - val 在在数组中,如果在数组中,则找到了一对二元组,它们的和为sum,该算法的缺点就是需要用到一个hash表,增加了空间复杂度。...
  • 整数溢出漏洞和格式化字符串漏洞

    千次阅读 2018-10-29 15:00:15
    有符号整数会在最高位用0表示正数,1表示负 数,而无符号整数则没有这种规则。 常见的整数类型有8位(单字节字符类型、布尔类型)、 16位(短整型)、32位(长整型)等。 当一个整数存入了比它本身小的存储...
  • printf('%08x',number)

    千次阅读 2012-11-25 18:07:52
    %x, %X 无符号以十六进制表示整数 %o 无符号以八进制表示整数 %g 自动选择合适的表示法 (1). 可以在"%"和字母之间插进数字表示最大场宽。 例如: %3d 表示输出3位整型数, 不够3位右对齐。 %9.2
  • x264参数中文详解(X264 Settings)

    万次阅读 2014-01-17 09:55:48
    x264参数中文详解(X264 Settings) 分类: x264/H.264 视频编解码 2013-09-09 14:15 356人阅读 评论(0) 收藏 举报 x264 转自:...
  • 第三十~三十一章:字符串转换成整数,通配符的字符串匹配问题前言 之前本一直想写写神经网络算法和EM算法,但写这两个算法实在需要大段大段的时间,而平时上班,周末则跑去北大教室自习看书(顺便以时间为序,说下...
  • 整数溢出问题——讲的不错

    千次阅读 2012-03-16 19:44:42
    C语言为编程者提供了三...例如现有算法要求如下:求满足条件1+2+3+…+n≤32767的最大整数n,请考察如下程序段: int n=1,sum=0; while(sum printf(“n=%d\n”,n-1); 乍看该程序时无错误,但事实上,上列程序中的wh

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 76,967
精华内容 30,786
关键字:

其中x表示不超过x的最大整数