AcWing算法学习笔记：动态规划（背包 + 线性dp + 区间dp + 计数dp + 状态压缩dp + 树形dp + 记忆化搜索）

动态规划

  • 一、背包问题
    • ① 01背包朴素版
    • ② 01背包优化版
    • ③ 完全背包朴素版
    • ④ 完全背包消k版
    • ⑤ 完全背包消k优化版
    • ⑥ 多重背包朴素版
    • ⑦多重背包二进制优化版
    • ⑧ 分组背包朴素版
    • ⑨ 分组背包优化版
  • 二、线性dp
    • ① 数字三角形
    • ② 最长上升子序列
    • ③ 最长上升子序列打印序列版
    • ④ 最长上升子序列0(nlogn)
    • ⑤ 最长公共子序列
    • ⑥ 最短编辑距离
  • 三、区间dp（石子合并）
  • 四、计数类dp（整数划分）
  • 五、数位统计dp（计数问题）还没写
  • 六、状态压缩dp
    • ①蒙德里安的梦想
    • ②最短哈密顿路径
  • 七、树形dp（没有上司的舞会）
  • 八、记忆化搜索（滑雪）

一、背包问题

① 01背包朴素版

算法
在这里插入图片描述

复杂度
时间复杂度0(nm)
空间复杂度0(nv)

代码

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int f[N][N];

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i ++) cin >> v[i] >> w[i];
    
    for (int i = 1; i <= n; i ++) //i == 0时，一件物品都不选，f都为0
    {
        for (int j = 0; j <= m; j ++)
        {
            f[i][j] = f[i - 1][j]; //不包含第i个物品
            if (j >= v[i]) f[i][j] = max(f[i][j], f[i - 1][j - v[i]] + w[i]); //包含第i个物品
        }
    }
    cout << f[n][m]; //前n个物品中选择体积不超过m的最大价值
    return 0;
}

② 01背包优化版

算法
通过滚动数组对01背包朴素版进行空间上的优化
f[i] 与 f[i - 1]轮流交替
若体积从小到大进行遍历，当更新f[i, j]时，f[i - 1, j - vi] 已经在更新f[i, j - vi]时被更新了
因此体积需要从大到小进行遍历，当更新f[i, j]时，f[i - 1, j - vi] 还未被更新

复杂度
时间复杂度0(nm)
空间复杂度0(m)
代码

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int f[N];

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i ++) cin >> v[i] >> w[i];
    
    for (int i = 1; i <= n; i ++) //i == 0时，一件物品都不选，f都为0
    {
        for (int j = m; j >= v[i]; j --)
        {
             f[j] = max(f[j], f[j - v[i]] + w[i]); //包含第i个物品
        }
    }
    cout << f[m]; //前n个物品中选择体积不超过m的最大价值
    return 0;
}

③ 完全背包朴素版

算法
在这里插入图片描述

复杂度
时间复杂度：0(nm^2)
代码

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int f[N][N];

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i ++) cin >> v[i] >> w[i];
    
    for (int i = 1; i <= n; i ++)
    {
        for (int j = 0; j <= m; j ++)
        {
            for (int k = 0; k * v[i] <= j; k ++)
            {
                f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + k * w[i]);
            }
        }
    }
    cout << f[n][m];
    return 0;
}

④ 完全背包消k版

算法
f[i,j] = max(f[i-1, j], f[i-1, j-v]+w, f[i-1, j-2v]+2w…f[i-1, j-kv]+kw)
f[i, j-v] = max(   f[i-1, j-v ],  f[i-1, j-2v]+w … f[i-1, j-kv]+(k-1)w)
将f[i,j]优化成f[i,j] = max(f[i-1, j], f[i, j-v])
复杂度
由于不需要枚举选取物品i的数量
因此减少一轮迭代
0(nm)
代码

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int f[N][N];

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i ++) cin >> v[i] >> w[i];
    
    for (int i = 1; i <= n; i ++)
    {
        for (int j = 0; j <= m; j ++)
        {
            f[i][j] = f[i - 1][j]; //不选第i件物品
            if(j >= v[i]) f[i][j] = max(f[i][j], f[i][j - v[i]] + w[i]); //选第i件物品
        }
    }
    cout << f[n][m];
    return 0;
}

⑤ 完全背包消k优化版

算法
类比与01背包的滚动数组优化
将f[i]与f[i - 1]轮流交替使用数组进行存储
由于不存在01背包中的更新覆盖的情况
因此体积从小到大枚举即可
复杂度
空间复杂度0(NM) -> 0(M)
代码

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int f[N];

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i ++) cin >> v[i] >> w[i];
    
    for (int i = 1; i <= n; i ++)
    {
        for (int j = v[i]; j <= m; j ++)
        {
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }
    cout << f[m];
    return 0;
}

⑥ 多重背包朴素版

算法在这里插入图片描述

复杂度
时间复杂度：0(nm^2)
代码

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

int n, m;
int v[N], w[N], s[N];
int f[N][N];

int main()
{
    cin >> n >> m;

    for (int i = 1; i <= n; i ++) cin >> v[i] >> w[i] >> s[i];
    
    for (int i = 1; i <= n; i ++)
    {
        for (int j = 0; j <= m; j ++)
        {
            for (int k = 0; k <= s[i] && k * v[i] <= j; k ++)
            {
                f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + k * w[i]); //相当于就是有个数限制的完全背包问题
            }
        }
    }
    cout << f[n][m];
    return 0;
}

⑦多重背包二进制优化版

算法
每个物品可选[0, s]个，朴素版需要从0到s进行枚举
使用二进制进行优化
在这里插入图片描述
将si种选法分解成logs种选法，将所有选法重新存储起来
采用01背包的做法即可得到最优解
复杂度
时间复杂度0(nm)
代码

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 22000, M = 2020;

int n, m;
int v[N], w[N];
int f[M];

int main()
{
    cin >> n >> m;
    int cnt = 0;
    for (int i = 1; i <= n; i ++) //划分为二进制组
    {
        int a, b, c;
        cin >> a >> b >> c;
        
        int k = 1;
        while (k <= c)
        {
            cnt ++;
            v[cnt] = k * a;
            w[cnt] = k * b;
            c -= k;
            k *= 2;
        }
        if (c > 0)
        {
            cnt ++;
            v[cnt] = c * a;
            w[cnt] = c * b;
        }
    }
    n = cnt;
    
    for (int i = 1; i <= n; i ++) //01背包
    {
        for (int j = m; j >= v[i]; j --)
        {
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }
    cout << f[m];
    return 0;
}

⑧ 分组背包朴素版

算法
在这里插入图片描述
枚举每一个分组内的物品，进行01背包的选法策略

复杂度
时间复杂度0(nms)
代码

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

int n, m;
int v[N][N], w[N][N], s[N];
int f[N][N];

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i ++)
    {
        cin >> s[i];
        for (int j = 1; j <= s[i]; j ++) cin >> v[i][j] >> w[i][j];
    }
    
    for (int i = 1; i <= n; i ++)
    {
        for (int j = 0; j <= m; j ++)
        {
            for (int k = 0; k <= s[i]; k ++) //k从0开始，包含不选该分组的f(i - 1, j)
            {
                if (j >= v[i][k]) f[i][j] = max(f[i][j], f[i - 1][ j - v[i][k]] + w[i][k]); //01背包
            }
        }
    }
    cout << f[n][m];
    return 0;
}

⑨ 分组背包优化版

算法
采用01背包的滚动数组优化法

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

int n, m;
int v[N][N], w[N][N], s[N];
int f[N];

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i ++)
    {
        cin >> s[i];
        for (int j = 1; j <= s[i]; j ++) cin >> v[i][j] >> w[i][j];
    }
    
    for (int i = 1; i <= n; i ++)
    {
        for (int j = m; j >= 0; j --)
        {
            for (int k = 0; k <= s[i]; k ++) //k从0开始，包含不选该分组的f(i - 1, j)
            {
                if (j >= v[i][k]) f[j] = max(f[j], f[j - v[i][k]] + w[i][k]); //01背包
            }
        }
    }
    cout << f[m];
    return 0;
}

二、线性dp

① 数字三角形

算法
在这里插入图片描述
代码

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 510, INF = 1e9;

int n;
int f[N][N];
int a[N][N];


int main()
{
    cin >> n;
    
    for (int i = 0; i <= n; i ++)
    {
        for (int j = 0; j <= n; j ++)
        {
            f[i][j] = -INF; //将状态全部初始化为最小值
        }
    }
    
    for (int i = 1; i <= n; i ++)
    {
        for (int j = 1; j <= i; j ++)
        {
            cin >> a[i][j]; //输入三角形
        }
    }
    
    f[1][1] = a[1][1];
    for (int i = 2; i <= n; i ++)
    {
        for (int j = 1; j <= i; j ++)
        {
            f[i][j] = max(f[i - 1][j], f[i - 1][j - 1]) + a[i][j];
        }
    }
    
    int res = -INF;
    for (int i = 1; i <= n; i ++) res = max(res, f[n][i]);
    cout << res;
    return 0;
}

② 最长上升子序列

算法
在这里插入图片描述
代码

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n;
int a[N];
int f[N];

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i ++) cin >> a[i];
    
    for (int i = 1; i <= n; i ++)
    {
        f[i] = 1;
        for (int j = 1; j < i; j ++)
        {
            if (a[j] < a[i]) f[i] = max(f[i], f[j] + 1);
        }
    }
    int res = 0;
    for (int i = 1; i <= n; i ++) res = max(res, f[i]);
    cout << res;
    return 0;
}

③ 最长上升子序列打印序列版

算法
更新状态时，记录每一位子串是由哪一位结尾的子串转移而来的
再根据最大字串的末尾下标，倒序输出字串下标

#include <iostream>
#include <algorithm>
#include <stack>

using namespace std;

const int N = 1010;

int n;
int a[N];
int f[N];
int g[N];//保存以该位结尾的序列是由哪一位结尾的序列转移而来的

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i ++) cin >> a[i];
    
    for (int i = 1; i <= n; i ++)
    {
        f[i] = 1;
        for (int j = 1; j < i; j ++)
        {
            if (a[j] < a[i])
            {
                if (f[j] + 1 > f[i]) //更新f[i]是由f[j]转移过来的，并记录
                {
                    f[i] = f[j] + 1;
                    g[i] = j;
                }
            }
        }
    }
    int k = 1;
    for (int i = 2; i <= n; i ++)
    {
        if (f[i] > f[k])
        {
            k = i;
        }
    }
    cout << f[k] << endl;
    
    stack <int> s;
    for (int i = f[k]; i >= 1; i --)
    {
        s.push(k); //放入堆栈，可逆序输出
        k = g[k];
    }
    while (!s.empty())
    {
        cout << a[s.top()] << " ";
        s.pop();
    }
    return 0;
}

④ 最长上升子序列0(nlogn)

算法
最长上升子序列的最后一位数，一定会随着长度的增长而严格单调增大
因此保存每一个长度的子序列的最小末位数
并枚举每一个数字，若以该数字结尾的序列，其倒数第二个数字应该是小于该数字的最大的数
因此在数组中二分倒数第二个数的位置
并更新数组
代码

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

int a[N];
int q[N];
int n;

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i ++) cin >> a[i];
    
    int len = 0;
    q[0] = -2e9;
    for (int i = 1; i <= n; i ++)
    {
        int l = 0, r = len;
        while (l < r)
        {
            int mid = l + r + 1 >> 1;
            if (q[mid] < a[i]) l = mid;
            else r = mid - 1;
        }
        len = max(len, r + 1);
        q[r + 1] = a[i];
    }
    cout << len;
    return 0;
}

⑤ 最长公共子序列

算法
在这里插入图片描述

代码

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 1010;
int n, m;
char a[N], b[N];
int f[N][N];

int main()
{
    cin >> n >> m;
    scanf("%s%s", a + 1, b + 1); //写入a[0], b[0],数组名本身就是地址，不需要&
    for (int i = 1; i <= n; i ++)
    {
        for (int j = 1; j <= m; j ++)
        {
            f[i][j] = max(f[i - 1][j], f[i][j - 1]);
            if (a[i] == b[j]) f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1); //最长子序列包含a[i]/b[j]
        }
    }
    cout << f[n][m];
    return 0;
}

⑥ 最短编辑距离

算法
在这里插入图片描述

代码

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n, m;
char a[N], b[N];
int f[N][N];

int main()
{
    scanf("%d%s", &n, a + 1);
    scanf("%d%s", &m, b + 1);
    
    for (int i = 0; i <= n; i ++) f[i][0] = i;
    for (int i = 0; i <= m; i ++) f[0][i] = i;
    
    for (int i = 1; i <= n; i ++)
    {
        for (int j = 1; j <= m; j ++)
        {
            f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1);
            f[i][j] = min(f[i][j], f[i- 1][j - 1] + (a[i] != b[j]));
        }
    }
    
    cout << f[n][m];
    return 0;
}

三、区间dp（石子合并）

算法
在这里插入图片描述
代码

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 310, INF = 1e8;

int f[N][N];
int s[N];
int a[N];
int n;

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i ++)
    {
        cin >> a[i];
        s[i] = a[i] + s[i - 1];
    }
    
    for (int len = 2; len <= n; len ++) //当len为1时，不需要合并
    {
        for (int i = 1; i + len - 1 <= n; i ++) //遍历左边界，左边界 + 长度不能越界
        {
            int j = i + len - 1;
            f[i][j] = INF;
            for (int k = i; k < j; k ++) //遍历分界点，k属于[i,j - 1]
            {
                f[i][j] = min(f[i][j], f[i][k] + f[k + 1][j] + s[j] - s[i - 1]);
            }
        }
    }
    cout << f[1][n];
    return 0;
}

四、计数类dp（整数划分）

  • 完全背包解法
    在这里插入图片描述
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010, mod = 1e9 + 7;

int n;
long long res;
long long f[N][N];

int main()
{
    cin >> n;
    
    for (int i = 0; i<= n; i ++) f[i][0] = 1;
    
    for (int i = 1; i <= n; i ++)
    {
        for (int j = 1; j <= n; j ++)
        {
            for (int k = 0; j >= k * i; k ++)
            {
                f[i][j] += f[i - 1][j - k * i] % mod;
            }
        }
    }
    cout << f[n][n];
    return 0;
}
  • 计数dp解法
    在这里插入图片描述
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;
const long long mod = 1e9 + 7;

int n;
long long f[N][N];

int main()
{
    cin >> n;
    
    f[0][0] = 1; //使得总和恰好为0,选择0个数的方案只有一种
    
    for (int i = 1; i <= n; i ++)
    {
        for (int j = 1; j <= i; j ++)
        {
            f[i][j] = (f[i - 1][j - 1] + f[i - j][j]) % mod;
        }
    }
    
    long long res = 0;
    for (int i = 1; i <= n; i ++) res = (f[n][i] + res) % mod;
    cout << res;
    return 0;
}

五、数位统计dp（计数问题）还没写

六、状态压缩dp

①蒙德里安的梦想

算法
在这里插入图片描述

代码

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 12, M = 1 << N;
int n, m;
long long f[N][M];
bool st[M];

int main()
{
    while (cin >> n >> m, n || m)
    {
        //初始化状态数组
        memset(f, 0, sizeof(f)); 
        
        //初始化判断是否有连续个奇数0的数组
        for (int i = 0; i < 1 << n; i ++)
        {
            int cnt = 0;
            st[i] = true;
            for (int j = 0; j < n; j ++)
            {
                if ((i >> j) & 1)
                {
                    if (cnt & 1) st[i] = false;
                    cnt = 0;
                }
                else cnt ++;
            }
            if (cnt & 1) st[i] = false;
        }
        
        f[0][0] = 1;
        for (int i = 1; i <= m; i ++)
        {
            for (int j = 0; j < 1 << n; j ++)
            {
                for (int k = 0; k < 1 << n; k ++)
                {
                    if (((j & k) == 0) && st[j | k]) f[i][j] += f[i - 1][k];
                }
            }
        }
        cout << f[m][0] << endl;
    }
    
    return 0;
}

②最短哈密顿路径

算法
在这里插入图片描述

代码

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 20, M = 1 << N;
int f[M][N];
int w[N][N];
int n;

int main()
{
    cin >> n;
    for (int i = 0; i < n; i ++)
    {
        for (int j = 0; j < n; j ++)
        {
            cin >> w[i][j];
        }
    }
    
    memset(f, 0x3f, sizeof(f));
    f[1][0] = 0;
    
    for (int i = 0; i < 1 << n; i ++)
    {
        for (int j = 0; j < n; j ++)
        {
            if ((i >> j) & 1)
            {
                for (int k = 0; k < n; k ++)
                {
                    if (((i - (1 << j)) >> k) & 1)
                    {
                        f[i][j] = min(f[i][j], f[i - (1 << j)][k] + w[k][j]);
                    }
                }
            }
        }
    }
    cout << f[(1 << n) - 1][n - 1];
    return 0;
}

七、树形dp（没有上司的舞会）

算法
在这里插入图片描述

代码

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 6010;
int f[N][2];
int happy[N];
bool has_father[N];
int h[N], e[N], ne[N], idx;
int n;

void add(int a, int b) //将子节点a加入到父节点b后
{
    e[idx] = a;
    ne[idx] = h[b];
    h[b] = idx ++;
}

void dfs(int u)
{
    f[u][1] = happy[u];
    
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        dfs(j);
        
        f[u][1] += f[j][0]; //包含u，则必不包含u的子节点
        f[u][0] += max(f[j][0], f[j][1]); //不包含u，可以考虑包含u的子节点
    }
}

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i ++) cin >> happy[i];
    
    memset(h, -1, sizeof(h));
    
    for (int i = 1; i < n; i ++)
    {
        int a, b;
        cin >> a >> b;
        has_father[a] = true;
        add(a, b);
    }
    
    int root = 1;
    while (has_father[root]) root ++;
    
    dfs(root);
    
    cout << max(f[root][0], f[root][1]);
    return 0;
}

八、记忆化搜索（滑雪）

算法
在这里插入图片描述

代码

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 310;
int d[N][N];
int f[N][N];
int n, m;

int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};

int dp(int x, int y)
{
    if (f[x][y] != -1) return f[x][y];
    
    f[x][y] = 1;
    for (int i = 0; i < 4; i ++)
    {
        int a = x + dx[i], b = y + dy[i];
        if (a >= 0 && a < n && b >= 0 && b < m && d[a][b] < d[x][y])
            f[x][y] = max(f[x][y], dp(a, b) + 1);
    }
    return f[x][y];
}

int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i ++)
    {
        for (int j = 0; j < m; j ++)
        {
            cin >> d[i][j];
        }
    }
    
    int res = 0;
    
    memset(f, -1, sizeof(f));
    for (int i = 0; i < n; i ++)
    {
        for (int j = 0; j < m; j ++)
        {
            res = max(res, dp(i, j));
        }
    }
    cout << res;
    return 0;
}

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

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

相关文章

Pytest自动化测试详解

Pytest自动化测试详解

&#x1f345; 视频学习&#xff1a;文末有免费的配套视频可观看 &#x1f345; 关注公众号&#xff1a;互联网杂货铺&#xff0c;回复1 &#xff0c;免费获取软件测试全套资料&#xff0c;资料在手&#xff0c;涨薪更快 为什么需要自动化测试&#xff1f; 自动化测试有很多优…
阅读更多...
CSS 闪电按钮效果

CSS 闪电按钮效果

<template><view class="const"><div class="voltage-button"><button>闪电按钮</button><svg version="1.1" xmlns="http://www.w3.org/2000/svg" x="0px" y="0px" viewBox=&q…
阅读更多...
02.04

02.04

1.信号 include "myhead.h" //定义信号处理函数 void handler(int signo) {if(signo SIGINT){printf("用户按下了ctrl c键&#xff0c;hello world\n");} }int main(int argc, const char *argv[]) {if(signal(SIGINT, handler) SIG_ERR){perror("…
阅读更多...
vue前端+nodejs后端通信-简单demo

vue前端+nodejs后端通信-简单demo

本文记录vue前端nodejs后端通讯最简单的方法&#xff0c;供广大网友最快速进入全栈开发。 技术架构 前端 vue axios 后端 nodejs express 一、前端部分-搭建VUE 项目 vue create Vnodenpm run serve 启动&#xff1b; 具体操作步骤&#xff0c;请自行百度&#xff0c;这里没…
阅读更多...
【JavaEE spring】SpringBoot 统一功能处理

【JavaEE spring】SpringBoot 统一功能处理

SpringBoot 统一功能处理 1. 拦截器1.1 拦截器快速⼊⻔1.2 拦截器详解1.2.1 拦截路径1.2.2 拦截器执⾏流程 1.3 登录校验1.3.1 定义拦截器1.3.2 注册配置拦截器 2. 统⼀数据返回格式2.1 快速⼊⻔2.2 存在问题2.3 案例代码修改2.4 优点 3. 统⼀异常处理 1. 拦截器 后端程序根据…
阅读更多...
快递员的烦恼 - 华为OD统一考试

快递员的烦恼 - 华为OD统一考试

OD统一考试&#xff08;C卷&#xff09; 分值&#xff1a; 200分 题解&#xff1a; Java / Python / C 题目描述 快递公司每日早晨&#xff0c;给每位快递员推送需要淡到客户手中的快递以及路线信息&#xff0c;快递员自己又查找了一些客户与客户之间的路线距离信息&#xff0…
阅读更多...
怎么把物品信息图片批量生成二维码？每张图片单独生码的制作技巧

怎么把物品信息图片批量生成二维码？每张图片单独生码的制作技巧

现在通过扫码来查看人员或者物品信息的方式越来越常见&#xff0c;在合适的位置放置对应的二维码内容&#xff0c;让其他人通过扫码来获取图片信息。那么如果我们将每个信息做成一张图片后&#xff0c;需要将图片生成二维码时&#xff0c;有能够批量生成二维码的方法可以快速处…
阅读更多...
【Mysql】整理

【Mysql】整理

Mysql整理与总结 整理Mysql的基本内容供回顾。 参考&#xff1a; [1]. 掘金.MySQL三大日志(binlog,redolog,undolog)详解 [2]. Javaguide.MySQL三大日志(binlog、redo log和undo log)详解
阅读更多...
2023-12蓝桥杯STEMA考试 C++ 中高级试卷解析

2023-12蓝桥杯STEMA考试 C++ 中高级试卷解析

蓝桥杯STEMA考试 C++ 中高级试卷（12月） 一、选择题 第一题 定义字符串 string a = "Hello C++"，下列选项可以获取到字符 C 的是（B）。 A、a[7] B、a[6] C、a[5] D、a[4] 第二题 下列选项中数值与其它项不同的是（ C）。 A、 B、 C、 D、 第三题 定义变量 int i =…
阅读更多...
幻兽帕鲁服务器自动重启备份-python

幻兽帕鲁服务器自动重启备份-python

幻兽帕鲁服务器自动重启备份-python 1. 前置知识点2. 目录结构3. 代码内容4. 原理解释5. 额外备注 基于python编写的服务器全自动管理工具&#xff0c;能够实现自动定时备份存档&#xff0c;以及在检测到服务器崩溃之后自动重新启动&#xff0c;并且整合了对于frp端口转发工具的…
阅读更多...
【高质量精品】2024美赛A题22页word版成品论文+数据+多版本前三问代码及代码讲解+前四问思路模型等（后续会更新）

【高质量精品】2024美赛A题22页word版成品论文+数据+多版本前三问代码及代码讲解+前四问思路模型等（后续会更新）

一定要点击文末的卡片&#xff0c;进入后&#xff0c;即可获取完整资料后续参考论文!! 整体分析:这个题目是一个典型的生态系统建模问题&#xff0c;涉及到动物种群的性比例变化、资源可用性、环境因素、生态系统相互作用等多个方面。这个题目的难点在于如何建立一个合理的数学…
阅读更多...
关于Clone

关于Clone

关于Clone 一般情况下&#xff0c;如果使用clone()方法&#xff0c;则需满足以下条件。 1、对任何对象o&#xff0c;都有o.clone() ! o。换言之&#xff0c;克隆对象与原型对象不是同一个对象。 2、对任何对象o&#xff0c;都有o.clone().getClass() o.getClass()。换言之&a…
阅读更多...
实景三维技术未来的着力点应该在哪里？

实景三维技术未来的着力点应该在哪里？

随着社会经济和文化生活的不断发展&#xff0c;公共服务和公共安全就成为政府部门和各行业各部门的一个非常重要的工作&#xff0c;提高政府以及相关部门对紧急事件的快速反应和抗风险能力&#xff0c;建设应急指挥系统为公众提供更便捷的紧急救助服务&#xff0c;已经成为社会…
阅读更多...
【GoLang入门教程】Go语言几种标准库介绍(五)

【GoLang入门教程】Go语言几种标准库介绍(五)

如何解决大模型的「幻觉」问题&#xff1f; 文章目录 如何解决大模型的「幻觉」问题&#xff1f;前言几种库image库 (常见图形格式的访问及生成)关键概念和类型&#xff1a;示例 IO库示例 math库(数学库)常用的函数和常量&#xff1a;示例 总结专栏集锦写在最后 前言 上一篇&a…
阅读更多...
计算机毕业设计 | springboot 高校新生报到系统(附源码)

计算机毕业设计 | springboot 高校新生报到系统(附源码)

1&#xff0c;绪论 1.1 开发背景 学校新生报到仅仅靠原始的手工管理&#xff0c;面对大量的新生信息&#xff0c;无法有效率地将其中的重要部分提取出来&#xff0c;并做出相应的判断和处理。学校的决策只能依据报表数据&#xff0c;在浪费大量人力、物力的同时无法做到实时监…
阅读更多...
图像模板匹配算法(MATLAB)

图像模板匹配算法(MATLAB)

模板匹配是一种用于在图像中定位和识别对象的技术。它的基本思想是: 提取图像中的一个子图像作为“模板”(template)。这个子图像通常包含我们感兴趣的目标对象。 在整个原始图像上,逐点比较模板和原始图像的相似度。相似度通常用归一化的交叉相关(Normalized Cross Correlati…
阅读更多...
Unity | 资源热更（YooAsset AB）

Unity | 资源热更（YooAsset AB）

目录 一、AssetBundle 1. 插件AssetBundle Browser 打AB包 &#xff08;1&#xff09;Unity&#xff08;我用的版本是2020.3.8&#xff09;导入AssetBundle Browser &#xff08;2&#xff09;设置Prefab &#xff08;3&#xff09;AssetBundleBrowser面板 2. 代码打AB包…
阅读更多...
Unity类银河恶魔城学习记录1-9 PlayerWallSilde源代码 P36

Unity类银河恶魔城学习记录1-9 PlayerWallSilde源代码 P36

Alex教程每一P的教程原代码加上我自己的理解初步理解写的注释&#xff0c;可供学习Alex教程的人参考 【Unity教程】从0编程制作类银河恶魔城游戏_哔哩哔哩_bilibili Player.cs using System.Collections; using System.Collections.Generic; using Unity.VisualScripting; us…
阅读更多...
【30秒看懂大数据】数据指标

【30秒看懂大数据】数据指标

公众号&#xff1a;知幽科技 PS:本文属专栏第24篇 简单说 数据指标是指对企业经营数据转化为可量化、可衡量、可对比、可预测的一个度量或者维度同称。 举例理解 你在小区门口开了一家馒头店。 开业第一天你算了下一共卖了50个馒头&#xff0c;一共收款100元&#xff0…
阅读更多...
通过手写简易版RPC理解RPC原理

通过手写简易版RPC理解RPC原理

RPC是什么 所谓的RPC其实是为了不同主机的两个进程间通信而产生的&#xff0c;通常不同的主机之间的进程通信&#xff0c;程序编写需要考虑到网络通信的功能&#xff0c;这样程序的编写将会变得复杂。RPC就来解决这一问题的&#xff0c;一台主机上的进程对另外一台主机的进程发…
阅读更多...
最新文章

Copyright @ 2022~2023