2. 算法分析

news2024/11/16 1:55:11

2. 算法分析

研究算法的最终目的就是如何花更少的时间，如何占用更少的内存去完成相同的需求。

我们要计算算法时间耗费情况，首先我们得度量算法的执行时间，那么如何度量呢？

2.1 算法的时间复杂度分析

事后分析估算方法：

比较容易想到的方法就是我们把算法执行若干次，然后拿个计时器在旁边计时，这种事后统计的方法看上去的确不

错，并且也并非要我们真的拿个计算器在旁边计算，因为计算机都提供了计时的功能。这种统计方法主要是通过设

计好的测试程序和测试数据，利用计算机计时器对不同的算法编制的程序的运行时间进行比较，从而确定算法效率

的高低，但是这种方法有很大的缺陷：必须依据算法实现编制好的测试程序，通常要花费大量时间和精力，测试完

了如果发现测试的是非常糟糕的算法，那么之前所做的事情就全部白费了，并且不同的测试环境(硬件环境)的差别

导致测试的结果差异也很大。

public static void main(String[] args) {
	long start = System.currentTimeMillis();
    int sum = 0;
    int n=100;
    for (int i = 1; i <= n; i++) {
    	sum += i;
	}
    System.out.println("sum=" + sum);
    long end = System.currentTimeMillis();
    System.out.println(end-start);
}

事前分析估算方法：

在计算机程序编写前，依据统计方法对算法进行估算，经过总结，我们发现一个高级语言编写的程序程序在计算机

上运行所消耗的时间取决于下列因素：

1.算法采用的策略和方案；

2.编译产生的代码质量；

3.问题的输入规模(所谓的问题输入规模就是输入量的多少)；

4.机器执行指令的速度；

由此可见，抛开这些与计算机硬件、软件有关的因素，一个程序的运行时间依赖于算法的好坏和问题的输入规模。

如果算法固定，那么该算法的执行时间就只和问题的输入规模有关系了。

我么再次以之前的求和案例为例，进行分析。

需求：

计算1到100的和。

第一种解法：

//如果输入量为n为1，则需要计算1次；
//如果输入量n为1亿，则需要计算1亿次；
public static void main(String[] args) {
    int sum = 0;//执行1次
    int n=100;//执行1次
    for (int i = 1; i <= n; i++) {//执行了n+1次
    	sum += i;//执行了n次
    }
	System.out.println("sum=" + sum);
}

第二种解法：

//如果输入量为n为1，则需要计算1次；
//如果输入量n为1亿，则需要计算1次；
public static void main(String[] args) {
    int sum = 0;//执行1次
    int n=100;//执行1次
    sum = (n+1)*n/2;//执行1次
    System.out.println("sum="+sum);
}

因此，当输入规模为n时，第一种算法执行了1+1+(n+1)+n=2n+3次；第二种算法执行了1+1+1=3次。如果我们把

第一种算法的循环体看做是一个整体，忽略结束条件的判断，那么其实这两个算法运行时间的差距就是n和1的差

距。

为什么循环判断在算法1里执行了n+1次，看起来是个不小的数量，但是却可以忽略呢？我们来看下一个例子：

需求：

计算100个1+100个2+100个3+…100个100的结果

代码：

public static void main(String[] args) {
    int sum=0;
    int n=100;
    for (int i = 1; i <=n ; i++) {
        for (int j = 1; j <=n ; j++) {
        sum+=i;
        }
    }
    System.out.println("sum="+sum);
}

上面这个例子中，如果我们要精确的研究循环的条件执行了多少次，是一件很麻烦的事情，并且，由于真正计算和

的代码是内循环的循环体，所以，在研究算法的效率时，我们只考虑核心代码的执行次数，这样可以简化分析。

我们研究算法复杂度，侧重的是当输入规模不断增大时，算法的增长量的一个抽象(规律)，而不是精确地定位需要

执行多少次，因为如果是这样的话，我们又得考虑回编译期优化等问题，容易主次跌倒。

我们不关心编写程序所用的语言是什么，也不关心这些程序将跑在什么样的计算机上，我们只关心它所实现的算

法。这样，不计那些循环索引的递增和循环终止的条件、变量声明、打印结果等操作，最终在分析程序的运行时间

时，最重要的是把程序看做是独立于程序设计语言的算法或一系列步骤。我们分析一个算法的运行时间，最重要的

就是把核心操作的次数和输入规模关联起来。

2.1.1 函数渐近增长

概念：

给定两个函数f(n)和g(n),如果存在一个整数N，使得对于所有的n>N,f(n)总是比g(n)大，那么我们说f(n)的增长渐近

快于g(n)。

概念似乎有点艰涩难懂，那接下来我们做几个测试。

测试一：

假设四个算法的输入规模都是n：

  1. 算法A1要做2n+3次操作，可以这么理解：先执行n次循环，执行完毕后，再有一个n次循环，最后有3次运算；

  2. 算法A2要做2n次操作；

  3. 算法B1要做3n+1次操作，可以这个理解：先执行n次循环，再执行一个n次循环，再执行一个n次循环，最后有 1 次运算。

  4. 算法B2要做3n次操作；

那么，上述算法，哪一个更快一些呢？

通过数据表格，比较算法A1和算法B1：

当输入规模n=1时，A1需要执行5次，B1需要执行4次，所以A1的效率比B1的效率低；

当输入规模n=2时，A1需要执行7次，B1需要执行7次，所以A1的效率和B1的效率一样；

当输入规模n>2时，A1需要的执行次数一直比B1需要执行的次数少，所以A1的效率比B1的效率高；

所以我们可以得出结论：

当输入规模n>2时，算法A1的渐近增长小于算法B1 的渐近增长

通过观察折线图，我们发现，随着输入规模的增大，算法A1和算法A2逐渐重叠到一块，算法B1和算法B2逐渐重叠

到一块，所以我们得出结论：

随着输入规模的增大，算法的常数操作可以忽略不计

测试二：

假设四个算法的输入规模都是n：

  1. 算法C1需要做4n+8次操作

  2. 算法C2需要做n次操作

  3. 算法D1需要做2n^2次操作

  4. 算法D2需要做n^2次操作

那么上述算法，哪个更快一些？

通过数据表格，对比算法C1和算法D1：

当输入规模n<=3时，算法C1执行次数多于算法D1，因此算法C1效率低一些；

当输入规模n>3时，算法C1执行次数少于算法D1，因此，算法D2效率低一些，

所以，总体上，算法C1要优于算法D1.通过折线图，对比对比算法C1和C2：

随着输入规模的增大，算法C1和算法C2几乎重叠

通过折线图，对比算法C系列和算法D系列：

随着输入规模的增大，即使去除n^2前面的常数因子，D系列的次数要远远高于C系列

因此，可以得出结论：

随着输入规模的增大，与最高次项相乘的常数可以忽略

测试三：

假设四个算法的输入规模都是n：

算法E1: 2n^2+3n+1;

算法E2： n^2

算法F1： 2n^3+3n+1

算法F2： n^3

那么上述算法，哪个更快一些？

通过数据表格，对比算法E1和算法F1：

当n=1时，算法E1和算法F1的执行次数一样；

当n>1时，算法E1的执行次数远远小于算法F1的执行次数；

所以算法E1总体上是由于算法F1的。

通过折线图我们会看到，算法F系列随着n的增长会变得特块，算法E系列随着n的增长相比较算法F来说，变得比较

慢，所以可以得出结论：

最高次项的指数大的，随着n的增长，结果也会变得增长特别快

测试四：

假设五个算法的输入规模都是n：

算法G： n^3;

算法H: n^2;

算法I： n:

算法J： logn

算法K: 1

那么上述算法，哪个效率更高呢？

通过观察数据表格和折线图，很容易可以得出结论：

算法函数中n最高次幂越小，算法效率越高

总上所述，在我们比较算法随着输入规模的增长量时，可以有以下规则：

1. 算法函数中的常数可以忽略；

2. 算法函数中最高次幂的常数因子可以忽略；

3. 算法函数中最高次幂越小，算法效率越高。

2.1.2 算法时间复杂度

2.1.2.1 大O记法

定义：

在进行算法分析时，语句总的执行次数T(n)是关于问题规模n的函数，进而分析T(n)随着n的变化情况并确定T(n) 的量级。算法的时间复杂度，就是算法的时间量度，记作:T(n)=O(f(n))。它表示随着问题规模n的增大，算法执行时间 的增长率和f(n)的增长率相同，称作算法的渐近时间复杂度，简称时间复杂度，其中f(n)是问题规模n的某个函数。

在这里，我们需要明确一个事情：执行次数=执行时间

用大写O()来体现算法时间复杂度的记法，我们称之为大O记法。一般情况下，随着输入规模n的增大，T(n)增长最慢的算法为最优算法。

下面我们使用大O表示法来表示一些求和算法的时间复杂度：

算法一：

public static void main(String[] args) {
    int sum = 0;//执行1次
    int n=100;//执行1次
    sum = (n+1)*n/2;//执行1次
    System.out.println("sum="+sum);
}

算法二：

public static void main(String[] args) {
    int sum = 0;//执行1次
    int n=100;//执行1次
    for (int i = 1; i <= n; i++) {
    	sum += i;//执行了n次
    }
    System.out.println("sum=" + sum);
}

算法三：

public static void main(String[] args) {
    int sum=0;//执行1次
    int n=100;//执行1次
    for (int i = 1; i <=n ; i++) {
        for (int j = 1; j <=n ; j++) {
        	sum+=i;//执行n^2次
        }
    }
    System.out.println("sum="+sum);
}

如果忽略判断条件的执行次数和输出语句的执行次数，那么当输入规模为n时，以上算法执行的次数分别为：

算法一：3次

算法二：n+3次

算法三：n^2+2次

如果用大O记法表示上述每个算法的时间复杂度，应该如何表示呢？基于我们对函数渐近增长的分析，推导大O阶

的表示法有以下几个规则可以使用：

1.用常数1取代运行时间中的所有加法常数；

2.在修改后的运行次数中，只保留高阶项；

3.如果最高阶项存在，且常数因子不为1，则去除与这个项相乘的常数；

所以，上述算法的大O记法分别为：

算法一：O(1)

算法二：O(n)

算法三：O(n^2)

2.1.2.2 常见的大O阶
1.线性阶

一般含有非嵌套循环涉及线性阶，线性阶就是随着输入规模的扩大，对应计算次数呈直线增长，例如：

public static void main(String[] args) {
    int sum = 0;
    int n=100;
    for (int i = 1; i <= n; i++) {
    	sum += i;
    }
    System.out.println("sum=" + sum);
}

上面这段代码，n=100，也就是说，外层循环每执行一次，内层循环就执行100次，那总共程序想要从这两个循环

中出来，就需要执行100*100次，也就是n的平方次，所以这段代码的时间复杂度是O(n^2).

2. 平方阶

一般嵌套循环属于这种时间复杂度

public static void main(String[] args) {
    int sum=0,n=100;
    for (int i = 1; i <=n ; i++) {
        for (int j = 1; j <=n ; j++) {
        	sum+=i;
        }
    }
    System.out.println(sum);
}

上面这段代码，n=100，也就是说，外层循环每执行一次，内层循环就执行100次，那总共程序想要从这两个循环

中出来，就需要执行100*100次，也就是n的平方次，所以这段代码的时间复杂度是O(n^2).

3.立方阶

一般三层嵌套循环属于这种时间复杂度

public static void main(String[] args) {
    int x=0,n=100;
    for (int i = 1; i <=n ; i++) {
        for (int j = i; j <=n ; j++) {
            for (int j = i; j <=n ; j++) {
            	x++;
            }
        }
    }
    System.out.println(x);
}

上面这段代码，n=100，也就是说，外层循环每执行一次，中间循环循环就执行100次，中间循环每执行一次，最

内层循环需要执行100次，那总共程序想要从这三个循环中出来，就需要执行100*100*100次，也就是n的立方，所以这段代码的时间复杂度是O(n^3).

4.对数阶

对数，属于高中数学的内容，我们分析程序以程序为主，数学为辅，所以不用过分担心。

int i=1,n=100;
while(i<n){
	i = i*2;
}

由于每次i*2之后，就距离n更近一步，假设有x个2相乘后大于n，则会退出循环。由于是2^x=n,得到x=log(2)n,所

以这个循环的时间复杂度为O(logn);

对于对数阶，由于随着输入规模n的增大，不管底数为多少，他们的增长趋势是一样的，所以我们会忽略底数。

5.常数阶

一般不涉及循环操作的都是常数阶，因为它不会随着n的增长而增加操作次数。例如：

public static void main(String[] args) {
    int n=100;
    int i=n+2;
    System.out.println(i);
}

上述代码，不管输入规模n是多少，都执行2次，根据大O推导法则，常数用1来替换，所以上述代码的时间复杂度

为O(1) 下面是对常见时间复杂度的一个总结：

他们的复杂程度从低到高依次为：

O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(n3)

根据前面的折线图分析，我们会发现，从平方阶开始，随着输入规模的增大，时间成本会急剧增大，所以，我们的

算法，尽可能的追求的是O(1),O(logn),O(n),O(nlogn)这几种时间复杂度，而如果发现算法的时间复杂度为平方

阶、 立方阶或者更复杂的，那我们可以分为这种算法是不可取的，需要优化。

2.1.2.3 函数调用的时间复杂度分析

之前，我们分析的都是单个函数内，算法代码的时间复杂度，接下来我们分析函数调用过程中时间复杂度。

案例一：

public static void main(String[] args) {
    int n=100;
    for (int i = 0; i < n; i++) {
    	show(i);
    }
}
private static void show(int i) {
	System.out.println(i);
}

在main方法中，有一个for循环，循环体调用了show方法，由于show方法内部只执行了一行代码，所以show方法的时间复杂度为O(1),那main方法的时间复杂度就是O(n)

案例二：

public static void main(String[] args) {
    int n=100;
    for (int i = 0; i < n; i++) {
    	show(i);
    }
}
private static void show(int i) {
    for (int j = 0; j < i; i++) {
    	System.out.println(i);
    }
}

在main方法中，有一个for循环，循环体调用了show方法，由于show方法内部也有一个for循环，所以show方法

的时间复杂度为O(n),那main方法的时间复杂度为O(n^2)

案例三：

public static void main(String[] args) {
    int n=100;
    show(n);
    for (int i = 0; i < n; i++) {
    	show(i);
    }
    for (int i = 0; i < n; i++) {
    	for (int j = 0; j < n; j++) {
    		System.out.println(j);
    	}
    }
}

private static void show(int i) {
    for (int j = 0; j < i; i++) {
    	System.out.println(i);
    }
}

在show方法中，有一个for循环，所以show方法的时间复杂度为O(n),在main方法中，show(n)这行代码内部执行

的次数为n，第一个for循环内调用了show方法，所以其执行次数为n^2,第二个嵌套for循环内只执行了一行代码，

所以其执行次数为n2,那么main方法总执行次数为n+n2+n2=2n2+n。根据大O推导规则，去掉n保留最高阶

项，并去掉最高阶项的常数因子2，所以最终main方法的时间复杂度为O(n^2)。

2.1.2.4 最坏情况

从心理学角度讲，每个人对发生的事情都会有一个预期，比如看到半杯水，有人会说：哇哦，还有半杯水哦！但也

有人会说：天哪，只有半杯水了。一般人处于一种对未来失败的担忧，而在预期的时候趋向做最坏的打算，这样即

使最糟糕的结果出现，当事人也有了心理准备，比较容易接受结果。假如最糟糕的结果并没有出现，当事人会很快

乐。 算法分析也是类似，假如有一个需求：

有一个存储了n个随机数字的数组，请从中查找出指定的数字。

public int search(int num){
    int[] arr={11,10,8,9,7,22,23,0};
    for (int i = 0; i < arr.length; i++) {
        if (num==arr[i]){
        	return i;
        }
    }
    return -1;
}

最好情况：

查找的第一个数字就是期望的数字，那么算法的时间复杂度为O(1)

最坏情况：

查找的最后一个数字，才是期望的数字，那么算法的时间复杂度为O(n)

平均情况：

任何数字查找的平均成本是O(n/2)

最坏情况是一种保证，在应用中，这是一种最基本的保障，即使在最坏情况下，也能够正常提供服务，所以，除非

特别指定，我们提到的运行时间都指的是最坏情况下的运行时间。

2.2 算法的空间复杂度分析

计算机的软硬件都经历了一个比较漫长的演变史，作为为运算提供环境的内存，更是如此，从早些时候的512k,经

历了1M，2M，4M…等，发展到现在的8G，甚至16G和32G，所以早期，算法在运行过程中对内存的占用情况也

是 一个经常需要考虑的问题。我么可以用算法的空间复杂度来描述算法对内存的占用。

2.2.1 java中常见内存占用

1.基本数据类型内存占用情况：

2.计算机访问内存的方式都是一次一个字节

3.一个引用（机器地址）需要8个字节表示：

例如： Date date = new Date(),则date这个变量需要占用8个字节来表示

4.创建一个对象

比如new Date()，除了Date对象内部存储的数据(例如年月日等信息)占用的内存，该对象本身也有内存开销，每个对象的自身开销是16个字节，用来保存对象的头信息。

5.一般内存的使用，如果不够8个字节，都会被自动填充为8字节：

6.数组的特殊性

java中数组被被限定为对象，他们一般都会因为记录长度而需要额外的内存。

一个原始数据类型的数组一般需要24字节的头信息(16个自己的对象开销，4字节用于保存长度以及4个填充字节)再加上保存值所需的内存。

2.2.2 算法的空间复杂度

了解了java的内存最基本的机制，就能够有效帮助我们估计大量程序的内存使用情况。

算法的空间复杂度计算公式记作：S(n)=O(f(n)),其中n为输入规模，f(n)为语句关于n所占存储空间的函数。

案例：

对指定的数组元素进行反转，并返回反转的内容。

解法一：

public static int[] reverse1(int[] arr){
    int n=arr.length;//申请4个字节
    int temp;//申请4个字节
    for(int start=0,end=n-1;start<=end;start++,end--){
        temp=arr[start];
        arr[start]=arr[end];
        arr[end]=temp;
    }
    return arr;
}

解法二：

public static int[] reverse2(int[] arr){
    int n=arr.length;//申请4个字节
    int[] temp=new int[n];//申请n*4个字节+数组自身头信息开销24个字节
    for (int i = n-1; i >=0; i--) {
    	temp[n-1-i]=arr[i];
    }
    return temp;
}

忽略判断条件占用的内存，我们得出的内存占用情况如下：

算法一：

​ 不管传入的数组大小为多少，始终额外申请4+4=8个字节；

算法二：

​ 4+4n+24=4n+28;

根据大O推导法则，算法一的空间复杂度为O(1),算法二的空间复杂度为O(n),所以从空间占用的角度讲，算法一要 优于算法二。 由于java中有内存垃圾回收机制，并且jvm对程序的内存占用也有优化（例如即时编译），我们无法精确的评估一个java程序的内存占用情况，但是了解了java的基本内存占用，使我们可以对java程序的内存占用情况进行估算。

由于现在的计算机设备内存一般都比较大，基本上个人计算机都是4G起步，大的可以达到32G，所以内存占用一般情况下并不是我们算法的瓶颈，普通情况下直接说复杂度，默认为算法的时间复杂度。

但是，如果你做的程序是嵌入式开发，尤其是一些传感器设备上的内置程序，由于这些设备的内存很小，一般为几kb，这个时候对算法的空间复杂度就有要求了，但是一般做java开发的，基本上都是服务器开发，一般不存在这样的问题。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/442798.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

关于web安全测试在功能测试中的应用

关于web安全测试在功能测试中的应用

关于web安全测试在功能测试中的应用 一、安全基本概念1.1实施安全评估1.1.1资产等级划分1.1.2威胁分析1.1.3风险分析1.1.4 安全方案 1.2 安全原则 二、我的安全测试模型三、安全测试在功能测试中的应用3.1 更改url3.2 逻辑缺陷&#xff1a;3.3 破坏流程顺序3.4 接口提示信息3.5…
阅读更多...
HNU-计算机系统-讨论课5

HNU-计算机系统-讨论课5

WARNING&#xff1a; 本题为开放性题目&#xff0c;所设计的也仅仅是一个可能的模型而已&#xff0c;再考虑到个人水平有限。在呈现效果上难免会有缺漏以及可行性的缺陷。故请批判性地接收&#xff01; 所以如果知识有错误或者缺漏&#xff0c;请一定要指出&#xff0c;您的建…
阅读更多...
计算机类大学生竞赛经验分享

计算机类大学生竞赛经验分享

如果你是作为一个科班出生的学习编程方向的一名在校大学生&#xff0c;那么如果对竞赛感兴趣&#xff0c;可以看看这篇文章 本人作为一名前端开发方向的学生&#xff0c;将自己这几年的参赛经验和比赛相关类型介绍分享给大家 首先我们要知道&#xff0c;竞赛分为三种大概的方向…
阅读更多...
《类和对象》（上篇）

《类和对象》（上篇）

本文主要对类和对象有一个初步的了解。 文章目录 前言1、类的引入和定义2、类的访问限定符及封装2.1 访问限定符2.2 封装 3 、类的作用域4 、类的实例化5 、类对象的模型5.1 类对象的大小5.2 类对象存储方式 6、this 指针6.1 引子6.2 特性6.3 this指针的一个问题 前言 C语言是面…
阅读更多...
MySQL插入和查询blob字段类型的sql语句

MySQL插入和查询blob字段类型的sql语句

创建表&#xff1a; CREATE TABLE t_inpatient_medical_records ( id bigint(20) NOT NULL AUTO_INCREMENT, inpatient_record_code varchar(32) DEFAULT NULL COMMENT 就诊流水号, patient_name varchar(256) DEFAULT NULL COMMENT 患者姓名, pat_id varchar(16) DEFAULT NULL…
阅读更多...
java数据类型的转换以及精度丢失

java数据类型的转换以及精度丢失

java数据类型的转换以及精度丢失_long转double会丢失精度吗_ღLiJia的博客-CSDN博客 一.浮点类型在计算机当中的存储 float存储需求是4字节&#xff08;32位&#xff09;, 其中1位最高位是符号位&#xff0c;中间8位表示阶位&#xff0c;后32位表示值 float的范围: -2^128 ~ …
阅读更多...
搞懂哈希散列

搞懂哈希散列

文章目录 1. 哈希概念2. 如何解决哈希冲突&#xff1f;3. 哈希函数概念4. 闭散列(目前淘汰的方法&#xff0c;了解&#xff09;**4.1.线性探测****4.2. 二次探测**4.3 闭散列查找与删除 5. 开散列6. 开散列与闭散列比较 1. 哈希概念 搜索树需要多次的关键码比较来搜索到结果&a…
阅读更多...
AutoGPT、AgentGPT、BabyAGI、HuggingGPT、CAMEL：各种基于GPT-4自治系统总结

AutoGPT、AgentGPT、BabyAGI、HuggingGPT、CAMEL：各种基于GPT-4自治系统总结

ChatGPT和LLM技术的出现使得这些最先进的语言模型席卷了世界&#xff0c;不仅是AI的开发人员&#xff0c;爱好者和一些组织也在研究探索集成和构建这些模型的创新方法。各种平台如雨后春笋般涌现&#xff0c;集成并促进新应用程序的开发。 AutoGPT的火爆让我们看到越来越多的自…
阅读更多...
Linux 3.14的设备树-实战开发代码

Linux 3.14的设备树-实战开发代码

OF提供的函数主要集中在drivers/of/目录下&#xff0c;有address.c,base.c,device.c,fdt.c,irq.c,platform.c等等 1&#xff0c;根据deice_node结构的full_name参数&#xff0c;在全局链表of_allnodes中&#xff0c;查找合适的device_node struct device_node *of_find_node_by…
阅读更多...
概率/期望dp

概率/期望dp

思维方式 概率/期望dp都是分析从当前状态能否去到其他情况&#xff0c;然后进行期望/概率公式的运算&#xff0c;最后消元推导出一般式。 ​​​​​​Problem - 4089 (hdu.edu.cn) 思路&#xff1a;概率dp&#xff0c;正推 分类讨论&#xff0c;设dp[i][j]表示i人的队伍在…
阅读更多...
力扣sql中等篇练习(八)

力扣sql中等篇练习(八)

力扣sql中等篇练习(八) 1 确认率 1.1 题目内容 1.1.1 基本题目信息1 1.1.2 基本题目信息2 1.1.3 示例输入输出 a 示例输入 b 示例输出 1.2 示例sql语句 # 分别统计没确认的用户和已经确认了的用户 SELECT s.user_id,ROUND(SUM(IF(c.actionconfirmed,1,0))/count(*),2) co…
阅读更多...
GPT模型支持下的Python-GEE遥感云大数据分析、管理与可视化技术及多领域案例应用

GPT模型支持下的Python-GEE遥感云大数据分析、管理与可视化技术及多领域案例应用

如今&#xff0c;Earth Engine凭借其强大的功能正受到越来越多国内外科技工作者的关注&#xff0c;应用范围也在不断扩大。学习致力于帮助科研工作者掌握Earth Engine的实际应用能力&#xff0c;以Python编程语言为基础&#xff0c;结合实例讲解平台搭建、影像数据分析、经典应…
阅读更多...
JAVA开发（H5商城嵌套到第三方H5商城进行异业合作方案）

JAVA开发（H5商城嵌套到第三方H5商城进行异业合作方案）

需求背景&#xff1a; 很多电商网站或者说是购物网站都是H5商城的方式&#xff0c;每个公司都有自己的H5商城。当公司和公司之间进行异业合作&#xff0c;商城互相导流甚至商城聚合时就需要H5商城和H5商城的嵌套和对接。假如存在A商城和B商城&#xff0c;现在需要B商城入驻到A商…
阅读更多...
CrackMapExec 域渗透工具使用

CrackMapExec 域渗透工具使用

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、CrackMapExec 是什么&#xff1f;二、简单使用1、获取帮助信息2、smb连接执行命令3、使用winrm执行命令&#xff08;躲避杀软&#xff09;4、smb 协议常用枚…
阅读更多...
Binder 驱动结构体列表

Binder 驱动结构体列表

下面列举 Binder 驱动相关的一些重要结构体 6~9 用于数据传输相关&#xff0c;其中 binder_write_read&#xff0c;binder_transaction_data进程空间和内核空间是通用的。 BWR 核心数据图表 binder_write_read 是整个 Binder IPC 过程&#xff0c;最为核心的数据结构之一 3.…
阅读更多...
品牌推广：如何让品牌在市场中保持活力并吸引更多的年轻人？

品牌推广：如何让品牌在市场中保持活力并吸引更多的年轻人？

在如今这个竞争激烈的市场环境中&#xff0c;让品牌年轻化已经成为了许多企业追求的目标。随着社会的不断发展和进步&#xff0c;消费者的需求和心理也在不断变化。因此&#xff0c;如果一个品牌想要在市场中保持活力并吸引更多的年轻人&#xff0c;就必须思考如何让品牌年轻化…
阅读更多...
【社区图书馆】读书推荐：《PyTorch高级机器学习实战》

【社区图书馆】读书推荐：《PyTorch高级机器学习实战》

读书推荐&#xff1a;《PyTorch高级机器学习实战》 作者&#xff1a;i阿极 作者简介&#xff1a;Python领域新星作者、多项比赛获奖者&#xff1a;博主个人首页 &#x1f60a;&#x1f60a;&#x1f60a;如果觉得文章不错或能帮助到你学习&#xff0c;可以点赞&#x1f44d;收藏…
阅读更多...
【GIT】git push后长时间没反应

【GIT】git push后长时间没反应

方向一 查看是否添加ssh 打开git bash cd ~/.ssh看是否成功&#xff0c;能成功说明之前生成过&#xff0c;看文件夹下是否有id_rsa.pub和id_rsa文件&#xff0c;有的话跳过生成步骤3 输入 ssh-keygen -t rsa -C ‘your_emailexample.com’(注&#xff1a;your_emailexample.c…
阅读更多...
人人都能GPT！微软开源DeepSpeed Chat帮用户训练模型

人人都能GPT！微软开源DeepSpeed Chat帮用户训练模型

简介 4月12日&#xff0c;微软宣布开源了 DeepSpeed Chat&#xff0c;帮助用户加速训练类似于 ChatGPT 的模型。 DeepSpeed Chat 能够简化 ChatGPT 类型模型的训练过程、强化推理体验。其中的 DeepSpeed-RLHF 系统能够在推理和训练两种模式之间进行切换&#xff0c;使复杂的 …
阅读更多...
【经典面试题目:最长递增子序列变形题目 | 动态规划 + 二分】

【经典面试题目:最长递增子序列变形题目 | 动态规划 + 二分】

&#x1f680; 算法题 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023