数学知识3

最新推荐文章于 2024-07-24 12:42:40 发布
最新推荐文章于 2024-07-24 12:42:40 发布
阅读量259 收藏
点赞数
分类专栏： 蓝桥杯学习 高级算法学习 文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42336835/article/details/123756761
版权

数学知识3

进制范围

一、基本数据类型的特点，位数，最大值和最小值。
1、
short -32768-32767

基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768 （-2的15此方）
最大值：Short.MAX_VALUE=32767 （2的15次方-1）

2、
2147483647

基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE= -2147483648 （-2的31次方）
最大值：Integer.MAX_VALUE= 2147483647  （2的31次方-1）

3、

基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808 （-2的63次方）
最大值：Long.MAX_VALUE=9223372036854775807 （2的63次方-1）

4、

基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45 （2的-149次方）
最大值：Float.MAX_VALUE=3.4028235E38 （2的128次方-1）

5、

基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324 （2的-1074次方）
最大值：Double.MAX_VALUE=1.7976931348623157E308 （2的1024次方-1）

进制可写位数

二、经实践证明，在代码中，能够写的位数。

1、首先是整型

int和long只能写10个数字，short只能写5个数字，多了就会报错。

int h=1234567890;

long w=1234567890;

short s=12345;

如果此时我在它们每个上面再加上一个数字，就会：

2、其次浮点

float的小数点后6位，double的小数点后16位。

float m=123.45566778465651454545f;

double n=3.1234567890123456789;

1.从定义上来看

int 是基本类型，直接存数值(类似的还有float、double、String、char)

Integer是对象，用一个引用指向这个对象(类似的有Float、Double、String)

2.从复杂度来看，

Java 中的数据类型分为基本数据类型和复杂数据类型

int 是前者；Integer 是后者(也就是一个类)

3.初始化的方式不同

int i =1;

Integer i= new Integer(1);//integer 是一个类

int 是基本数据类型(面向过程留下的痕迹，不过是对java的有益补充)；Integer 是一个类，是int的扩展，定义了很多的转换方法

注意：类似的还有：float Float;double Double;String等，其中String较为特殊，基本类型和复杂类似关键字相同。

例如，当需要往ArrayList，HashMap中放东西时，
像int，double这种内建类型是放不进去的，因为容器都是装 object的，
这是就需要这些内建类型的外覆类了。Java中每种内建类型都有相应的外覆类。

高斯消元法

在这里插入图片描述

输出结果为3种情况：
1.无解，
2.有唯一解
3.有无穷多解。

步骤：
代码
注意：

java中的小数保留的方法：
                BigDecimal b = new BigDecimal(d);
                DecimalFormat decimalFormat = new DecimalFormat("0.00#");
                String strVal = decimalFormat.format(b);
1.先使用BigDecimal将double数据转换b
2.使用DecimalFormat自己定义一种结构。 new DecimalFormat("0.00#")
3.用定义好的结构将之前的进行转换b。

package 数学知识;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.Scanner;

public class 高斯消元求方程解 {
    static int N = 10010;
    static double[][] g = new double[N][N];
    //关于浮点数一定要进行比较，得出最小的值
    static double eps =1e-6;//10^-6,比他小为0
    static int n;

    //第一行包含整数 n。
    //接下来 n 行，每行包含 n+1 个实数，表示一个方程的 n 个系数以及等号右侧的常数。

    public static void swap(double x, double y){
        double tmp = x;
        x = y;
        y = tmp;
    }

    public static int gauss(double[][] g){
        //行列
        int r,c;
        //找每一列里最大的哪一个值的那一行往上移动，交换位置
        for(r=0,c=0;c<n;c++){
            int t = r;//先赋初值
            //据说是因为找最大的那一行精度会更准
            for(int i=r;i<n;i++){
                if(Math.abs(g[i][c])>Math.abs(g[t][c])){
                    //说明绝对值最大的需要进行更换
                    t = i;
                }
            }
            //经过循环之后已经找到了最大值的那一行，判断判断是否为0，不为0用这一行进行消元
            if(Math.abs(g[t][c])<eps) continue;;

            //如果为0，跳出循环，如果不为0，则进行调整位置
            //调整位置时注意，这一行的每列元素都需要调整。
            for(int i=c;i<n+1;i++){
                swap(g[t][i],g[r][i]);
            }
            //交换完成
            //将系数变为1
            for(int i=n;i>=c;i--){
                //最大值已经在最上面了，所以进行变为1
                g[r][i] = g[r][i]/g[r][c];//从最后一列的第一行的数据开始的
            }
            //消元
            for(int i=r+1;i<n;i++){
                //判断是否wei0
                if(Math.abs(g[i][c]) >eps){
                    //如果这个数据不为0，再进行消为0
                    for(int j=n;j>=c;j--){//每列的元素也要进行变化
                        g[i][j] = g[i][j] - g[r][j]*g[i][c];
                    }
                }
            }
            r++;
        }
        if(r<n){
            //无解或者无穷解。
            for(int i=r;i<n;i++){
                if(Math.abs(g[i][n])>eps) return 2;
            }
            return 1;
        }
        //就剩唯一解
        for(int i= n-1;i>=0;i--){
            for(int j=i+1;j<n;j++){
                g[i][n] = g[i][n]- g[j][n]*g[i][j];
            }
        }
        return 0;
    }
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        //接收数据
        for(int i=0;i<n;i++){
            for(int j=0;j<n+1;j++){
                g[i][j] = sc.nextDouble();
            }
        }
        //g已经有初值
        int t = gauss(g);
        if(t==0){
            for(int i=0;i<n;i++) {
                double d = g[i][n];
                BigDecimal b = new BigDecimal(d);
                DecimalFormat decimalFormat = new DecimalFormat("0.00#");
                String strVal = decimalFormat.format(b);
                System.out.println(strVal);
            }
        }
        else if(t==1) System.out.println("Infinite group solutions");
        else System.out.println("No solution");
    }
}

求组合数1-（数字小）加法计数原理

数据范围
1≤n≤10000,
1≤b≤a≤2000
总结说是查表法

在这里插入图片描述
代码：
注意：
1.只有下三角，因为上三角数据不合理。
2.组合数累加原理。

package 数学知识;

import java.io.*;
import java.util.Scanner;

public class 求组合数12 {
    static int mod =1000000007;
    static int N = 2020;
    static long[][] f = new long[N][N];
    public static void Cmod(){
        //初始化
        for(int i=0;i<=2000;i++){//a
            for(int j=0;j<=i;j++){
                if(j==0) f[i][j] = 1;
                else f[i][j] = (f[i-1][j-1]+f[i-1][j])%mod;
            }
        }
    }
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
        int n = Integer.valueOf(reader.readLine());
        //Scanner sc = new Scanner(System.in);
        //int n = sc.nextInt();
        while (n-->0){
            String[] s = reader.readLine().split(" ");
            int a = Integer.valueOf(s[0]);
            int b = Integer.valueOf(s[1]);
            Cmod();
            System.out.println(f[a][b]);
        }
    }
}

在这里插入图片描述

组合数2-逆元+费马-（数1-100000）

1≤n≤10000,
1≤b≤a≤10^5

1.数据数变大，预处理方式不同，也是采用查表法。
1.一个是逆元表，infact【】
2.一个是阶乘表fact【】
b!-1 = (b-1!b)-1 = (b-1)!-1b-1
b-1 = b(109)+5=b-1!-1*b(mod-2)
在这里插入图片描述

在这里插入图片描述

把除法换成乘法。
1.快速幂
2.费马定义
3.输出
注意：先（long（））在int可以保证数据不丢失

代码：

package 数学知识;

import java.io.*;
import java.util.Scanner;

public class 求组合数23 {
    //先long在int数据不会少
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static int N = 1000007;
    static int p = 1000000007;
    static int[] fact = new int[N];
    static int[] infact = new int[N];

    public static int qui(int a,int b, int p){
        long res= 1;
        while (b!=0){
            if((b&1)==1) res = res*a%p;
            b = b>>1;
            a =(int) ((long)a*a%p);
        }
        return (int)res;
    }

    public static void feim_zuhe(){
        fact[0] = infact[0]=1;
        for(int i=1;i<=100000;i++){
            fact[i] = (int)( (long) fact[i-1]*i %p);
            infact[i] = (int)( (long) infact[i-1]*qui(i,p-2,p)%p);
        }
    }
    public static void main(String[] args) throws IOException {
        int n = Integer.valueOf(reader.readLine());
        while (n-->0){
            String[] s = reader.readLine().split(" ");
            int a = Integer.valueOf(s[0]);
            int b = Integer.valueOf(s[1]);
            feim_zuhe();
            int ans =(int) ((long)fact[a]*infact[b]%p*infact[a-b]%p);
            System.out.println(ans);
        }
    }
}

在这里插入图片描述

求组合数3-数超级大，lucas定理

1≤n≤20,
1≤b≤a≤10^18,
1≤p≤10^5,

每个数钞机无敌大，使用lucas
在这里插入图片描述

在这里插入图片描述
lucas定理的证明

在这里插入图片描述
在这里插入图片描述

高精度组合数-bigInteger

据范围较大超级大且要乘除所以想当然的使用高精

分解N!的质因子那理所当然
M!的质因子也能分解，
那这么说的话(N-M)!的质因子也一定能分解。
看到这应该也看明白了，C(N,M)=N!/M!/(N-M)!
求出质因子的用途就很想当然了我们可以把它的所有质因子乘起来这样既可得到最终答案。
而直接求出上面式子有些许困难我们不如直接求出N!的质因子接着减去这些除数的质因子。
这样就得出了答案所有的质因子。

1.筛质因子（N!,M!,(N-M)!）
2.上下相减因子求出质数的次数
3.盛器来

算出阶乘的质因子的次数：
例如
8！=1234567*8
本身应该有2里1个，4里面有2个，6里面有1个，8里面有3个
1+2+1+3 = 7。
利用公式：
8/2=4
8/4=2
8/8=1
=7
在这里插入图片描述
代码：
//最后高精度的转换一定要先进行初始化原始数
//线性筛的熟

package 数学知识;

import java.math.BigInteger;
import java.util.Scanner;

public class 求组合数44 {
    //筛质数
    //求个数，相减
    //累乘。
    static int N =5010;
    static int[] primes = new int[N];
    static boolean[] st = new boolean[N];
    static int num;//记录质数
    static int[] sum = new int[N];
    public static void get_primes(int n){
        for(int i=2;i<=n;i++){
            if(st[i] == false) primes[num++] = i;
            for(int j=0;primes[j]*i<=n;j++){
                st[primes[j]*i]=true;
                if(i%primes[j]==0) break;
            }
        }
    }
    //阶乘的质因子的次数
    public static int get(int a,int p){
        int cnu = 0;
        while (a!=0){
            cnu = cnu+a/p;
            a = a/p;
        }
        return cnu;
    }
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        //首先筛质数
        get_primes(a);
        //因为啊a>b
        for(int i=0;i<num;i++){
            sum[i] = get(a,primes[i])-get(b,primes[i])-get(a-b,primes[i]);
        }
        //现在的质因子次数就是剩下的
        //高精度计算
        BigInteger res = BigInteger.valueOf(1);
        for(int i=0;i<num;i++){//p
            BigInteger p = BigInteger.valueOf(primes[i]);
            for(int j=0;j<sum[i];j++){
                res = res.multiply(p);
            }
        }
        System.out.println(res);
    }
}

卡特数

根据范围选方法：
在这里插入图片描述
C(2n n)
= 2n!/n!(2n-n)!
= 2n!/n!n!
= (n+1)…(2n)/n!=(n+1)(n+2)(n+3)…2n/(123…n)/n+1
在这里插入图片描述
1.每一条cong(0,0)-(5,7)-都会走到
在这里插入图片描述
在这里插入图片描述
代码：

package 数学知识;

import java.util.Scanner;

public class 满足条件的01序列 {
    static int p = 1000000007;

    public static long qui_mi(int a,int b,int p){
        long res = 1;
        while (b!=0){
            if((b&1)==1)res = res *a %p;
            b = b>>1;
            a =(int) ((long)a*a%p);
        }
        return res;
    }


    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        int n = sc.nextInt();
        //上面
        long res = 1;
        for(int i=2*n;i>=n+1;i--){
            res = res*i%p;
        }
        //下面
        //将除法变为乘法，使用逆元的方式进行
        for(int i=1;i<=n;i++){
            res = res * qui_mi(i,p-2,p)%p;
        }
        //n+1
        res = res*qui_mi(n+1,p-2,p)%p;
        System.out.println(res);

    }
}
魔法少女啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数学知识
越看越喜欢啊
03-01 591
ACM题集：https://blog.csdn.net/weixin_39778570/article/details/83187443 质数 约数 同余 矩阵乘法 高斯消元和线性空间 组合计数 容斥原理和莫比乌斯函数 概率和数学期望 0/1分数规划 博弈论和SG函数 ...
求数对应的逆元素
NorburyL
07-01 585
例子： 求20 mod 79 对应逆元素 79 = 3 * 20 + 19 20 = 1 * 19 + 1 19 = 19 * 1 + 0 (余数为0) 1 3 第一行，1、3来自1*19和3*20,最少两个数 1 1 3*1+1 第二行 此处final为4 原理： 第二行的构造 x1 x2 x3 1 x1 x4 x5 x4 = (x1*x2)+1 x5 = (x4*x3)+x1 若第一行的个数为 奇数个，则结果为 n-final,偶数则为final 例题： 3 mo
将顺序表中的所有元素逆置
happy_bigqiang的博客
11-08 7206
题目:如题———-是你的代码#include <stdio.h> #include <stdlib.h>#define MaxSize 5 typedef int ElementType; typedef struct LNode * SeqList; struct LNode{ ElementType data[MaxSize]; ElementType Last; };SeqLi
O(n)打印逆元表
0.0
08-05 490
//O(n)打印逆元表 void init() { inv[1] = inv[0] = 1; for (LL i = 2; i &lt; maxn; i++) inv[i] = (mod - mod / i)*inv[mod%i] % mod; }
逆元打表
Bluelanzhan的博客
10-03 599
#include&lt;bits/stdc++.h&gt; using namespace std; const int mod = 998244353; int n ; long long inv[10005], f[10005]; void ni(int n) { inv[0] = inv[1] = 1; for(int i = 2; i &lt;= n; i++) { inv[...
离散数学知识点总结
11-05
离散数学知识点总结
ACM中的数学知识
05-14
ACM中的数学知识
高中数学知识点大全.pdf
07-05
高中数学知识点大全
高等数学知识点.pdf
04-26
高等数学知识点
五年级数学第3周周末作业数学知识.doc
10-13
数学知识考试试卷及答案
插入和选择排序
c23856的博客
07-20 529
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
【数据结构】搜索二叉树
最新发布
dab112的博客
07-24 540
介绍了二叉搜索树的实现与模拟
数据结构（二叉树-1）
2401_83968713的博客
07-20 1068
树是⼀种⾮线性的数据结构，它是由nn>=0） 个有限结点组成⼀个具有层次关系的集合。把它叫做 树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的。有⼀个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M>0)个互不相交的集合T1T2……Tm，其中每⼀个集合⼜是⼀棵结构与树类似的⼦树。每棵⼦树的根结点有且只有⼀个前驱，可以有0个或多个后继。因此，树是递归定义的。树形结构中，⼦树之间不能有交集，否则就不是树形结构。
【手撕数据结构】把玩顺序表
apple_61439616的博客
07-19 956
顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组线性结构又是什么意思，这就不得不提到线性表了线性表（linear list）是n个具有相同特性的数据元素的有限序列线性表是⼀种在实际中⼴泛使 ⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串注意的是，他在逻辑结构上一定是连续的，但在物理结构上不一定是连续的.线性表在物理上存储时，通常以数组和链式结构的形式存储那么我们知道，数组在内存中存储也是连续的，并且也是类型一致，那么他与顺序表的区别是什么呢.
《数据结构：栈和队列》
2401_83305953的博客
07-19 663
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行插入和删除操作的一端称为栈顶，另一端称为栈底。概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)队列也可以由数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。：栈的插入操作叫做进栈/压栈/入栈/，入数据在栈顶。
数据结构——二叉树定义
鲸落博客
07-23 367
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
数据结构：栈
sparrowfart的博客
07-19 1171
满足栈的特性，只有先进后出的特性，不能遍历，也就不能遍历打印，也不能随机访问。
中学 数学 知识图谱 nlp
09-06
中学数学知识图谱NLP（自然语言处理）是指使用NLP技术来构建和应用中学数学知识图谱。数学知识图谱是一种将数学知识组织成图结构的方式，可以帮助学生和教师更好地理解和应用数学知识。 中学数学知识图谱NLP的主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值