【二十三】【算法分析与设计】三柱汉诺塔详解，计算子移动次数，正常递归计算，观察数据得出数学规律，递归图得出数学规律，将递归函数转化为递推式

目录

汉诺塔递归

汉诺塔子移动次数的计算

牛牛的汉诺塔

选择正常的递归模拟计算子移动次数

根据具体数据得出数学规律

根据递归图得出数学规律

将递归函数转化为递推式

结尾

汉诺塔递归

汉诺塔是一个经典问题，相传在古印度圣庙中，有一种被称为汉诺塔(Hanoi)的游戏。该游戏是在一块铜板装置上，有三根杆(编号A、B、C)，在A杆自下而上、由大到小按顺序放置n个金盘。游戏的目标：把A杆上的金盘全部移到C杆上，并仍保持原有顺序叠好。操作规则：每次只能移动一个盘子，并且在移动过程中三根杆上都始终保持大盘在下，小盘在上，操作过程中盘子可以置于A、B、C任一杆上。

汉诺塔以及其衍生问题往往使用递归来求解，也是学习和理解递归很好的老师。

其伪代码如下 

 

Function Hanoi(n,a,b,c)
    if n==1 then
        print(a+'->'+c)
    else
        Hanoi(n-1,a,c,b)
        print(a+'->'+c)
        Hanoi(n-1,b,a,c)
    end if
end Function 
 

定义递归函数hanoi(n,a,b,c)表示将n个盘子从a柱移动到c柱，以b柱为辅助柱。
 

维护定义的含义，内部逻辑先将n-1个盘子从a柱移动到b柱，以c柱为辅助柱。再将最大盘子从a柱移动到c柱，以b柱为辅助柱。最后将n-1个盘子从b柱移动到c柱，以a柱为辅助柱。
 

递归结束出口为n==1时，从a柱移动到c柱，以b柱为辅助柱。
 

C++代码
 

 

#include <iostream>
using namespace std;

// 函数声明
void hanoi(int n, char a, char b, char c) {
    if (n == 1) {
        cout << a << "->" << c<< endl;
        return;
    }
    hanoi(n-1, a, c, b);
    cout << a << " -> " << c<< endl;
    hanoi(n-1, b, a, c);
}

 

汉诺塔子移动次数的计算
 

牛牛的汉诺塔
 

 
 
链接：登录—专业IT笔试面试备考平台_牛客网 来源：牛客网
 
 
时间限制：C/C++ 1秒，其他语言2秒
 
 
空间限制：C/C++ 262144K，其他语言524288K
 
 
64bit IO Format: %lld
 
 
题目描述 
 
 
汉诺塔是一个经典问题，相传在古印度圣庙中，有一种被称为汉诺塔(Hanoi)的游戏。该游戏是在一块铜板装置上，有三根杆(编号A、B、C)，在A杆自下而上、由大到小按顺序放置n个金盘。游戏的目标：把A杆上的金盘全部移到C杆上，并仍保持原有顺序叠好。操作规则：每次只能移动一个盘子，并且在移动过程中三根杆上都始终保持大盘在下，小盘在上，操作过程中盘子可以置于A、B、C任一杆上。
 
 
汉诺塔以及其衍生问题往往使用递归来求解，也是学习和理解递归很好的老师。
 
 
 
 
其伪代码如下
 
 
Function Hanoi(n,a,b,c)
 
 
if n==1 then
 
 
print(a+'->'+c)
 
 
else
 
 
Hanoi(n-1,a,c,b)
 
 
print(a+'->'+c)
 
 
Hanoi(n-1,b,a,c)
 
 
end if
 
 
end Function
 
 
牛牛很快就理解了代码的意思并且写出了求解汉诺塔的程序，他现在想研究汉诺塔的规律。
 
 
请你统计以下信息：A->B,A->C,B->A,B->C,C->A,C->B的次数，以及所有移动的总步数。
 
 
输入描述:
 
 
仅一行，输入一个正整数n(1≤n≤60)(1 leq n leq 60)(1≤n≤60)表示汉诺塔的层数。
 
 
输出描述:
 
 
首先输出6行
 
 
A->B:XX
 
 
A->C:XX
 
 
B->A:XX
 
 
B->C:XX
 
 
C->A:XX
 
 
C->B:XX
 
 
分别表示每种移动情况出现的次数
 
 
最后输出一行
 
 
SUM:XX
 
 
表示所有移动情况的总和。
 
 
示例1
 
 
输入
 
 
复制3
 
 
3
 
 
输出
 
 
复制A->B:1 A->C:3 B->A:1 B->C:1 C->A:0 C->B:1 SUM:7
 
 
A->B:1
 
 
A->C:3
 
 
B->A:1
 
 
B->C:1
 
 
C->A:0
 
 
C->B:1
 
 
SUM:7
 
 
说明
 
 
伪代码所示算法的移动序列如下：
 
 
A->C
 
 
A->B
 
 
C->B
 
 
A->C
 
 
B->A
 
 
B->C
 
 
A->C
 
 
统计：
 
 
A->B出现1次
 
 
A->C出现3次
 
 
B->C出现1次
 
 
B->A出现1次
 
 
C->B出现1次
 
 
总计7次
 

 

选择正常的递归模拟计算子移动次数
 

 

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
LL N = 1000005;
LL MOD = 1e4 + 7;
LL N1 = 10005;



void Hanoi(int n, char a, char b, char c, int& count_ab, int& count_ac, int& count_ba, int& count_bc, int& count_ca, int& count_cb) {
        if (a == 'A' && c == 'B') count_ab++;
        if (a == 'A' && c == 'C') count_ac++;
        if (a == 'B' && c == 'A') count_ba++;
        if (a == 'B' && c == 'C') count_bc++;
        if (a == 'C' && c == 'A') count_ca++;
        if (a == 'C' && c == 'B') count_cb++;



        if (n == 1) {
        return;
        } else {
                Hanoi(n - 1, a, c, b, count_ab, count_ac, count_ba, count_bc, count_ca, count_cb);
                Hanoi(n - 1, b, a, c, count_ab, count_ac, count_ba, count_bc, count_ca, count_cb);
        }
}
int main() {
        int count_ab = 0;
        int count_ac = 0;
        int count_ba = 0;
        int count_bc = 0;
        int count_ca = 0;
        int count_cb = 0;
        char a = 'A', b = 'B', c = 'C';
    int n;
    cin>>n;
        Hanoi(n, a, b, c, count_ab, count_ac, count_ba, count_bc, count_ca, count_cb);

        int count=count_ab+count_ac+count_ba+count_bc+count_ca+count_cb;
        cout<<"A->B:"<<count_ab<<endl;
        cout<<"A->C:"<<count_ac<<endl;
        cout<<"B->A:"<<count_ba<<endl;
        cout<<"B->C:"<<count_bc<<endl;
        cout<<"C->A:"<<count_ca<<endl;
        cout<<"C->B:"<<count_cb<<endl;
        cout<<"SUM:"<<count;
}
 

我们可以通过递归关系式来表达这个问题的解法次数。对于n个盘子，移动它们所需的步骤T(n)可以表示为：
 

T(n)=2T(n−1)+1
 

这里的思路是：移动n-1个盘子到临时柱子（这需要T(n-1)步），移动最大的盘子到目标柱子（这需要1步），最后再将n-1个盘子从临时柱子移动到目标柱子上（再次需要T(n-1)步）。
 

我们可以进一步解开这个递归式：
 

  •  
    当n = 1时，只需要移动一次，所以T(1) = 1。
     
  •  
    当n = 2时，T(2) = 2T(1) + 1 = 3。
     
  •  
    当n = 3时，T(3) = 2T(2) + 1 = 7。
     
 

以此类推，我们发现这是一个等比数列的求和问题，其总和公式为：
 

T(n)=2^n−1
 

因此，汉诺塔问题的时间复杂度为O(2^n)。这个复杂度表明了随着盘子数量的增加，需要的移动次数呈指数级增长，这也解释了为什么汉诺塔问题在盘子数量稍多时就变得难以直接通过手动移动来解决。
 

 

当n==60时，时间复杂度是O(2^60)，2^10≈1000=10^3，2^60==2^10*2^10*2^10*2^10*2^10*2^10。也就是六个10^3相乘，等于10^18远远超过10^9，10^9对应的时间大概是1s，这样的递归是一定会超时的。
 

根据具体数据得出数学规律
 

我们将正常递归模拟计算子移动次数的代码进行修改，用来计算前n项的子移动次数数据。
 

 

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
LL N = 1000005;
LL MOD = 1e4 + 7;
LL N1 = 10005;



void Hanoi(int n, char a, char b, char c, int& count_ab, int& count_ac, int& count_ba, int& count_bc, int& count_ca, int& count_cb) {
    if (a == 'A' && c == 'B') count_ab++;
    if (a == 'A' && c == 'C') count_ac++;
    if (a == 'B' && c == 'A') count_ba++;
    if (a == 'B' && c == 'C') count_bc++;
    if (a == 'C' && c == 'A') count_ca++;
    if (a == 'C' && c == 'B') count_cb++;



    if (n == 1) {
        return;
    } else {
        Hanoi(n - 1, a, c, b, count_ab, count_ac, count_ba, count_bc, count_ca, count_cb);
        Hanoi(n - 1, b, a, c, count_ab, count_ac, count_ba, count_bc, count_ca, count_cb);
    }
 }
int main() {

    char a = 'A', b = 'B', c = 'C';
    cout<<"     ";
    cout << setw(8) << "a->b " << setw(8) << "a->c " << setw(8) << "b->a " << setw(8) << "b->c " << setw(8) << "c->a " << setw(8) << "c->b " << setw(8) << "SUM " << endl;
    for (int i = 1; i <= 20; i++) {
        int count_ab = 0;
        int count_ac = 0;
        int count_ba = 0;
        int count_bc = 0;
        int count_ca = 0;
        int count_cb = 0;
        Hanoi(i, a, b, c, count_ab, count_ac, count_ba, count_bc, count_ca, count_cb);

        int count = count_ab + count_ac + count_ba + count_bc + count_ca + count_cb;
        cout << "n="<<setw(2) << i<<":";
        cout << setw(7) << count_ab << " ";
        cout << setw(7) << count_ac << " ";
        cout << setw(7) << count_ba << " ";
        cout << setw(7) << count_bc << " ";
        cout << setw(7) << count_ca << " ";
        cout << setw(7) << count_cb << " ";
        cout << setw(7) << count << endl;
    }

 }
 

 

//输出
        a->b    a->c    b->a    b->c    c->a    c->b     SUM
n= 1:      0       1       0       0       0       0       1
n= 2:      1       1       0       1       0       0       3
n= 3:      1       3       1       1       0       1       7
n= 4:      4       3       1       4       2       1      15
n= 5:      4       9       6       4       2       6      31
n= 6:     15       9       6      15      12       6      63
n= 7:     15      31      27      15      12      27     127
n= 8:     58      31      27      58      54      27     255
n= 9:     58     117     112      58      54     112     511
n=10:    229     117     112     229     224     112    1023
n=11:    229     459     453     229     224     453    2047
n=12:    912     459     453     912     906     453    4095
n=13:    912    1825    1818     912     906    1818    8191
n=14:   3643    1825    1818    3643    3636    1818   16383
n=15:   3643    7287    7279    3643    3636    7279   32767
n=16:  14566    7287    7279   14566   14558    7279   65535
n=17:  14566   29133   29124   14566   14558   29124  131071
n=18:  58257   29133   29124   58257   58248   29124  262143
n=19:  58257  116515  116505   58257   58248  116505  524287
n=20: 233020  116515  116505  233020  233010  116505 1048575
 

我们将a->b,a->c,b->a,b->c,c->a,c->b分别记为1,2,3,4,5,6。
 

我们希望找出前后项的规律，很容易发现，同一个n中，1号等于4号，3号等于6号。
 

因此我们将数据截取出1,2,3,5四列数据。做法很简单，只需要简单修改代码即可。
 

 

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
LL N = 1000005;
LL MOD = 1e4 + 7;
LL N1 = 10005;



void Hanoi(int n, char a, char b, char c, int& count_ab, int& count_ac, int& count_ba, int& count_bc, int& count_ca, int& count_cb) {
    if (a == 'A' && c == 'B') count_ab++;
    if (a == 'A' && c == 'C') count_ac++;
    if (a == 'B' && c == 'A') count_ba++;
    if (a == 'B' && c == 'C') count_bc++;
    if (a == 'C' && c == 'A') count_ca++;
    if (a == 'C' && c == 'B') count_cb++;



    if (n == 1) {
        return;
    } else {
        Hanoi(n - 1, a, c, b, count_ab, count_ac, count_ba, count_bc, count_ca, count_cb);
        Hanoi(n - 1, b, a, c, count_ab, count_ac, count_ba, count_bc, count_ca, count_cb);
    }
 }
int main() {

    char a = 'A', b = 'B', c = 'C';
    cout << "     ";
    cout << setw(8) << "a->b ";
    cout << setw(8) << "a->c ";
    cout << setw(8) << "b->a ";
//    cout << setw(8) << "b->c ";
    cout << setw(8) << "c->a ";
//    cout << setw(8) << "c->b ";
    cout << setw(8) << "SUM " << endl;
    for (int i = 1; i <= 20; i++) {
        int count_ab = 0;
        int count_ac = 0;
        int count_ba = 0;
        int count_bc = 0;
        int count_ca = 0;
        int count_cb = 0;
        Hanoi(i, a, b, c, count_ab, count_ac, count_ba, count_bc, count_ca, count_cb);

        int count = count_ab + count_ac + count_ba + count_bc + count_ca + count_cb;
        cout << "n=" << setw(2) << i << ":";
        cout << setw(7) << count_ab << " ";
        cout << setw(7) << count_ac << " ";
        cout << setw(7) << count_ba << " ";
//        cout << setw(7) << count_bc << " ";
        cout << setw(7) << count_ca << " ";
//        cout << setw(7) << count_cb << " ";
        cout << setw(7) << count << endl;
    }

 }
 

 

//输出
        a->b    a->c    b->a    c->a     SUM
n= 1:      0       1       0       0       1
n= 2:      1       1       0       0       3
n= 3:      1       3       1       0       7
n= 4:      4       3       1       2      15
n= 5:      4       9       6       2      31
n= 6:     15       9       6      12      63
n= 7:     15      31      27      12     127
n= 8:     58      31      27      54     255
n= 9:     58     117     112      54     511
n=10:    229     117     112     224    1023
n=11:    229     459     453     224    2047
n=12:    912     459     453     906    4095
n=13:    912    1825    1818     906    8191
n=14:   3643    1825    1818    3636   16383
n=15:   3643    7287    7279    3636   32767
n=16:  14566    7287    7279   14558   65535
n=17:  14566   29133   29124   14558  131071
n=18:  58257   29133   29124   58248  262143
n=19:  58257  116515  116505   58248  524287
n=20: 233020  116515  116505  233010 1048575
 

我们希望由上面的数据找出前后项的关系，我们对a->b,a->c,b->a,c->a重新进行编号，分别记为1,2,3,4。
 

我们需要用的n-1项的1,2,3,4号数据推导出n项的1,2,3,4号数据。
 

找规律的思路是，我们可以先关注n项的1号数据，看n-1项的某一号数据是否可以单独推导出n项的1号数据。1对1的关系。如果1对1的关系找不到，那就找n-1项的多号数据是否可以推导出1号数据，以此类推。
 

 

先关注n项1号与n-1项一对一的关系。
 

当n==7时，1号等于n==6的（2号*2-3），等于（3号*2+3）。
 

当n==8时，1号等于n==7的（2号*2-4），等于（3号*2+4）。
 

当n==9时，1号等于n==8的（2号*2-4），等于（3号*2+4）。
 

当n==10时，1号等于n==9的（2号*2-5），等于（3号*2+5）。
 

很容易发现递推公式，n项的1号等于n-1项的（2号*2-n/2）或者等于（3号*2+n/2）。
 

找到1号的递推式，我们接着找2号的递推式。
 

 

先关注n项2号与n-1项一对一的关系。
 

当n==7时，2号等于n==6的（1号*2+1）。
 

当n==8时，2号等于n==7的（1号*2+1）。
 

当n==9时，2号等于n==8的（1号*2+1）。
 

当n==10时，2号等于n==9的（1号*2+1）。
 

很容易发现递推公式，n项的2号等于n-1项的（2号*2+1）。
 

找到2号的递推式，我们接着找3号的递推式。
 

 

先关注n项3号与n-1项一对一的关系。
 

当n==7时，3号等于n==6的（1号*2-3）。
 

当n==8时，3号等于n==7的（1号*2-3）。
 

当n==9时，3号等于n==8的（1号*2-4）。
 

当n==10时，3号等于n==9的（1号*2-4）。
 

很容易发现递推公式，n项的3号等于n-1项的（1号*2-（n-1）/2）。
 

找到3号的递推式，我们接着找4号的递推式。
 

 

先关注n项4号与n-1项一对一的关系。
 

当n==7时，4号等于n==6的（3号*2）。
 

当n==8时，4号等于n==7的（3号*2）。
 

当n==9时，4号等于n==8的（3号*2）。
 

当n==10时，4号等于n==9的（3号*2）。
 

很容易发现递推公式，n项的4号等于n-1项的（3号*2）。
 

接着我们就可以利用递推式直接求前后项的数据。
 

 

其实我们可以发现，上述的前后项关系不仅仅是上述的几种，例如n项的1号等于n-1项的（1号+2号），n项的3号等于n-1项的（1号+4号）等等。我们知道的是这些推导公式都可以推导出前后项关系，得到递推式。
 

 

#include<bits/stdc++.h>
using namespace std;
using LL=long long;
int main(){
    int n;cin>>n;
    vector<vector<LL>> a(n+1,vector<LL>(4));
    a[1][1]=1;
    for(int i=2;i<=n;i++){
        a[i][0]=a[i-1][1]+a[i-1][2];
        a[i][1]=a[i-1][0]*2+1;
        a[i][2]=a[i-1][3]*2+(i-1)/2;
        a[i][3]=a[i-1][2]*2;
    }
    
    cout<<"A->B:"<<a[n][0]<<endl;
    cout<<"A->C:"<<a[n][1]<<endl;
    cout<<"B->A:"<<a[n][2]<<endl;
    cout<<"B->C:"<<a[n][0]<<endl;
    cout<<"C->A:"<<a[n][3]<<endl;
    cout<<"C->B:"<<a[n][2]<<endl;
    cout<<"SUM:"<<a[n][0]*2+a[n][1]+a[n][2]*2+a[n][3]<<endl;
}
 

根据递归图得出数学规律
 

 

 

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main() {
        int n;
        cin >> n;
        LL count_ab = 0, count_ac = 0, count_ba = 0, count_bc = 0, count_ca = 0, count_cb = 0;
        LL length = 1;
        for (int i = 1; i <= n; i++) {
                if (i != 1)length *= 2;
                if (i % 2 == 1) {
                        LL tempcount = length / 3;
                        count_ac += tempcount;
                        count_cb += tempcount;
                        count_ba += tempcount;
                        LL tempcount1 = length % 3;
                        if (tempcount1 == 1) {
                                count_ac++;
                        } else {
                                count_ac++;
                                count_cb++;
                        }
                } else {
                        LL tempcount = length / 3;
                        count_ab += tempcount;
                        count_bc += tempcount;
                        count_ca += tempcount;
                        LL tempcount1 = length % 3;
                        if (tempcount1 == 1) {
                                count_ab++;
                        } else {
                                count_ab++;
                                count_bc++;
                        }
                }
        }

        cout << "A->B:" << count_ab << endl;
        cout << "A->C:" << count_ac << endl;
        cout << "B->A:" << count_ba << endl;
        cout << "B->C:" << count_bc << endl;
        cout << "C->A:" << count_ca << endl;
        cout << "C->B:" << count_cb << endl;
        cout << "SUM:" << count_ab + count_ac + count_ba + count_bc + count_ca + count_cb << endl;
}
 

将递归函数转化为递推式
 

 

 

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main() {
        int n;
        cin >> n;
        vector<vector<LL>> dp(3,vector<LL>(7));
        dp[1][2] = 1;
        for (int i = 2; i <= n; i++) {
                dp[2][1] = dp[1][2] + dp[1][3];
                dp[2][2] = dp[1][1] + dp[1][4] + 1;
                dp[2][3] = dp[1][1] + dp[1][5];
                dp[2][4] = dp[1][2] + dp[1][6];
                dp[2][5] = dp[1][6] + dp[1][3];
                dp[2][6] = dp[1][5] + dp[1][4];

                dp[1][1] = dp[2][1];
                dp[1][2] = dp[2][2];
                dp[1][3] = dp[2][3];
                dp[1][4] = dp[2][4];
                dp[1][5] = dp[2][5];
                dp[1][6] = dp[2][6];
        }

        cout << "A->B:" << dp[1][1] << endl;
        cout << "A->C:" << dp[1][2] << endl;
        cout << "B->A:" << dp[1][3] << endl;
        cout << "B->C:" << dp[1][4] << endl;
        cout << "C->A:" << dp[1][5] << endl;
        cout << "C->B:" << dp[1][6] << endl;
        cout << "SUM:" << dp[1][1] + dp[1][2] + dp[1][3] + dp[1][4] + dp[1][5] + dp[1][6] << endl;
}
 

结尾
 

最后，感谢您阅读我的文章，希望这些内容能够对您有所启发和帮助。如果您有任何问题或想要分享您的观点，请随时在评论区留言。
 

 

同时，不要忘记订阅我的博客以获取更多有趣的内容。在未来的文章中，我将继续探讨这个话题的不同方面，为您呈现更多深度和见解。
 

 

谢谢您的支持，期待与您在下一篇文章中再次相遇！

                

        

        

                    

                    

                    

                    

                        

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

                        如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！
                    

                    
                    

                        
                    

                

                

                    相关文章

                
                

                    

                        

                            

                                
                                    【框架】说一说 Fork/Join？
                            

                        

                        

                            

                                【框架】说一说 Fork/Join？
                            

                            

                                SueWakeup 个人主页&#xff1a;SueWakeup 系列专栏&#xff1a;学习Java框架 个性签名&#xff1a;人生乏味啊&#xff0c;我欲令之光怪陆离  本文封面由 凯楠&#x1f4f7; 友情赞助 目录 
前言 
什么是 Fork&#xff1f; 
什么是 Join&#xff1f; 
Fork/Join 的核心组件 
F…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    基于K-近邻的PLOSAR图像分类
                            

                        

                        

                            

                                基于K-近邻的PLOSAR图像分类
                            

                            

                                &#x1f380;个人主页&#xff1a; https://zhangxiaoshu.blog.csdn.net &#x1f4e2;欢迎大家&#xff1a;关注&#x1f50d;点赞&#x1f44d;评论&#x1f4dd;收藏⭐️&#xff0c;如有错误敬请指正! &#x1f495;未来很长&#xff0c;值得我们全力奔赴更美好的生活&…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    网络原理(6)——IP协议
                            

                        

                        

                            

                                网络原理(6)——IP协议
                            

                            

                                目录 
一、网段划分 
现在的网络划分&#xff1a; 
1、一般情况下的家庭网络环境 
2、IP地址 
3、子网掩码 
4、网关 
以前的网络划分&#xff1a; 
二、特殊IP 
1、环回 IP 
2、主机号为全 0 的IP 
3、广播地址IP 
三、路由选择&#xff08;路线规划&#xff09; 一、网段划分…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    智慧城管综合执法办案系统，现场移动执法APP源码，占道经营AI智能识别分析系统
                            

                        

                        

                            

                                智慧城管综合执法办案系统，现场移动执法APP源码，占道经营AI智能识别分析系统
                            

                            

                                智慧城管执法平台源码 智慧城管综合执法办案系统&#xff0c;提供了案件在线办理、当事人信用管理、文书电子送达、沿街店铺分析等功能&#xff0c;全面赋能执法队员&#xff0c;提高执法队员办案效率。 
智慧城管综合执法办案系统在业务上能够支持所有行政处罚权力项目的网上运…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    systrace抓取
                            

                        

                        

                            

                                systrace抓取
                            

                            

                                1. 抓取systrace日志 
adb root
adb shell
atrace -z -b 8192 video gfx input view wm rs hal sched freq idle irq -t 10 > /sdcard/trace_output atrace: Android Trace命令&#xff0c;用于在Android系统上进行性能跟踪和分析。 -z: 压缩跟踪数据&#xff0c;减小输出文…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    Excel中最常用的快捷健，每天都会用到
                            

                        

                        

                            

                                Excel中最常用的快捷健，每天都会用到
                            

                            

                                Hello&#xff0c;大家好&#xff0c;今天跟大家分享我们工作中经常使用的快捷键&#xff0c;快捷键能够在一定程度上提高我们的工作效率&#xff0c;快速达到我们想要的结果&#xff0c;善用快捷键也能让别人觉得你非常的厉害。 
1快速求和 &#xff1a;Alt 
使用方法非常的简…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    Python编程异步爬虫实战案例
                            

                        

                        

                            

                                Python编程异步爬虫实战案例
                            

                            

                                aiohttp异步爬取实战 
案例介绍 
链接为https://spa5.scrape.center&#xff0c;页面如下图所示&#xff1a; 这是一个图书网站&#xff0c;整个网站包含数千本图书信息&#xff0c;网站数据是JavaScript渲染而得的&#xff0c;数据可以通过Ajax接口获取&#xff0c;并且接口没…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    深度学习 - PyTorch基本流程 (代码)
                            

                        

                        

                            

                                深度学习 - PyTorch基本流程 (代码)
                            

                            

                                直接上代码 
import torch 
import matplotlib.pyplot as plt 
from torch import nn# 创建data
print("**** Create Data ****")
weight  0.3
bias  0.9
X  torch.arange(0,1,0.01).unsqueeze(dim  1)
y  weight * X  bias
print(f"Number of X samples: {len(…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    ZYNQ学习之Ubuntu环境下的Shell与APT下载工具
                            

                        

                        

                            

                                ZYNQ学习之Ubuntu环境下的Shell与APT下载工具
                            

                            

                                基本都是摘抄正点原子的文章&#xff1a;<领航者 ZYNQ 之嵌入式Linux 开发指南 V3.2.pdf&#xff0c;因初次学习&#xff0c;仅作学习摘录之用&#xff0c;有不懂之处后续会继续更新~ 
一、Ubuntu Shell操作 
简单的说Shell 就是敲命令。国内把 Linux 下通过命令行输入命令叫…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    代码随想录算法训练营第三十二天 | 122.买卖股票的最佳时机II ，55. 跳跃游戏 ， 45.跳跃游戏II
                            

                        

                        

                            

                                代码随想录算法训练营第三十二天 | 122.买卖股票的最佳时机II ，55. 跳跃游戏 ， 45.跳跃游戏II
                            

                            

                                贪心&#xff1a;只要把每一个上升区间都吃到手&#xff0c;就能一直赚 
class Solution {
public:int maxProfit(vector<int>& prices) {int res  0;for(int i  1;i< prices.size();i){int diff  prices[i] - prices[i-1];if(prices[i] > prices[i-1]){res  d…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    WSL使用
                            

                        

                        

                            

                                WSL使用
                            

                            

                                WSL使用 
WSL安装和使用 
Termianl和Ubuntu的安装 
打开Hype-V虚拟化配置Microsoft Store中搜索Window Terminal并安装Microsoft Store中搜索Ubuntu, 选择安装Ubuntu 22.04.3 LTS版本打开Window Terminal选择Ubuntu标签栏, 进入命令行 
中文输入法安装 
查看是否安装了fcitx框架…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    【官方】操作指南，附代码！银河麒麟服务器迁移运维管理平台V2.1中间件及高可用服务部署（4）
                            

                        

                        

                            

                                【官方】操作指南，附代码！银河麒麟服务器迁移运维管理平台V2.1中间件及高可用服务部署（4）
                            

                            

                                1.RocketMQ集群模式 
主机配置示例&#xff1a; IP  角色  架构模式  对应配置文件  1.1.1.1  nameserver1  master  broker-n0.conf  2.2.2.2  nameserver2  salve1  broker-n1.conf  3.3.3.3  nameserver3  salve2  broker-n2.conf  
1.1.安装rocketmq 
在服务器上安装rocket…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    第14篇：2线-4线译码器
                            

                        

                        

                            

                                第14篇：2线-4线译码器
                            

                            

                                Q&#xff1a;有编码器那对应的就会有译码器&#xff0c;本期我们来设计实现2线-4线二进制译码器 。 
A&#xff1a;基本原理&#xff1a;译码器是编码器的逆过程&#xff0c;其功能是将具有特定含义的二进制码转换为对应的输出信号。2线-4线二进制译码器有2个输入共4种不同的组…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    java目标和（力扣Leetcode106）
                            

                        

                        

                            

                                java目标和（力扣Leetcode106）
                            

                            

                                目标和 
力扣原题 
问题描述 
给定一个正整数数组 nums 和一个整数 target&#xff0c;向数组中的每个整数前添加 ‘’ 或 ‘-’&#xff0c;然后串联起所有整数&#xff0c;可以构造一个表达式。返回可以通过上述方法构造的、运算结果等于 target 的不同表达式的数目。 
示例 …
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    【MySQL】11. 复合查询(重点)
                            

                        

                        

                            

                                【MySQL】11. 复合查询(重点)
                            

                            

                                4. 子查询 
子查询是指嵌入在其他sql语句中的select语句&#xff0c;也叫嵌套查询 
4.1 单行子查询 
返回一行记录的子查询 显示SMITH同一部门的员工 
mysql> select * from emp where deptno  (select deptno from emp where ename  SMITH);
-----------------------------…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    小目标检测篇 | YOLOv8改进之添加BiFormer注意力机制
                            

                        

                        

                            

                                小目标检测篇 | YOLOv8改进之添加BiFormer注意力机制
                            

                            

                                前言：Hello大家好，我是小哥谈。BiFormer是一种具有双层路由的动态稀疏注意力机制，它通过查询自适应的方式关注一小部分相关标记，从而提供了更灵活的计算分配和内容感知。它在多个计算机视觉任务中表现出了良好的性能和高计算效率。BiFormer注意力机制比较适合处理小尺度目标…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    聚类算法之高斯混合模型聚类 (Gaussian Mixture Model, GMM)
                            

                        

                        

                            

                                聚类算法之高斯混合模型聚类 (Gaussian Mixture Model, GMM)
                            

                            

                                注意&#xff1a;本文引用自专业人工智能社区Venus AI 
更多AI知识请参考原站 &#xff08;[www.aideeplearning.cn]&#xff09; 
高斯混合模型&#xff08;GMM&#xff09;是统计模型中的一颗璀璨之星&#xff0c;它为数据提供了一种复杂而又强大的表示方法。在机器学习的许多…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    大数据基础：Linux基础详解
                            

                        

                        

                            

                                大数据基础：Linux基础详解
                            

                            

                                课程介绍 
本课程主要通过对linux基础课程的详细讲解&#xff0c;让大家熟练虚拟机的安装使用&#xff0c;Linux系统的安装配置&#xff0c;学习掌握linux系统常用命令的使用&#xff0c;常用的软件安装方法&#xff0c;制作快照&#xff0c;克隆&#xff0c;完成免密登录&…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    linux系统--------------mysql数据库管理
                            

                        

                        

                            

                                linux系统--------------mysql数据库管理
                            

                            

                                目录 
一、SQL语句 
1.1SQL语言分类 
1.2查看数据库信息    
1.3登录到你想登录的库 
1.4查看数据库中的表信息 
1.5显示数据表的结构&#xff08;字段&#xff09; 
1.5.1数据表的结构 
1.5.2常用的数据类型: 
二、关系型数据库的四种语言 
2.1DDL&#xff1a;数据定义语言&am…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
                

                    

                        

                            

                                
                                    跨域与Spring Boot中CORS的应用
                            

                        

                        

                            

                                跨域与Spring Boot中CORS的应用
                            

                            

                                摘要&#xff1a;前后端独立开发期间&#xff0c;交互主要通过接口文档&#xff0c;前端Mock数据&#xff0c;后端使用Postman都不会发现跨域问题。当联调时前端尝试调用后端接口&#xff0c;这往往就需要需要处理的跨域问题…… 下面总结下跨域问题产生的前因后果以及如何通过…
                            

                            

                                阅读更多...
                            

                        

                    

                

                
            

            

                

                    

                        

                            最新文章

                        
                    

                

            

        

    

    

        

            

                Copyright @ 2022~2023