动态规划：背包问题合集

01背包

定义dp[i][j]：在前i件物品中选出若干件，放入容量为j的背包，能获得的最大价值。

考虑第i件物品拿还是不拿。讨论c[i]与背包容量的关系：

（1）j < c[i] 时，背包容量为j，而第i件物品重量大于j只能选择不拿：f[i][j] = f[i-1][j]

  ( 2) j >= c[i] 时，背包可以拿可以不拿第i个物品。如果选择第i件物品，那么选择第i件物品后剩余的背包容量  即从前i-1个物品选出若干个物品，放入容量为j-w[i]的背包，即f[ i-1 ][ j - w[i] ]是从前i-1个物品选出若干个物品，放入容量为j-w[i]的背包，能获得的最大价值）

拿：f[i][j]=f[i-1][j - w[i]]+c[i]

不拿：f[i][j] =f[i-1][j]

取两者最大值：f[i][j] =  max( f[i-1][j-w[i]] + c[i] , f[i-1][j] )

01背包问题：
dp[n+1][m+1]
memset(dp,0,sizeof(dp));//初始化，将dp全部赋0(不用恰好装满)
for(int i=1;i<=n;i++) 
   for(int j=1;j<=m;j++)
      if(j<w[i])
	     dp[i][j]=dp[i-1][j];
	  else
	     dp[i][j]= max(dp[i-1][j-w[i]]+c[i],dp[i-1][j]);
cout<<dp[n][m];

只存一行数据来进行空间优化。当前结果来自上一行的j已经前面的区域（红色区域），所以必须让j以递减的形式更新，以保证能够取到上一行前面的值

 因为j递减更新，用到前面的值是没优化前上一行的旧值，我们恰恰需要上一行的旧值。

 

 

 优化后的代码:

for(int i=1;i<=N;i++)
	for(int j=V;j>=c[i];j--)
		dp[j]=max(dp[j-c[i]]+w[i],dp[j]);
cout<<dp[V];

 优化后的dp循环时不用分类讨论是因为：j逆序遍历，同时结束条件为j>=w[i],这两点保证了j-w[i]一定会大于0，所以不用分类讨论。但是没优化前，j正序遍历，j-w[i] 可能小于0，这将会导致没有意义以及数组越界，所以要分类讨论。

01背包方案数

容量V,N件物品，体积为C[i],价值为w[i], 求将背包（恰好）装满的方案数

定义dp[i][j]：前i件物品中选若干件放入剩余空间为j的背包中刚好把背包装满的方案总数。

考虑第i件物品能不能选

dp[i][j] = dp[i-1][j] ，0<=j<=C[i]

dp[i][j] = dp[i-1][j] + dp[i-1][j-C[i]]，j>=C[i]

初始化：F[0][0]=1，即没有物品放入容量为0的背包刚好放满的方案数为1

F[0][0] = 1 
    for i =1 to N 
          do for j =0 to V 
                if (j < C[i]) 
                     then F[i][j] = F[i-1][j] 
                else 
                     F[i][j] =F[i-1][j]+F[i-1][j-C[i]] 
return F[N][V]

滚动数组空间优化

F[0] =1 
   for i=1 to N 
        do for j= V to c[i] 
             do  f[j] += f[j-c[i]];
return F[V] 

多重背包问题

可以把ni个物品逐个拆分，得到\sumni个物品。原问题转化为01背包问题

dp[i][v] = max(dp[i-1][v-k*ci]+k*wi) ，0<=k<=ni.?

for(int i=1;i<=N;i++)
   for(int j=0;j<=V;j++)
        for(int k=0;k<=n[i];k++)
            if(j>=c[i]*k)
               dp[i][j]=max(dp[i-1][j-c[i]*k]+w[i]*k,dp[i][j]);

空间优化：(滚动数组  二维降一维)?

for(int i=1;i<=N;i++)
   for(int j=V;j>=0;j--)
        for(int k=0;k<=n[i];k++)
            if(j>=c[i]*k) dp[j]=max(dp[j-c[i]*k]+w[i]*k,dp[j]);

恰好装满初始化问题

求最优解的背包问题中，有的题目要求【恰好装满背包】，有的题目并【没有要求】必须把背包装满，这两种方法初始化有所不同。设：F[i]表示容量为i的背包能够装的最大价值。

恰好装满背包：初始化：F[0] = 0 ,  F[i] = -INF, 1 <= i <= V。

不用恰好装满背包：初始化：F[i] = 0 ,   0 <= i <= V。

初始化的F数组事实上就是在没有任何物品可以放入背包时的合法状态。

如果要求背包恰好装满：

(1) 容量为0 的背包不放入任何物品，恰好装满 ，价值为0，所以初始化为0。

(2) 容量不为0的背包不放入任何物品，不能恰好装满，所以初始化为-INF,如果求最小值，初始化为INF。循环后判断F[V]是否等于INF判断能否选出若干个物品使背包恰好装满。

如果不要求背包恰好装满：F数组全部初始化为0，因为不放入任何物品，所得的价值就是0。

完全背包问题

dp数组：dp[i][j]:表示从第一个到第i个物品任意取，背包可以装的重量为j，背包可以装的最大总价值

状态转移方程： dp[i][j]=max{  dp[i-1][j]  ,   dp[i-1][j-k*weight[i]]+kvalue[i] }k=1,2,3....且j-k*weight>=0。

01背包问题：dp[i][j]表示从前i个物品中选出若干个物品，放入容量为j的背包中，能获得的最大价值。

状态转移方程：dp[i][j] = max(dp[i-1][j-k*w[i]]+k*c[i]) 0<=k*w[i]<= j

int dp[n+1][m+1]；//下标从1开始
memset(dp,0,sizeof(dp));
for(int i=1;i<=n;i++)
  for(int j=1;j<=m;j++)
     int res=-1;
	 for(int k=0;k*w[i]<=j;k++)
	    res=max(res,dp[i-1][j-k*w[i]]+k*c[i]);
	 dp[i][j]=res;
	 
cout<<dp[n][m];

 空间优化：

 

 优化后的代码：

	for(int i=1;i<=N;i++)
	{
		for(int j=c[i];j<=V;j++)
		{
			dp[j]=max(dp[j-c[i]]+w[i],dp[j]);
		}
	}
	cout<<dp[V]<<endl;

二维费用的背包问题

二维费用的背包问题，需要多加一维来记录

假设限制为v1，v2。dp[i][j][k]表示在前i个物品中选v1不超过j，v2不超过k的最大价值。

dp[i][j][k] = max( dp[i-1][j][k] , dp[i-1][j-v1][k-v2]+w );

空间优化：

i正序，jk逆序：

dp[j][k]=max(dp[j][k] , dp[j-v1][k-v2]+w)

#include<iostream>
using namespace std;
int N,V,M;
int dp[101][101];
int main(){
    cin>>N>>V>>M;
    for(int i=1;i<=N;i++){
        int v,m,w;
        cin>>v>>m>>w;
        for(int j=V;j>=v;j--){
            for(int k=M;k>=m;k--){
                dp[j][k]=max(dp[j][k],dp[j-v][k-m]+w);
            }
            
        }
    }
    cout<<dp[V][M];
    return 0;
}

分组背包问题

 每个组只能选一个物品，每个组的物品是互斥的。

用二维数组存数据。循环分组，逆序循环体积，正序循环一组内的选择。

#include<bits/stdc++.h>
using namespace std;
const int N=110;
int f[N];
int v[N][N],w[N][N],s[N];
int n,m,k;
int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++){
        cin>>s[i];
        for(int j=0;j<s[i];j++){
            cin>>v[i][j]>>w[i][j];
        }
    }
    for(int i=0;i<n;i++){
        for(int j=m;j>=0;j--){
            for(int k=0;k<s[i];k++){
                if(j>=v[i][k])     f[j]=max(f[j],f[j-v[i][k]]+w[i][k]);  
            }
        }
    }
    cout<<f[m]<<endl;
}
完全背包：货币系统 

 给你一个n种面值的货币系统，求组成面值为m的货币有多少种方案。

 


多重背包：LeetCode1155 掷骰子等于目标和的方法数

这里有 n 个一样的骰子，每个骰子上都有 k 个面，分别标号为 1 到 k 。给定三个整数n、k 和 target，返回投掷骰子的所有可能得到的结果，使得骰子面朝上的数字总和等于target。由于答案可能很大，需10^9+7取模。

每个筛子可以选择1~k，选择和为target。

一共n个物品，每个物品可以选择1~k个。（不可以不选，因为每个筛子至少为1）

class Solution {
public:
    int K;
    int N;
    int t;
    int dp[35][30005];
    int numRollsToTarget(int n, int k, int target) {
         //dp[i][j]表示从前i个筛子中恰好选择和为j的方案数
         memset(dp,0,sizeof(dp));
         const int mod=1e9+7;
         dp[0][0]=1;
       //  dp[i][j]=dp[i-1][j-1]+dp[i-1][j-2]+...+dp[i-1][j-k];
         for(int i=1;i<=n;i++){
             for(int j=1;j<=target;j++){
                 for(int l=1;l<=k&&j-l>=0;l++)
                 dp[i][j]=(dp[i][j]+dp[i-1][j-l])%mod;
             }
         }
      
         return dp[n][target];
    }
};

01背包方案数：质数拆分 

将 2019 拆分为若干个两两不同的质数之和，一共有多少种不同的方法？注意交换顺序视为同一种方法，例如 2 + 2017 = 2019 与 2017+2=2019 视为同一种方法。

在2019范围内，预处理质数数组。考虑到数组每个数可以选可以不选，然后选出的和恰好为2019的方案，转换为求01背包问题方案数。

由于是恰好组成2019，所以dp在初始化的时候要注意：dp[0]=1，dp[i]=0表示在什么都没选的情况下。从选和为0的方案数为1.其他方案数为0

for(int i=0;i<k;i++) for(int j=2019;j>=a[i];j--)   dp[j]+=dp[j-a[i]];

#include <iostream>
#include<cstring>
#include<cmath>
using namespace std;
int a[2020];
bool judge(int n){
  if(n==2)return true;
  for(int i=2;i<int(sqrt(n))+1;i++){
    if(n%i==0)
    return false;
  }
  return true;
}
int k=0;
void init_a(){
  for(int i=2;i<2019;i++){
    if(judge(i))
      a[k++]=i;

long long dp[2020];
int main()
{
  init_a();
  memset(dp,0,sizeof(dp));
  dp[0]=1;  
  for(int i=0;i<k;i++){
     for(int j=2019;j>=a[i];j--)
       dp[j]+=dp[j-a[i]];
   cout<<dp[2019];
  return 0;
}
完全背包方案数：整数划分

​

可以转换为完全背包问题。从1~n选择若干个数，使它们的和恰好为n，一共有多少种方案
dp[i][j]表示从前i个数选若干个数，使它们的和恰好为j的方案数。所以dp[i][j]=dp[i-1][j]+dp[i][j-i]

空间优化：
for i 1~n: for j i~n: dp[j]=dp[j]+dp[j-i]  

int n;
cin>>n;
memset(dp,0,sizeof(dp));
dp[0]=1;
for(int i=1;i<=n;i++){
   for(int j=i;j<=n;j++)
    		dp[j]=(dp[j]+dp[j-i])%mod;
 cout<<dp[n];

  带附件的01背包：金民的采购方案

​

 假设进行到了第i个主件，则当前一共有5种选择：（1）什么也不买（2）只买主件（3）买主件和附件1（4）买主件和附件2（5）买主件，附件1，附件2

数据结构的设计：用二维数组v[i][0]，v[i][1]，v[i][2]分别表示第i件主件的价值，第i件主件第一个附件的价值，第i件主件第二个附件的价值。

用二维数组w[i][0]，w[i][1]，w[i][2]分别表示第i件主件的重要度，第i件主件第一个附件的重要度，第i件主件第二个附件的重要度。

dp[i][j]:表示前i个主件在j的情况的最大值

dp[i][j]=max( dp[i-1][j],

dp[i-1][j-v[i][0]]+v[i][0]*w[i][0],

dp[i-1][j-v[i][0]-v[i][1]]+v[i][0]*w[i][0]+v[i][1]*w[i][1],

dp[i-1][j-v[i][0]-v[i][2]]+v[i][0]*w[i][0]+v[i][2]*w[i][2],

dp[i-1][j-v[i][0]-v[i][1]-v[i][2]]+v[i][0]*w[i][0]+v[i][1]*w[i][1]+v[i][2]*w[i][2])

int dp[32001]; 
int v0[61]; int p0[61]; int v1[61];
int p1[61]; int v2[61]; int p2[61];
int n,m;
int main(){
	cin>>n>>m;
	int v,p,q;
	int cnt=1;
	for(int i=1;i<=m;i++){
		cin>>v>>p>>q;
		if(q==0) v0[i]=v;p0[i]=p;
		else if(v1[q]==-1) v1[q]=v; p1[q]=p;
		else v2[q]=v; p2[q]=p;
	for(int i=1;i<=m;i++)
		for(int j=n;j>=v0[i]&&v0[i]!=0;j--)
	if(j>=v0[i])
				dp[j]=max(dp[j],dp[j-v0[i]]+v0[i]*p0[i]);
	else if(j>=v0[i]+v1[i])
				dp[j]=max(dp[j],dp[j-v0[i]-v1[i]]+v0[i]*p0[i]+v1[i]*p1[i]);
	else if(j>=v0[i]+v2[i])
				dp[j]=max(dp[j],dp[j-v0[i]-v2[i]]+v0[i]*p0[i]+v2[i]*p2[i]);
	else if(j>=v0[i]+v1[i]+v2[i])
		dp[j]=max(dp[j], dp[j - v1[i]- v0[i]-v2[i]]+v0[i]*p0[i]+v1[i]*p1[i]+v2[i]*p2[i]);
						
	cout<<dp[n];
完全背包：存钱罐（恰好装满）

​

 背包恰好装满问题：

设有n个物品，其重量(或占用空间)分别为w1, W.,...Wn.价值分别为V1,2....n. ←
给定一个总容量为W的背包，每个物品只能整个放入背包或不放。←
问:如何选择放入背包的物品，使得背包中的物品的总重恰好为W的同时，总价值最大/小?

背包恰好装满 初始化不同，最后判断是否能装满。

dp[i][j]:前i个物品恰好装满j的最小值。

恰好装满求最小值：dp->inf,dp[0]=0

恰好装满求最大值：dp->-inf,dp[0]=0

理解：

(1)  初始化是指在没有任何物品放入背包的合法状态。

①容量为0的背包可以在什么也不装的情况下恰好被装满，价值为0，所以dp[0]=0

②容量不为0的背包在什么也不装的情况下不可能被装满，属于未定义的状态，所以应该被赋无穷（具体是正无穷还是负无穷，看题目求最大值还是最小值）

(2)  当前的合法解，一定是之前的合法状态推导得到，如果循环结束后，dp[m]还是inf，说明没有合法的状态能够推导到m，说明不能从n个数中选若干个装满m。

input();
memset(dp,inf,sizeof(dp));
dp[0]=0;
int v=f-e;
for(int i=1;i<=n;i++)
	for(int j=w[i];j<=v;j++)
		dp[j]=min(dp[j],dp[j-w[i]]+p[i]);
if(dp[v]==inf)cout<<"impossible"<<endl;
else cout<<dp[v]<<endl;
01背包问题-二维费用：宠物小精灵之收服
  1. 小智拥有一定数量的精灵球（N个）和皮卡丘初始体力值（M点）。
    • 每收服一只野生小精灵，会消耗特定数量的精灵球并造成对皮卡丘特定数值的体力伤害。

  2. 目标设定：

    • 主要目标：在不超出资源限制的前提下，最大化收服的野生小精灵数量（C）。
    • 次要目标（约束条件相同时）：在收服相同数量野生小精灵的情况下，尽可能使皮卡丘剩余体力值最大（R）。

  3. 决策过程：

    • 遇到每个野生小精灵时，小智有两项选择：收服或离开。
    • 若选择收服，必须消耗相应数量的精灵球，皮卡丘承受相应体力伤害。
    • 若选择离开，不消耗精灵球，皮卡丘无体力损失。

​

​

#include<iostream>
#include<cstring>
using namespace std;
int dp[1001][501];
int V1,V2,N;
int main(){
    cin>>V1>>V2>>N;
    for(int i=0;i<N;i++){
        int v1,v2;
        cin>>v1>>v2;
        for(int j=V1;j>=v1;j--){
            for(int k=V2-1;k>=v2;k--){
                dp[j][k]=max(dp[j][k],dp[j-v1][k-v2]+1);
            }
        }
    }
    cout<<dp[V1][V2-1]<<" ";
    for(int i=0;i<=V2-1;i++){
        if(dp[V1][i]==dp[V1][V2-1]){
            cout<<V2-i;
            return 0;
        }
    }
    return 0;
    
}
leetcode 416 分割等和子集

判断一个数组能否分成两个和相等的子集。

dp[i][j]表示选前i个数和为j的方案数。

初始化：dp[0][0]=1

递推式：dp[i][j]=dp[i-1][j]+dp[i-1][j-nums[i]]

空间优化：dp[j]+=dp[j-nums[i]]

01背包问题：猫狗大战

 一堆数分两组（1）每组数的个数只能差一个（2）每组数之和的差值尽可能小
输入：n，n个数
输出：每组数之和

01背包：

所有数之和为sum,如果想让两组数之和相差尽可能小，那么两组数尽量靠近sum/2
数是偶数，选n/2个数，并且容量为sum/2，使价值最大。

数是奇数，选n/2个数，并且容量为sum/2，是价值最大。

所以在n个数中，选n/2个数，使它们之和最大且不超过sum/2。

dp[i][j][k]:从前i个数中选k个数使它们之和不超过j并且和最大
dp[i][j][k] = max( dp[i-1][j][k]，dp[i-1][j-w[i]][k-1] + w[i] )
滚动数组：
dp[j][k]=max( dp[j][k]，dp[j-w[i]][k-1] + w[i] ) 

#include<iostream>
#include<cstring>
using namespace std;
int n;
int w[201];
int dp[10000][201];
int main()
{
	memset(dp,0,sizeof(dp));
	cin>>n;
	int sum=0;
	for(int i=1;i<=n;i++){
		cin>>w[i];
		sum+=w[i];
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=sum/2;j>=w[i];j--){
			for(int k=1;k<=n/2;k++){
				dp[j][k]=max(dp[j][k],dp[j-w[i]][k-1]+w[i]);
			}
		}
	}
	cout<<dp[sum/2][n/2];
}
背包问题输出方案：机器分配 ？？

​

 如果背包问题要输出方法则不能滚动数组化简空间，因为要回溯到上一个状态，所以上一个状态不能被更新。回溯关键：判断dp[i][j]的上一步是什么。即查找dp[i][j]=dp[i-1][j-v]+w。

找到后j-=v；并break。 ？？？

​

#include<iostream>
#include<cstring>
using namespace std;
int G[11][16];
int dp[20][20];
int way[20];
int main(){
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            cin>>G[i][j];
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=m;j>=0;j--){
            int r=0;
            for(int k=0;k<=m;k++){
                if(j-k>=0){
                   r=max(r,dp[i-1][j-k]+G[i][k]);
                }
            }
            dp[i][j]=r;
        }
    }
    cout<<dp[n][m]<<endl;
    int j=m;
    for(int i=n;i>=1;i--){
        for(int k=0;j<=j;k++){
            if(dp[i][j]==dp[i-1][j-k]+G[i][k]){
                way[i]=k;
                j-=k;
                break;
            }
        }
    }
    for(int i=1;i<=n;i++){
        cout<<i<<" "<<way[i]<<endl;
    }
    return 0;
}
多重背包方案：P1077摆花

​

​

 初始化：dp[0][0]=1表示前0种花选0盆有一种方案 

 空间优化：dp[j]=(dp[j]+dp[j-k])%mod;//注意k从1开始循环，因为如果k=0，就相当于把dp[i-1][j]计算了两遍

#include<iostream>
using namespace std;
int dp[101];
int a[101];

int main()
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)cin>>a[i];
	dp[0]=1; 
	for(int i=1;i<=n;i++)
		for(int j=m;j>=0;j--)
			for(int k=1;k<=a[i];k++)
				if(j-k>=0) dp[j]=(dp[j]+dp[j-k])%1000007;
	cout<<dp[m];

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

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

相关文章

C++进阶编程 --- 3(上).string容器、vector容器、deque容器、stack容器

C++进阶编程 --- 3(上).string容器、vector容器、deque容器、stack容器

文章目录 第三章(上)&#xff1a;3.STL 常用容器3.1 string容器3.1.1 string基本概念3.1.2 string构造函数3.1.3 string赋值操作3.1.4 string字符串拼接3.1.5 string查找和替换3.1.6 string字符串比较3.1.7 string字符存取3.1.8 string插入与删除3.1.9 string子串 3.2 vector容…
阅读更多...
14届蓝桥杯 C/C++ B组 T5 接龙排序 （最长上升子序列DP+优化）

14届蓝桥杯 C/C++ B组 T5 接龙排序 （最长上升子序列DP+优化）

不难发现这是一个LIS问题&#xff0c;但是如果直接套用LIS的模版&#xff0c;在数据范围到达 1 e 5 1e5 1e5 的情况下&#xff0c;就只能够得到一半的分数&#xff0c;所以我们需要对其进行优化。 首先给出暴力的代码&#xff1a; #include<iostream> using namespace…
阅读更多...
Linux虚拟网络设备深度解析：使用场景、分类与开发者指南

Linux虚拟网络设备深度解析：使用场景、分类与开发者指南

Linux虚拟网络设备支撑着各种复杂的网络需求和配置&#xff0c;从基础的网络桥接到高级的网络隔离和加密&#x1f510;。以下是对主要Linux虚拟网络设备的介绍、它们的作用以及适用场景的概览&#xff0c;同时提出了一种合理的分类&#xff0c;并指出应用开发人员应该着重掌握的…
阅读更多...
vue2/vue3手写专题——实现双向绑定/响应式拦截/虚拟DOM/依赖收集

vue2/vue3手写专题——实现双向绑定/响应式拦截/虚拟DOM/依赖收集

目录 vue双向绑定 请手动实现一个简单的双向绑定功能&#xff0c;要求实现以下功能&#xff1a; 1.使用原生javaScript 2.使用vue非v-model方式实现 思考&#xff1a;vue为什么要做双向绑定&#xff1f; 虚拟DOM/Render函数 将给定html片段写出Virtual Dom结构、并尝试挂载到页…
阅读更多...
【面试】运算器-⑪搜索旋转排序数组

【面试】运算器-⑪搜索旋转排序数组

先存一下后面要用的字符⑪⑫⑬⑭⑮⑯⑰⑱⑲⑳ 33. 搜索旋转排序数组 感谢力扣&#xff01; 整数数组 nums 按升序排列&#xff0c;数组中的值 互不相同 。 在传递给函数之前&#xff0c;nums 在预先未知的某个下标 k&#xff08;0 < k < nums.length&#xff09;上进行了…
阅读更多...
《UE5_C++多人TPS完整教程》学习笔记31 ——《P32 角色移动（Character Movement）》

《UE5_C++多人TPS完整教程》学习笔记31 ——《P32 角色移动（Character Movement）》

本文为B站系列教学视频 《UE5_C多人TPS完整教程》 —— 《P32 角色移动&#xff08;Character Movement&#xff09;》 的学习笔记&#xff0c;该系列教学视频为 Udemy 课程 《Unreal Engine 5 C Multiplayer Shooter》 的中文字幕翻译版&#xff0c;UP主&#xff08;也是译者&…
阅读更多...
S32K324 数据初始化Rom到Ram Copy的方式

S32K324 数据初始化Rom到Ram Copy的方式

文章目录 前言基础知识ld文件中的段定义ld文件中的符号定义 ld定义copy地址范围启动文件中的定义Copy的使用总结 前言 之前一直不理解在ld文件中加__xxx_ram_start,__xxx_rom_start,__xxx_rom_end这些的作用&#xff0c;也不清楚原理。前几天遇到一个内存copy的问题&#xff0…
阅读更多...
云计算（五）—— OpenStack基础环境配置与API使用

云计算（五）—— OpenStack基础环境配置与API使用

OpenStack基础环境配置与API使用 项目实训一 【实训题目】 使用cURL命令获取实例列表 【实训目的】 理解OpenStack的身份认证和API请求流程。 【实训准备】 &#xff08;1&#xff09;复习OpenStack的认证与API请求流程的相关内容。 &#xff08;2&#xff09;熟悉cURL…
阅读更多...
软件设计师——数据库

软件设计师——数据库

数据库 三级模式两级映像关系模型基本术语关系模型中的关系完整性约束 三级模式两级映像 概念模式&#xff08;也称模式&#xff09;对应基本表 外模式&#xff08;也称用户模式或子模式&#xff09;对应视图 内模式&#xff08;也称存储模式&#xff09;对应存储文件 两级映像…
阅读更多...
SL1581耐压30V芯片 24V转5V/2.4A

SL1581耐压30V芯片 24V转5V/2.4A

SL1581是一款专为24V转5V/2.4A应用设计的耐压30V芯片。这款芯片采用了先进的电源管理技术和高效能的转换电路&#xff0c;为电子设备提供了稳定、可靠的电源输出。 首先&#xff0c;SL1581芯片具有出色的耐压性能&#xff0c;能够在高达30V的电压下稳定工作。这使其非常适合在需…
阅读更多...
RFID涉密载体柜 RFID智能文件柜系统

RFID涉密载体柜 RFID智能文件柜系统

涉密载体管控RFID智能柜&#xff08;载体柜DW-G101R&#xff09;通过对涉密物资、设备进行RFID唯一标识并放置于RFID设备涉密物资柜柜体&#xff0c;通过定位每台设备每件涉密物资的位置&#xff0c;实现涉密物资审批、自助借还、防盗等出入库全流程自动化管理。主要管理对象移…
阅读更多...
Vulnhub：MHZ_CXF: C1F

Vulnhub：MHZ_CXF: C1F

目录 信息收集 arp-scan nmap nikto WEB web信息收集 dirmap gobuster ssh登录 提权 获得初始立足点 系统信息收集 横向渗透 提权 信息收集 arp-scan ┌──(root㉿ru)-[~/桌面] └─# arp-scan -l Interface: eth0, type: EN10MB, MAC: 00:50:56:…
阅读更多...
产品经理和项目经理的区别

产品经理和项目经理的区别

1. 前言 本文深入探讨了产品经理与项目经理在职责、关注点以及所需技能方面的显著区别。产品经理主要负责产品的规划、设计和市场定位，强调对用户需求的深刻理解和产品创新的推动；而项目经理则侧重于项目的执行、进度控制和资源管理，确保项目按时、按质、按预算完成。两者在…
阅读更多...
C++11可变模板参数：海纳百川的Args

C++11可变模板参数：海纳百川的Args

目录 一、可变模板参数的概念及功能 1.1Args的概念与使用 1.2获取args中的参数 二、emplace可变模板参数的实际应用 三、逗号表达式展开参数包 一、可变模板参数的概念及功能 1.1Args的概念与使用 C11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板…
阅读更多...
python中的split()用法

python中的split()用法

在Python中&#xff0c;split() 是一个字符串方法&#xff0c;用于将字符串按照指定的分隔符分割成一个列表。如果没有提供分隔符&#xff0c;那么它会默认按照任何空白字符&#xff08;如空格、换行符、制表符等&#xff09;进行分割。 这里是 split() 方法的一些基本用法&am…
阅读更多...
德兰梅尔：耐高温热销的膜元件亮相2024上海国际生物发酵展

德兰梅尔：耐高温热销的膜元件亮相2024上海国际生物发酵展

德兰梅尔&#xff1a;耐高温热销的膜元件盛装亮相2024上海国际生物发酵展&#xff0c;8月7-9号上海新国际博览中心与您不见不散&#xff01; 据了解&#xff0c;从成立至今&#xff0c;德兰梅尔一直专注膜技术、膜产品的开发生产。在中国市场上&#xff0c;德兰梅尔刚步入中国…
阅读更多...
代码随想录算法训练营33期 第三十一天（补29） | 491. 非递减子序列、46. 全排列、47. 全排列 II

代码随想录算法训练营33期 第三十一天（补29） | 491. 非递减子序列、46. 全排列、47. 全排列 II

491. 非递减子序列 class Solution { public:vector<int> path;vector<vector<int>> result;void BackTracking(vector<int>& nums, int index){if(path.size()>2){result.push_back(path);}unordered_set<int> usedSet;for (int iindex…
阅读更多...
nandgame中的asm编程 Escape Labyrinth(逃离迷宫)

nandgame中的asm编程 Escape Labyrinth(逃离迷宫)

先翻译题目&#xff1a; 逃离迷宫计算机被困在火星上的迷宫中。编写一个程序&#xff0c;让它逃离迷宫。计算机配备了连接的轮子和前方障碍物探测器。与轮子和探测器的输入/输出是内存映射在地址7FFF上&#xff1a;对外设的输出信号&#xff1a; 位 设置为1代表&#xff1a; 2…
阅读更多...
高精度原边控制离线式PWM功率开关芯片D3820的特征和详细的工作原理介绍

高精度原边控制离线式PWM功率开关芯片D3820的特征和详细的工作原理介绍

D3820是一款高精度原边控制离线式PWM功率开关。本文主要介绍D3820的特征和详细的工作原理&#xff0c;对反激式隔离AC-DC开关电源提供较为详细的测试过程。 特 点 1、全电压范围CC/CV精度保持在5%以内 2、用原边控制&#xff0c;无需TL431和光耦 3、欠压锁定&#xff08…
阅读更多...
2024mathorcup妈妈杯数学建模A题思路模型

2024mathorcup妈妈杯数学建模A题思路模型

2024mathorcup妈妈杯数学建模A题思路模型&#xff1a;比赛开始后第一时间更新&#xff0c;更新见文末名片&#xff0c;下面对2022年B题进行介绍&#xff1a; 2022Mathorcup B题题目介绍 ​ B题无人仓的搬运机器人调度问题本题考在无人仓内的仓库管理问题之一&#xff0c;搬运机…
阅读更多...
最新文章

Copyright @ 2022~2023