算法学习记录：动态规划

前言：

  算法学习记录不是算法介绍，本文记录的是从零开始的学习过程（见到的例题，代码的理解……），所有内容按学习顺序更新，而且不保证正确，如有错误，请帮助指出。

学习工具：蓝桥OJ，LeetCode

背景知识：

你有动态规划相关基础知识。

（算法学习记录：动态规划基础）

目录

前言：

背景知识：

 正文：

模型一：背包问题

01背包：

蓝桥OJ 1174：小明的背包1

蓝桥OJ 2223：背包与魔法

蓝桥OJ 3741：倒水

蓝桥OJ 3637：盗墓分赃

蓝桥OJ 2945：蓝桥课程抢购

完全背包：

 蓝桥OJ 1175：小明的背包2

多重背包：

蓝桥OJ 389：摆花

 蓝桥OJ 4059：新一的宝藏搜寻加强版

单调队列优化多重背包：

二维费用背包：

 蓝桥OJ 3937：小蓝的神秘行囊

 分组背包：

 蓝桥OJ 1178：小明的背包5

模型二：树型DP

模型三：区间DP

模型四：状压DP

模型五：数位DP

模型六：期望DP

 正文：

动态规划：Dynamic Programing 。以下简称“DP”。

按方法分类：搜索法（DFS），迭代法

按实现方式分类：一维DP，二维DP

动态规划涉及的问题种类繁多，按照题目模型分类：

模型一：背包问题

01背包：

问题描述：

  有一个体积为V的背包，商店有n个物品，每个物品有一个价值v和体积w，每个物品只能够被拿一次，文能够装下物品的最大价值。

设状态dp[i][j]表示到第i个物品为止，拿的物品总体积为j的情况下的最大价值。

状态转移方程：

蓝桥OJ 1174：小明的背包1
#include<bits/stdc++.h>
using namespace std;

using ll = long long;
const int N = 105,M = 1010;
ll dp[N][M];

int main()
{
	int n,V;cin >> n >> V;
	
	for(int i = 1;i <= n;i ++)
	{
		ll w,v;cin >> w >> v;
		for(int j = 0;j <= V;j ++)
		{
			if(j >= w)dp[i][j] = max(dp[i-1][j],dp[i-1][j-w]+v);
		    else dp[i][j] = dp[i - 1][j];
		}
		
	}
	
	cout << dp[n][V] << endl;
	
	return 0;
}

 观察发现：这题我们只关心第n个物品的情况，

所以没必要用二维数组把原来的所有情况存下

每次更新只用上一次数据，如果能直接进行覆盖，就采用一维数组解决问题。

优化：

dp[i][j]=dp[i-1][j]，相当于dp[i-1]复制给dp[i]，

将第一维优化掉直接当作一个数组

每次更新时，从后往前更新，此时dp[j]表示此时物品总体积为j时的物品最大价值。

得到状态转移方程：

#include<bits/stdc++.h>
using namespace std;

using ll = long long;
const int N = 105,M = 1010;
ll dp[M];

int main()
{
	int n,V;cin >> n >> V;
	
	for(int i = 1;i <= n;i ++)
	{
		ll w,v;cin >> w >> v;
		for(int j = V;j >= w;j ++)
		{
		  dp[j] = max(dp[j],dp[j - w] + v);
		}
		
	}
	
	cout << dp[V] << endl;
	
	return 0;
}
蓝桥OJ 2223：背包与魔法

对每个物品有3种选择：不选、选但不用魔法、选且用魔法

状态转移方程：

#include<iostream>
using namespace std;
using ll = long long;
const int N = 1e4 + 9;
ll dp[N][2];

int main()
{
	int n,m,k;cin >> n >> m >> k;
	for(int i = 1;i <= n;i ++)
	{
		ll w,v;cin >> w >> v;
		for(int j = m;j >= 0;j --)
		{
			if(j >= w)
			{
				dp[j][0] = max(dp[j][0],dp[j - w][0] + v);
				dp[j][1] = max(dp[j][1],dp[j - w][1] + v);
			}
			if(j >= w + k)
			{
				dp[j][1] = max(dp[j][1],dp[j - w - k][0] + 2 * v);
			}
		}	
	}
	cout << max(dp[m][0],dp[m][1]) << endl;
	return 0;
}
蓝桥OJ 3741：倒水
//为了尽可能节约水，本题只有3种倒水方式：
//1、给当前客人倒水a毫升，使得总好感度增加b
//2、给当前客人倒水c毫升(c>a)，使得总好感度增加d
//3、不给客人倒水(对应题目中的倒水小于a毫升，倒与不倒是一样的，还不如不倒)，总好感度增加e 
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

ll dp[1005][1005];//dp[i][j]表示只考虑前i个客人，共倒水j毫升所得的最大好感度 
//易知对于第i个客人，给其倒水所得好感度的多少只与前i-1个客人有关 

int main()
{
    int N,M;
    cin>>N>>M;
    for(int i=1;i<=N;i++)//分别考虑前1~N个客人 
    {
        ll a,b,c,d,e;
        cin>>a>>b>>c>>d>>e;
        for(int j=0;j<=M;j++)//对第i个客人，分别考虑共倒0~M毫升水 
        {
            //若当前拥有的水小于a，干脆不倒水，好感度为前i-1个客人共倒j升水所得好感度 加上e 
            if(j<a)dp[i][j]=dp[i-1][j]+e;
            //若当前拥有的水不小于a但是小于c，则可以选择倒a毫升或者不倒水
            //若倒a毫升水，则好感度为 前i-1个客人共倒j-a毫升水所得好感度 加上b
            //若不倒水，则好感度为 前i-1个客人共倒j毫升水所得好感度 加上e
            //二者取较大值即可 
            else if(j>=a&&j<c)dp[i][j]=max(dp[i-1][j-a]+b,dp[i-1][j]+e);
            //若当前拥有的水足够多，依次考虑三种情况，同理可得 
            else dp[i][j]=max(dp[i-1][j-a]+b,max(dp[i-1][j-c]+d,dp[i-1][j]+e));
        }
    }
    cout<<dp[N][M]<<endl;//考虑前N个客人，共倒M毫升水所得好感度的最大值 即为最终答案 
    return 0;
}

优化：


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll dp[1005];
int main()
{
	int N,M;
	cin>>N>>M;
	for(int i=1;i<=N;i++)
	{
		ll a,b,c,d,e;
		cin>>a>>b>>c>>d>>e;
		for(int j=M;j>=0;j--)
		{
			if(j<a)dp[j]=dp[j]+e;
			else if(j>=a&&j<c)dp[j]=max(dp[j-a]+b,dp[j]+e);
			else dp[j]=max(dp[j-a]+b,max(dp[j-c]+d,dp[j]+e));
		}
	}
	cout<<dp[M]<<endl;
	return 0;
}
蓝桥OJ 3637：盗墓分赃
#include<bits/stdc++.h>
using namespace std;
const int N=2e4+5;
bool dp[N];
const int M=1e3+4;
int s[M];
int main()
{
	int n;cin>>n;
	int sum=0;
	for(int i=1;i<=n;i++)
	{
		cin>>s[i];
		sum+=s[i];
	}
	dp[0]=true;                //啥也不拿一定可以
	if(sum%2!=0)
		cout<<"no"<<'\n';
	else
	{
		for(int i=1;i<=n;i++)
		{
			for(int j=sum;j>=1;j--)
			{
				if(j>=s[i])
					dp[j]=dp[j]||dp[j-s[i]];
			}
		}
		if(dp[sum/2])
			cout<<"yes"<<'\n';
		else
			cout<<"no"<<'\n';
	}
	return 0;
}
蓝桥OJ 2945：蓝桥课程抢购

由于要先考虑把时间短的放前面，使用结构体数组把数据关联起来，便于操作。

#include<bits/stdc++.h>
using namespace std;
using ll=long long;
const int N=1e5+4;
ll dp[55][N];            //表示在i个科目之前，j的等待时间下最大的价值
 struct Class
{
 int wait,j,value;
}c[55];
bool cmp(Class a,Class b)
{
   return a.j<b.j;
}
int main()
{
  ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
  int n;cin>>n;
  int sum=0;
  for(int i=1;i<=n;i++)
  {
    cin>>c[i].wait>>c[i].j>>c[i].value;
    sum=max(sum,c[i].j);
  }
  sort(c+1,c+n+1,cmp);               //先把截至时间短的放前面,贪心把时间短的先做了
  ll ans=0;
  for(int i=1;i<=n;i++)
  {
    for(int j=sum;j>=1;j--)
    {
      dp[i][j]=dp[i-1][j];               //先初始化成这个科目不选
      if(j>=c[i].wait&&j<=c[i].j)
      {
        dp[i][j]=max(dp[i][j],dp[i-1][j-c[i].wait]+c[i].value);
        ans=max(ans,dp[i][j]);
      }
    }
  }
  cout<<ans<<'\n';
  return 0;
}

优化：

#include<bits/stdc++.h>
using namespace std;
using ll=long long;
const int N=1e5+4;
ll dp[N];            //表示在i个科目之前，j的等待时间下最大的价值
struct Class
{
	int wait,j,value;
}c[55];
bool cmp(Class a,Class b)
{
	return a.j<b.j;
}
int main()
{
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int n;cin>>n;
	int sum=0;
	for(int i=1;i<=n;i++)
	{
		cin>>c[i].wait>>c[i].j>>c[i].value;
		sum=max(sum,c[i].j);
	}
	sort(c+1,c+n+1,cmp);               //先把截至时间短的放前面,贪心把时间短的先做了
	ll ans=0;
	for(int i=1;i<=n;i++)
	{
		for(int j=sum;j>=1;j--)
		{
			dp[j]=dp[j];               //先初始化成这个科目不选
			if(j>=c[i].wait&&j<=c[i].j)
			{
				dp[j]=max(dp[j],dp[j-c[i].wait]+c[i].value);
				ans=max(ans,dp[j]);
			}
		}
	}
	cout<<ans<<'\n';
	return 0;
}

完全背包：

又名无穷背包，每种物品有无数个背包。

即每个物品可以被拿无数次，有无限多个。

设状态dp[i]表示拿的物品总体积为i的情况下的最大价值。

状态转移方程：

 因为新数据的产生必须有先后，现在就必须用”新数据“来更新“新数据”。

 蓝桥OJ 1175：小明的背包2
#include<iostream>
using namespace std;
const int N = 1e3 + 9;
int dp[N];

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

对比这题与’小明的背包1‘，

可以发现：遍历顺序变化后，

dp[i]可以来自在相同t情况（遍历到了同一件物品）下刚刚被更新过的数据 。

这就计算了这件物品可以被用多次的情况。

多重背包：

有一个体积为V的背包，商店有n种物品，每种物品有一个价值v和体积w，每种物品有s个，问装下的最大价值。

只需在01背包模型的基础上再加一层循环，更新s次即可。

蓝桥OJ 389：摆花

对于每一个到达一个位置并种了某种花的情况，

方案数都是先种上一个位置并种了少用一种花的方案数，

具体来说：

这个方案数就是：保持种到相同位置，这最后一种花种了多少盆的所有情况的方案数之和

设状态dp[i][j]表示到第i种花为止（不一定以第i种花结尾），到第j个位置（1-j都放了花）的情况下的总方案数：

图解：

归纳出状态转移方程：

 

#include<bits/stdc++.h>
using namespace std;
const int N = 105;
using ll = long long;
const ll p = 1e6 + 7;
ll a[N],dp[N][N];
 
int main()
{
	int n,m; cin >> n >> m;
	for(int i = 1;i <= n; i ++)cin >> a[i];
	
	dp[0][0] = 1;
	
	for(int i = 1;i <= n;i ++)
	{
		for(int j = 0;j <= m;j ++)
		{
			for(int k = 0;k <= a[i] && k <= j; k ++){
				dp[i][j] = (dp[i][j] + dp[i - 1][j - k]) % p;
			}
		}
	}
	cout << dp[n][m] << endl;
	return 0;
}
 蓝桥OJ 4059：新一的宝藏搜寻加强版
#include<iostream>
using namespace std;
const int N = 205;
int dp[N];

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

 优化：原时间复杂度：O（n*s*V）

进行二进制优化：时间复杂度：O（n*logs*V）

#include<bits/stdc++.h>
using namespace std;

using ll = long long;
const int N = 1e3+7,M = 2e4 +7;


ll dp[M];

int main()
{
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int n,m;cin >> n >> m;
	for(int i = 1;i <= n;i ++)
	{
		ll v,w,s;cin >> v >> w >> s;
		for(int k = 1;k <= s;s -= k,k +=k)
		{
			for(int j = m;j >= k * v;j--)dp[j] = max(dp[j],dp[j - k * v] + k * w);
		}
		
		for(int j = m;j >= s*v;j --)dp[j] = max(dp[j],dp[j - s * v]+ s* w);
	}
	cout << dp[m] << endl;
	return 0;
}

单调队列优化多重背包：

另见：算法学习记录：滑动窗口

优化效果（时间复杂度）：

二维费用背包：

问题描述：

有一个体积为V的背包，商店有n种物品，每种物品有一个价值v、体积w、重量m，每种物品仅有1个，问能装下物品的最大价值。（需同时考虑体积和重量限制）

倒着更新，状态转移方程修改成二维。

状态转移方程：

 蓝桥OJ 3937：小蓝的神秘行囊
#include<bits/stdc++.h>
using namespace std;
using ll = long long ;
const int N = 105;
ll dp[N][N];

int main()
{
	int n,V,M;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] << endl;
	return 0;
}

 分组背包：

有一个体积为V的背包，商店有n组物品，每组物品有若干个，价值v、体积w。每组物品至多选一个，问能够装下的最大价值。

设状态dp[i][j]表示到第i组，体积为j的最大价值，这里不能忽略第一维，否则状态转移错误。

状态转移方程：

 蓝桥OJ 1178：小明的背包5
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1500;
ll dp[N][N];

int main()
{
	int n,V;cin >> n >> V;
	
	for(int i = 1;i <= n;i ++)
	{
		int s;cin >> s;
		for(int j = 0;j <= V;j ++)dp[i][j] = dp[i - 1][j];
		while(s --)
		{
			ll w,v;cin >> w >> v;
			for(int j = w;j <= V;j ++)dp[i][j] = max(dp[i][j],dp[i - 1][j - w] + v);
		}
	}
	
	
	cout << dp[n][V] << endl;
	
	return 0;
}

模型二：树型DP

了解过了树的基础后：算法学习记录：有关树的基础

 自上而下DP：

考虑树型DP问题一：

 如果暴力枚举：时间复杂度为O(n*2^n）不能解决问题

考虑贪心的办法：发现即使使用最大权值和作为判断依据，难以对树状结构进行正确计算。

因此采用动态规划算法：

考虑状态：

  由题中限制：一个子结点能不能选，受上一个结点的约束

所以需要开二维dp，用0或1表示被选或未被选的状态。

用f[i][0]表示当前结点不选所能得到的最大值

用f[i][1]表示当前结点选择后所能得的最大值。

考虑转移：

自上而下转移：在结点的所有儿子结点中取最大值，对0/1的情况分类讨论。

归纳出状态转移方程：

#include <bits/stdc++.h>
using namespace std;
#define maxn 110000
int n, val[maxn];
struct Edge
{
    int nex, to;
}edge[maxn << 1];
int head[maxn], cnt;
int f[maxn][2];
void add(int from, int to)
{
    edge[++cnt].nex = head[from];
    head[from] = cnt;
    edge[cnt].to = to;
    return ;
}
void dfs(int u, int fa)
{
    for (int i = head[u]; i; i = edge[i].nex)
    {
        int v = edge[i].to;
        if (v != fa)
            continue;
        dfs(v, u);
        f[u][0] += max(f[v][0], f[v][1]);
        f[u][1] += f[v][0];
    }
    return ;
}
int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; ++ i )
        scanf("%d", &val[i]), f[i][1] = val[i];
    for (int i = 1; i < n; ++ i )
    {
        int u, v;
        scanf("%d%d", &u, &v);
        add(u, v), add(v, u);
    }
    dfs(1, 0);
    printf("%d\n", max(f[1][0], f[1][1]));
    return 0;
}

 考虑树型DP问题二：

 考虑状态：

承接上一个模型，会想到用一个三维的dp，

仔细观察发现，可以将根据体积关系优化掉0/1这一维。

图解：

由体积的数量关系可以判断这个父结点一定被选上了，这样实现了一维的优化。  

考虑转移： 

在每一个结点下，把它的所有子节点当作许多物品。

用01背包的思路，将“贡献”合并。

归纳出状态转移方程： 

这是最核心的部分：

1.需要开一个新的一维数组来存储临时情况，因为更新时会用到原数据，不可以直接覆盖。

2.外层循环会遍历到每个子节点，所以对于数组nf[v]，最后复制回f[u][v]的数据是遍历过所有子结点的最终数据，是每个体积下的合法最优状况。

#include <bits/stdc++.h>
using namespace std;
#define maxn 110
int n, V;
int f[maxn][maxn];
int w[maxn], v[maxn];
vector<int> g[maxn];
struct Edge
{
	int nex, to;
}edge[maxn << 1];
int head[maxn], cnt;
void add(int from, int to)
{
	edge[++ cnt].nex = head[from];
	head[from] = cnt;
	edge[cnt].to = to;
	return ;
}

void dfs(int u, int fa)
{
	memset(f[u], -0x3f, sizeof f[u]);
	if (v[u] <= V)
		f[u][v[u]] = w[u];
	for (int i = head[u]; i; i = edge[i].nex)
	{
		int v = edge[i].to;
		if (v == fa)
			continue;
		dfs(v, u);
		vector<int> nf(f[u], f[u] + V + 1);
		for (int v1 = 0; v1 <= V; v1 ++)
		{
			for (int v2 = 0; v1 + v2 <= V; v2 ++ )
			{
				nf[v1 + v2] = max(nf[v1 + v2], f[u][v1] + f[v][v2]);
			}
		}
		for (int v = 0; v <= V; v ++ )
			f[u][v] = nf[v];
	}
	return ;
}
int main()
{
	scanf("%d%d", &n, &v);
	for (int i = 1; i < n; ++ i )
	{
		int u, v;
		add(u, v), add(v, u);
	}
	dfs(1, 0);
	int ans = 0;
	for (int i = 0; i <= V; ++ i )
		ans = max(ans, f[1][i]);
	cout << ans << endl;
	return 0;
}

 自下而上DP：

 每一次进行转移时，先遍历子节点，求出子节点的DP值之后，再向父节点转移。

最大独立集：

蓝桥OJ 1319：蓝桥舞会 

#include <bits/stdc++.h>
using namespace std;
const int N=100005;
int n,a[N];
long long dp[N][2];
vector<int> e[N];
void dfs(int u)
{
    for (auto v:e[u])
    {
        dfs(v);
        dp[u][1]+=dp[v][0];
        dp[u][0]+=max(dp[v][0],dp[v][1]);
    }
    dp[u][1]+=a[u];
}
int main()
{
    cin>>n;
    set<int> st;
    for (int i=1;i<=n;i++) cin>>a[i],st.insert(i);
    for (int i=1,x,y;i<n;++i)
    {
        cin>>x>>y;
        e[y].push_back(x);
        st.erase(x);
    }
    int rt=*st.begin();
    dfs(rt);
    cout<<max(dp[rt][0],dp[rt][1]);
    return 0;
}
最小点覆盖：

选择若干个点，使得树上每一条边都被覆盖。

即每一条边都至少有一个端点被选择，求被选择的点权和的最值。

 

 

 

#include <bits/stdc++.h>
using namespace std;
const int N=100005;
vector<int>e[N];
int val[N],dp[N][2];
int d[N];
int n, m, k;
void dfs(int u,int fa)
{
    for (auto v:e[u])
    {
        if (v==fa) continue;
        dfs(v,u);
        dp[u][0]+=dp[v][1];
        dp[u][1]+=min(dp[v][0],dp[v][1]);
    }
    dp[u][1]+=1;
}
int main()
{
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);
    cin>>n;
    for (int i=1,x,y;i<n;++i)
    {
        cin>>x>>y;
        e[x].push_back(y);
        e[y].push_back(x);
    }
    dfs(1,0);
    cout<<min(dp[1][0],dp[1][1]);
    return 0;
}
最小支配集：

选择若干个点，使得树上的每一个点都被支配，即每一点要么自身被选择要么相邻的结点被选择。

求选择的点的点权和最值。 

模型三：区间DP

区间DP是以区间为尺度的DP，一般有以下特点：

1.可以将一个大区间的问题拆成若干个子区间合并的问题

2.两个连续的子区间可以进行整合、合并成一个大区间。

 模型题：

#include <bits/stdc++.h>
using namespace std;
const int N=100005;
vector<int>e[N];
long long a[N],dp[N][3];
int d[N];
int n;
void dfs(int u)
{
    long long minn=1e18;
    for (auto v:e[u])
    {
        dfs(v);
        dp[u][0]+=min({dp[v][0],dp[v][1],dp[v][2]});
        dp[u][1]+=min(dp[v][0],dp[v][1]);
        minn=min(minn,dp[v][0]-min(dp[v][0],dp[v][1]));
        dp[u][2]+=dp[v][1];
    }
    dp[u][0]+=a[u];
    dp[u][1]+=minn;
}
int main()
{
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);
    cin>>n;
    for (int i=1;i<=n;++i)
    {
        int id,m;
        cin>>id;
        cin>>a[id];
        cin>>m;
        while (m--)
        {
            int x;
            cin>>x;
            e[id].push_back(x);
            d[x]++;
        }
    }
    int rt;
    for (int i=1;i<=n;++i)
        if (d[i]==0) rt=i;
    dfs(rt);
    cout<<min(dp[rt][0],dp[rt][1]);
    return 0;
}

 

模型四：状压DP

模型五：数位DP

模型六：期望DP

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

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

相关文章

Find My资讯|苹果Apple Pencil 3将支持Find My定位查找功能

Find My资讯|苹果Apple Pencil 3将支持Find My定位查找功能

国外科技媒体 9to5Mac 深挖 iOS 17.4 Beta 1 更新代码&#xff0c;发现了 Apple Pencil 3 的踪迹&#xff0c;并显示该手写笔支持 Find My 功能。这就意味着可以和 AirPods 和 AirTags 一样&#xff0c;用户可以通过 Find My 网络&#xff0c;寻找丢失的 Apple Pencil 手写笔。…
阅读更多...
Kotlin for loop: in、 until、 step、 downTo

Kotlin for loop: in、 until、 step、 downTo

Kotlin for loop: in、 until、 step、 downTo fun loop1() {for (i in 0..5) {print("$i ")}println("\n1-end\n") }fun loop2() {for (i in 0 until 5) {print("$i ")}println("\n2-end\n") }fun loop3() {for (i in 0 until (5)) {…
阅读更多...
探索Viper-适用于GoLang的完整配置解决方案

探索Viper-适用于GoLang的完整配置解决方案

前言 对于现代应用程序&#xff0c;尤其大中型的项目来说&#xff0c;在程序启动和运行时&#xff0c;往往需要传入许多参数来控制程序的行为&#xff0c;我们可以通过命令行参数&#xff0c;环境变量&#xff0c;配置文件等方式来将参数传递给程序。而Viper库为Golang语言开发…
阅读更多...
LabVIEW继电器触点接触电阻自动测试

LabVIEW继电器触点接触电阻自动测试

继电器作为工业中的重要组件&#xff0c;其性能直接影响着整个生产线的可靠性和安全性。触点接触电阻是衡量继电器性能的重要参数&#xff0c;传统的测试方法效率低下且成本高昂。为了解决这些问题&#xff0c;采用LabVIEW软件&#xff0c;结合专业的硬件平台&#xff0c;实现了…
阅读更多...
备战蓝桥杯----数据结构及STL应用（基础2）

备战蓝桥杯----数据结构及STL应用（基础2）

上次我们讲了vector的大致内容&#xff0c;接下来让我们讲一下栈&#xff0c;队列吧&#xff01; 什么是栈呢&#xff1f; 很简单&#xff0c;我们用的羽毛球桶就是&#xff0c;我们取的球&#xff0c;是最后放的&#xff0c;栈是一种先进后出的数据结构。 方法函数 s.push(…
阅读更多...
怎样做好Code Review

怎样做好Code Review

Code Review方案 定义 Code Review代码评审是指在软件开发过程中&#xff0c;通过对源代码进行系统性检查的过程。通常的目的是查找各种缺陷&#xff0c;包括代码缺陷、功能实现问题、编码合理性、性能优化等&#xff1b;保证软件总体质量和提高开发者自身水平 code review …
阅读更多...
SRM是什么意思？SRM供应商管理系统哪个好？

SRM是什么意思？SRM供应商管理系统哪个好？

阅读本文&#xff0c;您将了解&#xff1a;一、SRM是什么意思&#xff1b;二、SRM的应用价值&#xff1b;三、SRM供应商管理系统哪个好&#xff1f;推荐在零代码平台自主开发。 在当今快速变化的商业环境中&#xff0c;企业之间的协作和效率至关重要。供应链管理作为企业运营的…
阅读更多...
HarmonyOS鸿蒙学习笔记（24）AppScope的icon和UIAblity的icon的区别

HarmonyOS鸿蒙学习笔记（24）AppScope的icon和UIAblity的icon的区别

在HarmonyOS中有两个配置文件app.json5配置文件和module.json5配置文件&#xff0c;两个配置文件都有icon和label标签&#xff1a; 二者区别如下&#xff1a; app.json5的icon app.json5里面的icon和label:对应的是应用图标和应用标签&#xff0c;应用图标和标签是在设置应用…
阅读更多...
HarmonyOS --@state状态装饰器

HarmonyOS --@state状态装饰器

在声明式UI中&#xff0c;是以状态驱动视图更新。 状态&#xff08;state&#xff09;&#xff1a;指驱动视图更新的数据&#xff08;被装饰器标记的变量&#xff09;。 试图&#xff08;view&#xff09;&#xff1a;基于UI描述渲染得到用户界面 State装饰器标记的变量必须初…
阅读更多...
C# Socket 允许控制台应用通过防火墙

C# Socket 允许控制台应用通过防火墙

需求&#xff1a; 在代码中将exe添加到防火墙规则中&#xff0c;允许Socket通过 添加库引用 效果&#xff1a; 一键三联 若可用记得点赞评论收藏哦&#xff0c;你的支持就是写作的动力。 源地址: https://gist.github.com/cstrahan/513804 调用代码: private static void …
阅读更多...
雅特力AT32 Workbench图形化代码生成工具，简化嵌入式开发利器

雅特力AT32 Workbench图形化代码生成工具，简化嵌入式开发利器

嵌入式系统应用市场广泛&#xff0c;早已遍及日常生活&#xff0c;随着产品需求复杂度的提升&#xff0c;32位MCU开发难度也随之增加&#xff0c;如何降低开发成本&#xff0c;缩短开发周期&#xff0c;是所有嵌入式开发人员的共同课题。 面对市场竞争日益加剧的情形&#xff…
阅读更多...
【Web前端实操17】导航栏效果——滑动门

【Web前端实操17】导航栏效果——滑动门

滑动门 定义： 类似于这种： 滑到导航栏的某一项就会出现相应的画面，里面有对应的画面出现。 箭头图标操作和引用： 像一些图标，如果需要的话，可以找字体图标，比如阿里巴巴矢量图标库：iconfont-阿里巴巴矢量图标库 选择一个——>添加至购物车——>下载代码 因…
阅读更多...
实战 | OpenCV+OCR实现弧形文字识别实例(详细步骤 + 源码)

实战 | OpenCV+OCR实现弧形文字识别实例(详细步骤 + 源码)

导 读 本文主要介绍基于OpenCV+OCR实现弧形文字识别实例，并给详细步骤和代码。源码在文末。 背景介绍 测试图如下，目标是正确识别图中的字符。图片来源： https://www.51halcon.com/forum.php?mod=viewthread&tid=6712 同样，论坛中已经给出了Halcon实现代码，…
阅读更多...
Linux文件管理（下）

Linux文件管理（下）

上上篇介绍了Linux文件管理的上部分内容&#xff0c;这次继续将 Linux文件管理的剩余部分说完。内容如下。 一、查看文件内容 1、cat 命令 1.1 输出文件内容 基本语法&#xff1a; cat 文件名称主要功能&#xff1a;正序输出文件的内容。 eg&#xff1a;输出 readme.txt文…
阅读更多...
《幻兽帕鲁》1月29日游戏服务器推荐！腾讯云降低规格再次降价！

《幻兽帕鲁》1月29日游戏服务器推荐！腾讯云降低规格再次降价！

腾讯29日刷新规格&#xff0c;从14M降低到12M&#xff0c;硬盘和流量都有降低&#xff0c;但价格打下来了&#xff01;价格从66元/月降低到32元/月&#xff0c;277元/3个月降低到96元/3个月&#xff01; 三大厂商4核16G的云服务器价格对齐&#xff0c;不过具体参数略有不同 阿里…
阅读更多...
w24文件上传之PHP伪协议

w24文件上传之PHP伪协议

PHP支持的伪协议 file:// - 访问本地文件系统 http:// - 访问网址 ftp:// - 访问文件 php:// -访问各个输入/输出流 zlib:// -压缩流 data:// - 数据 glob:// -查找匹配的文件路径模式 phar:// - php归档 ssh2:// - Secure shell 2 rar:// - RAR ogg:// - 音频流 expect:// - …
阅读更多...
力扣(LeetCode)227. 基本计算器 II

力扣(LeetCode)227. 基本计算器 II

给你一个字符串表达式 s &#xff0c;请你实现一个基本计算器来计算并返回它的值。 整数除法仅保留整数部分。 你可以假设给定的表达式总是有效的。所有中间结果将在 [-231, 231 - 1] 的范围内。 注意&#xff1a;不允许使用任何将字符串作为数学表达式计算的内置函数&#…
阅读更多...
还能这样学Linux内核，非我族类！

还能这样学Linux内核，非我族类！

哈喽&#xff0c;我是子牙&#xff0c;一个很卷的硬核男人。深入研究计算机底层、Windows内核、Linux内核、Hotspot源码……聚焦做那些大家想学没地方学的课程 今天的互联网江湖&#xff0c;受大环境影响&#xff0c;已经不似前些年那般朝气蓬勃&#xff0c;裁员严重&#xff…
阅读更多...
C#简单使用Yolov5的Onnx格式模型进行目标检测

C#简单使用Yolov5的Onnx格式模型进行目标检测

背景 最近要离职了&#xff0c;同事需要了解一下C#如何使用yolov5系列onnx格式模型进行目标检测&#xff0c;由于其对C#不熟练&#xff0c;可能会影响公司后续的开发进度&#xff0c;所以趁着还在&#xff0c;赶紧把手尾搞好。 方案 1、创建一个C# DotNet 8 控制台项目[可千…
阅读更多...
Phoncent博客GPT写作工具

Phoncent博客GPT写作工具

对于许多人来说&#xff0c;写作并不是一件轻松的事情。有时候&#xff0c;我们可能会遇到写作灵感枯竭、写作思路混乱、语言表达困难等问题。为了解决这些问题&#xff0c;Phoncent博客推出了一款创新的工具——GPT写作工具&#xff0c;它利用了GPT技术&#xff0c;为用户提供…
阅读更多...
最新文章

Copyright @ 2022~2023