【寒假集训营总结笔记——7道优质好题】

2024-04-12 06:20
文章标签 总结 笔记 寒假 优质 集训营 好题

本文主要是介绍【寒假集训营总结笔记——7道优质好题】，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

牛客寒假集训营总结笔记——7道优质好题

一、Trie树的应用：

题目链接：Tokitsukaze and Min-Max XOR

1、题意

在这里插入图片描述

2、题解

1、首先这道题的答案和元素本身的顺序是无关的，因为假如你选择了一些数字，它是默认必须排好序才能记作是答案，所以对于我们枚举的任意一组max和min，位于 m i n ≤ x ≤ m a x min \le x \le max min≤x≤max的x是可取可不取的，所以就是 2 i − j − 1 + 1 2^{i-j-1}+1 2i−j−1+1就是当前位置作为max的贡献，怎么快速得到min呢，我们可以用01trie树得到。

2、01trie树详解(具体看代码)：
首先是建树了，在每个节点的周围都放一个val节点存放该节点的儿子节点所有的 ∑ ( 2 − i ) \sum(2^{-i}) ∑(2−i)。
然后就是搜索了，我们贪心的来使用trie树，当k在我们枚举的二进制位置为0时，当前二进制位必须和当前的max相抵消才能合法，当我们到达k的二进制为1的位置时，我们就可以直接把1^(max当前的二进制位)的贡献直接加上了，然后继续往下，类似于数位dp一样的思想去看。

3、代码

#include<bits/stdc++.h>
#define int long long 
#define endl '\n' 
using namespace std; 
const int N = 2e5 + 10;
const int inf = 0x3f3f3f3f; 
const int mod = 1e9 + 7; 
int n,m,cnt;
int a[N];
int son[N*40][2], val[N*40];int qpow(int x, int y) {int res = 1; while(y) {if(y & 1) res = res * x % mod;  x = x * x % mod; y >>= 1; }return res; 
}
// 建树
void insert(int x, int nums) {int p = 1; for(int i = 35; i >= 0; -- i ) {int t = x >> i & 1; if(!son[p][t]) {son[p][t] = ++ cnt;int q = cnt;son[q][1] = son[q][0] = 0;val[q]=0;}p = son[p][t]; val[p] = (val[p]+nums)%mod;}
}
//查询操作
int query(int x, int k) {int res=0,p=1;for(int i = 35; i >= 0; -- i ) {int ps = k >> i & 1;int cur = x >> i & 1; if(ps) {if(son[p][cur]) res = (res + val[son[p][cur]]) % mod;p = son[p][1^cur];}else p = son[p][cur];}res = (res + val[p]) % mod;return res; 
}
void solve() {cin >> n >> m;cnt=1;for(int i = 1; i <= n; ++ i ) cin >> a[i]; sort(a + 1, a + 1 + n);val[cnt]=0;son[cnt][0]=son[cnt][1]=0;int ans=0;for(int i = 1; i <= n; ++ i ) {ans = (ans + 1 + qpow(2,i - 1) * query(a[i],m) % mod) % mod;insert(a[i],qpow(qpow(2,i),mod-2));}cout<<ans<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0); cout.tie(0); int T; cin >> T; while(T -- ) solve();return 0; 
}

二、朴素懒标记的应用和模板总结：

题目链接： Tokitsukaze and Power Battle (easy)

1、题意：

在这里插入图片描述

2、题解

数据范围已经告诉我们了，只会增加非负数并且原数组元素也都是非负数，因为要让差距尽可能的大，所以肯定要从左边一直选择并且另一个玩家选择右边的后一个，保证它是最小的，比如：给定了我们 l , r l,r l,r,那我们需要的方案肯定是 m a x ( s u m [ L . . R ] − a [ R + 1 ] ) max(sum[L..R] - a[R + 1]) max(sum[L..R]−a[R+1])，因为我们贪心可以知道必须选择第一个元素，那么其实我们只需要维护一个 s [ 1.... l ] − a [ l + 1 ] s[1....l] - a[l + 1] s[1....l]−a[l+1]，加上懒标记即可，比如我们需要讲将 a x a_x ax​改成 y y y，只需要维护区间加法即可，即区间 x . . . n x...n x...n加上 − a x + y {-a_x+y} −ax​+y，与此同时我们再维护一个树状数组动态记录数组的前缀和，这样查询的时候我们就可以总结 q u e r y ( 1 , l , r ) − s u m ( l − 1 ) query(1,l,r)-sum(l-1) query(1,l,r)−sum(l−1)。

3、懒标记维护区间加法和区间最大值最小值：

#define int long long 
using namespace std; 
const int N = 5e5 + 10; 
const int inf = 0x3f3f3f3f; 
int n, m; 
int a[N]; 
struct node 
{int l, r; int mx,mn;int lz; 
}tr[N * 4]; void pushup(node &t, node& l, node& r)  
{t.mx = max(l.mx, r.mx);t.mn = min(l.mn, r.mn); 
}
void pushup(int u) 
{pushup(tr[u], tr[u << 1], tr[u << 1 | 1]); 
}void pushdown(int u) 
{if(!tr[u].lz) return; node &l = tr[u << 1], &r = tr[u << 1 | 1]; l.mx = l.mx + tr[u].lz, l.lz += tr[u].lz; r.mx = r.mx + tr[u].lz, r.lz += tr[u].lz; l.mn = l.mn + tr[u].lz; r.mn = r.mn + tr[u].lz; tr[u].lz = 0; pushup(u); 
}void build(int u, int l, int r) 
{tr[u].l = l, tr[u].r = r; if(l == r){tr[u].lz = 0; tr[u].mx = a[l] - (a[l + 1] - a[l]); tr[u].mn = a[l] - (a[l + 1] - a[l]); }else{tr[u].lz = 0; int mid = l + r >> 1; build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r); pushup(u); }
}void change(int u, int l, int r, int d)  
{node& t = tr[u]; if(t.l >= l && t.r <= r) {t.mx += d; t.mn += d; t.lz += d; }else{pushdown(u); int mid = t.l + t.r >> 1; if(l <= mid) change(u << 1, l, r, d); if(r > mid) change(u << 1 | 1, l, r, d); pushup(u); }
}
int query_mx(int u, int l, int r) 
{node t = tr[u]; if(t.l >= l && t.r <= r) return t.mx; else{pushdown(u); int res = -1e18; int mid = t.l + t.r >> 1; if(l <= mid)  res = max(res,query_mx(u << 1, l, r)); if(r > mid) res = max(res,query_mx(u << 1 | 1, l, r)); return res; }
}int query_mn(int u, int l, int r) 
{node t = tr[u]; if(t.l >= l && t.r <= r) return t.mn; else{pushdown(u); int res = 1e18; int mid = t.l + t.r >> 1; if(l <= mid)  res = min(res,query_mn(u << 1, l, r)); if(r > mid) res = min(res,query_mn(u << 1 | 1, l, r)); return res; }
}

4、代码：

#include <iostream> 
#include <algorithm> 
#include <cstdio> 
#include <cstring> #define int long long 
using namespace std; 
const int N = 5e5 + 10; 
const int inf = 0x3f3f3f3f; 
int n, m; 
int a[N]; 
struct node 
{int l, r; int mx,mn;int lz; 
}tr[N * 4]; void pushup(node &t, node& l, node& r)  
{t.mx = max(l.mx, r.mx);t.mn = min(l.mn, r.mn); 
}
void pushup(int u) 
{pushup(tr[u], tr[u << 1], tr[u << 1 | 1]); 
}void pushdown(int u) 
{if(!tr[u].lz) return; node &l = tr[u << 1], &r = tr[u << 1 | 1]; l.mx = l.mx + tr[u].lz, l.lz += tr[u].lz; r.mx = r.mx + tr[u].lz, r.lz += tr[u].lz; l.mn = l.mn + tr[u].lz; r.mn = r.mn + tr[u].lz; tr[u].lz = 0; pushup(u); 
}void build(int u, int l, int r) 
{tr[u].l = l, tr[u].r = r; if(l == r){tr[u].lz = 0; tr[u].mx = a[l] - (a[l + 1] - a[l]); tr[u].mn = a[l] - (a[l + 1] - a[l]); }else {tr[u].lz = 0; int mid = l + r >> 1; build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r); pushup(u); }
}void change(int u, int l, int r, int d)  
{node& t = tr[u]; if(t.l >= l && t.r <= r) {t.mx += d; t.mn += d; t.lz += d; }else {pushdown(u); int mid = t.l + t.r >> 1; if(l <= mid) change(u << 1, l, r, d); if(r > mid) change(u << 1 | 1, l, r, d); pushup(u); }
}
int query_mx(int u, int l, int r) 
{node t = tr[u]; if(t.l >= l && t.r <= r) return t.mx; else {pushdown(u); int res = -1e18; int mid = t.l + t.r >> 1; if(l <= mid)  res = max(res,query_mx(u << 1, l, r)); if(r > mid) res = max(res,query_mx(u << 1 | 1, l, r)); return res; }
}int query_mn(int u, int l, int r) 
{node t = tr[u]; if(t.l >= l && t.r <= r) return t.mn; else {pushdown(u); int res = 1e18; int mid = t.l + t.r >> 1; if(l <= mid)  res = min(res,query_mn(u << 1, l, r)); if(r > mid) res = min(res,query_mn(u << 1 | 1, l, r)); return res; }
}
int trr[N]; #define lowbit(x) (x&-x) 
void add(int x, int c) {for(int i = x; i <= n; i += lowbit(i)) trr[i] += c; 
}
int sum(int x) {int res = 0; for(int i = x; i; i -= lowbit(i)) res += trr[i]; return res; 
}
void solve() {scanf("%lld%lld",&n,&m); for(int i = 0; i <= n; ++ i ) trr[i] = 0; for(int i = 1; i <= n; ++ i ) {scanf("%lld",&a[i]); add(i,a[i]);a[i] += a[i - 1]; }a[n + 1] = a[n]; build(1,1,n);while(m -- ) {int x, y, z; cin >> x >> y >> z; if(x == 1) {int tt = sum(y) - sum(y-1);add(y,z-tt);change(1,y,n,z-tt);if(y-1>=1) change(1,y-1,y-1,-(z-tt));}else {cout<<query_mx(1,y,z-1)-sum(y-1)<<endl;}}
}
signed main() 
{int ts; scanf("%lld",&ts);while(ts -- ) solve(); return 0; 
}

三、第二类斯特林数

题目链接：鸡数题

1、题意：

在这里插入图片描述

2、题解：

问题可以很容易的转换成将n个小球放到m个盒子的方案，并且每个盒子都要有小球，第二类斯特林数是一个组合数学中的概念，表示将 n n n 个不同的物体划分成 k k k 个非空的不可辨别的集合的方法数。

通项公式为：转自oi-wiki
在这里插入图片描述

3、代码

#include <bits/stdc++.h> 
#define int long long 
using namespace std; 
const int N = 2e5 + 10; 
const int mod = 1e9 + 7; 
int n, m; 
int f1[N], f2[N]; 
int qmi(int x, int y) {int res = 1; while(y) {if(y & 1) res = res * x % mod; x = x * x % mod; y >>= 1; }return res; 
}
int f(int a, int b) {return f1[a] * f2[a - b] % mod * f2[b] % mod; 
}
signed main() {cin >> n >> m; if(n < m) {cout << 0 << endl; return 0; }if(n == m) {cout << 1 << endl; return 0; }f1[0] = 1, f2[0] = 1;  for(int i = 1; i <= n; ++ i ) {f1[i] = (f1[i - 1] * i) % mod;f2[i] = qmi(f1[i], mod - 2);  }int ans = 0; for(int i = 0; i <= m; ++ i )ans = (ans + qmi(-1, i) * f(m, i) % mod * qmi(m - i, n) % mod) % mod;ans = (ans * f2[m] % mod + mod) % mod;cout<<ans<<endl;return 0; 
}

四、贡献题的新思路

题目链接：tomorin的字符串迷茫值

1、题意：

在这里插入图片描述

2、题解：

一般我们做这种贡献题都是想着每种方案对答案的贡献，这道题换了一种思考的角度，我们对每种情况内的每个子情况对子情况所在的所有情况的贡献，比如mygo,就会有mygo, m_ygo,m_y_go…，m和y，y和g，g和o之间的位置都可以选和不选，求每个位置如果有当前这种情况，两边任意删除的情况就是它对他所在方案内的贡献。

怎么计算两边的任意情况的贡献呢，这里就需要dp了，dp[i]定义为长度为i的字符串，不删除连续位置的所有方案数。那么我们只需要考虑最后一个位置的字符，它既可以删也可以不删，如果保留就是dp[i-1],，如果删除，那就是dp[i-2],因为i-1不能删除，然后就是 d p [ i ] = d p [ i − 1 ] + d p [ i − 2 ] dp[i] = dp[i-1]+dp[i-2] dp[i]=dp[i−1]+dp[i−2]，就是斐波那契数列。

对于任意位置i…j的贡献计算就是： d p [ i − 1 ] ∗ d p [ n − i ] dp[i-1]*dp[n-i] dp[i−1]∗dp[n−i]

3、代码

#include<bits/stdc++.h>
#define int long long 
using namespace std;
const int N = 2e5 + 10; 
const int mod = 1e9 + 7; 
int n,m,k;
int f[N]; 
int qpow(int x, int y) {int res = 1; while(y) {if(y&1)res=res*x%mod;x=x*x%mod;y>>=1;}return res; 
}signed main() {f[0]=1,f[1]=2;for(int i = 2; i < N; ++ i ) f[i] = (f[i - 1] + f[i - 2]) % mod; string s;cin>>s;n=s.size();int ans=0;for(int i = 0; i < 1<<3; ++ i ) {string us="m";if(i>>0&1)us+='1';us+='y';if(i>>1&1)us+='1';us+='g';if(i>>2&1)us+='1';us+='o';int le=us.size();int t = 0;for(int j = 0; j + le - 1 < n; ++ j ) {string tmp = s.substr(j,le);bool flag=1;for(int k = 0; k < le; ++ k )if(us[k]!=tmp[k]&&us[k]!='1') {flag=0;break; }if(flag) {ans = (ans + f[j]*f[n-1-(j+le-1)]%mod)%mod;}}}cout<<ans<<endl;return 0; 
}

五、完全背包变形题

题目链接：soyorin的通知

完全背包板子：

#include<bits/stdc++.h> 
#define int long long 
using namespace std; 
const int N = 1010 + 10;
int n,m;
int dp[N];
signed main() {cin>>n>>m;// memset(dp,-0x3f,sizeof dp);dp[0]=0;for(int i = 1; i <= n; ++ i ) {int v,w;cin>>v>>w;for(int i = v; i <= m; ++ i ) dp[i]=max(dp[i],dp[i-v]+w);}cout<<dp[m]<<endl;return 0;
}

1、题意

在这里插入图片描述

2、题解

因为刚开始必须要至少先用p的代价先通知一个人，才能进行完全背包，那我们不妨先进行完全背包，然后再枚举用了几次的p，但注意必须至少一次。

3、代码

#include<bits/stdc++.h>
#define int long long 
using namespace std; 
const int N = 1010;
int n,m;
int dp[N];
int a[N],b[N];
signed main() {cin>>n>>m;for(int i = 1; i <= n; ++ i ) cin>>a[i]>>b[i];memset(dp,0x3f,sizeof dp);dp[0]=0;for(int i = 1; i <= n; ++ i ) {for(int j = 0; j <= n; ++ j ) dp[j]=min(dp[j],dp[max(0ll,j-b[i])]+a[i]);}int ans=1e18;for(int i = 0; i < n; ++ i )ans=min(ans,dp[i]+(n-i)*m);
//     cout<<dp[n]<<endl;cout<<ans<<endl;return 0; 
}

六、区间贪心问题 陡峭值问题

题目链接： rikki的数组陡峭值

1、题意

在这里插入图片描述

2、题解

首先假如我们有一堆的区间 [ l 1 , r 1 ] , [ l 2 , r 2 ] , . . . , [ l n , r n ] [l_1,r_1],[l_2,r_2],...,[l_n,r_n] [l1​,r1​],[l2​,r2​],...,[ln​,rn​], 此时我们假设有三个区间， s e g 1 = [ l 1 , r 1 ] , s e g 2 = [ l 2 , r 2 ] , s e g 3 = [ l 3 , r 3 ] seg_1=[l_1,r_1],seg_2=[l_2,r_2],seg_3=[l_3,r_3] seg1​=[l1​,r1​],seg2​=[l2​,r2​],seg3​=[l3​,r3​]
对于 s e g 1 ∩ s e g 3 = ∅ , s e g 2 ∩ s e g 3 ≠ ∅ , s e g 2 ∩ s e g 1 ≠ ∅ seg_1 \cap seg_3 = \empty, seg_2 \cap seg_3 \neq \empty, seg_2 \cap seg_1 \neq \empty seg1​∩seg3​=∅,seg2​∩seg3​=∅,seg2​∩seg1​=∅， s e g 2 seg_2 seg2​ 无论是和 s e g 1 seg_1 seg1​或者是 s e g 3 seg_3 seg3​合并， 结果一定 ≥ a b s ( s e g 3 . l − s e g 1 . r ) \geq abs(seg_3.l-seg_1.r) ≥abs(seg3​.l−seg1​.r)，所以我们肯定优先合并 s e g 1 seg_1 seg1​，因为合并 s e g 3 seg_3 seg3​会使得后面能合并的区间变少，肯定更劣。
其它情况，很显然是和能合并的区间合并。

3、代码

#include <bits/stdc++.h>
#define lowbit(x) (x&-x)
#define int long long 
#define ff first 
#define ss second 
using namespace std;
using PII = pair<int, int>; 
const int N = 3e5 + 10;
const int inf = 1e18; 
int n, m, k; 
int dp[N][2];void solve() {cin>>n;int l=1,r=1e9;vector<PII> ve;for(int i = 1; i <= n; ++ i ) {int L,R;cin>>L>>R;if(i==1) l=L,r=R;else {if(R<l||L>r) {ve.push_back({l,r});l=L,r=R;}else {l=max(l,L),r=min(r,R);// cout<<l<<' '<<r<<endl;}}}ve.push_back({l,r});// for(int i = 0; i < ve.size(); ++ i ) cout<<ve[i].ff<<" "<<ve[i].ss<<endl;if(ve.size()==1)cout<<0<<endl;else {for(int i = 1; i < ve.size(); ++ i ) {dp[i+1][0]=min(dp[i][0]+abs(ve[i].ff-ve[i-1].ff),dp[i][1]+abs(ve[i].ff-ve[i-1].ss)); dp[i+1][1]=min(dp[i][0]+abs(ve[i].ss-ve[i-1].ff),dp[i][1]+abs(ve[i].ss-ve[i-1].ss));} cout<<min(dp[ve.size()][0],dp[ve.size()][1])<<endl;}
}
signed main() {int ts=1;// cin >> ts; while(ts -- ) solve();return 0; 
}

七、分部dp解决问题，将一个复杂难以解决的问题拆解。

题目链接：来点每日一题

1、题意

在这里插入图片描述

2、题解

一次性考虑所有的情况时间复杂度要做到 O ( n 3 ) O(n^3) O(n3)，那肯定是超时了，我们不妨将问题转化成小的问题，先只考虑每段只选6个的方案，即 m x [ i ] [ j ] mx[i][j] mx[i][j],为i道j中选6个数的最优解，再做一遍线性dp，每次把一段看成一个整体， d p [ i ] = m a x ( d p [ i ] , d p [ j − 1 ] + m x [ j ] [ i ] ) dp[i] = max(dp[i], dp[j - 1] + mx[j][i]) dp[i]=max(dp[i],dp[j−1]+mx[j][i])，然后求mx[i][j]的过程也是一个很经典我问题，就是从i到j中选6个数使得它满足题目中的式子最大的方案，因为其中带有负号，所以我们得同时求最小值。

我们分部来看，首先是求 m x [ i ] [ j ] mx[i][j] mx[i][j]的过程：

    for(int i = 1; i <= n; ++ i ) {int f[7][3]; for(int j = 0; j <= 6; ++ j ) f[j][0]=-1e9,f[j][1]=1e9;f[0][0]=f[0][1]=0;for(int j = i; j <= n; ++ j ) {    for(int k = 6; k >= 1; -- k )  // 从后往前滚动数组，因为要利用上一个状态更新，不能从小到大，类似降维背包的写法。for(int t = 0; t <= 1; ++ t)     {if(abs(f[k-1][t])==1e9)continue; //到不合法不存在的方案要跳过，因为有负号可能会直接更新。if(k % 2 == 0) {f[k][0]=max(f[k][0],f[k-1][t]-a[j]);f[k][1]=min(f[k][1],f[k-1][t]-a[j]);}else if(k == 1) {f[k][0]=max(f[k][0],f[k-1][t]+a[j]);f[k][1]=min(f[k][1],f[k-1][t]+a[j]);}else {f[k][0]=max(f[k][0],f[k-1][t]*a[j]);f[k][1]=min(f[k][1],f[k-1][t]*a[j]);}}mx[i][j]=max(mx[i][j], f[6][0]);}}

有了 m x [ i ] [ j ] mx[i][j] mx[i][j]一切就很简单了

3、代码

#include<bits/stdc++.h>
#define int long long 
using namespace std; 
const int N = 1010; 
const int inf = 0x3f3f3f3f; 
int n,m;
int a[N];
int dp[N],mx[N][N]; signed main() {cin>>n;for(int i = 1; i <= n; ++ i ) cin>>a[i]; for(int i = 1; i <= n; ++ i ) {int f[7][3]; for(int j = 0; j <= 6; ++ j ) f[j][0]=-1e9,f[j][1]=1e9;f[0][0]=f[0][1]=0;for(int j = i; j <= n; ++ j ) {for(int k = 6; k >= 1; -- k ) for(int t = 0; t <= 1; ++ t)     {if(abs(f[k-1][t])==1e9)continue; if(k % 2 == 0) {f[k][0]=max(f[k][0],f[k-1][t]-a[j]);f[k][1]=min(f[k][1],f[k-1][t]-a[j]);}else if(k == 1) {f[k][0]=max(f[k][0],f[k-1][t]+a[j]);f[k][1]=min(f[k][1],f[k-1][t]+a[j]);}else {f[k][0]=max(f[k][0],f[k-1][t]*a[j]);f[k][1]=min(f[k][1],f[k-1][t]*a[j]);}}mx[i][j]=max(mx[i][j], f[6][0]);}}int ans=0;for(int i = 1; i <= n; ++ i ) {dp[i]=dp[i-1];for(int j = 1; j <= i; ++ j ) dp[i] = max(dp[i], dp[j-1]+mx[j][i]),ans=max(ans,dp[i]);}cout<<ans<<endl;return 0;
}

这篇关于【寒假集训营总结笔记——7道优质好题】的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/896339。

相关文章

Python中连接不同数据库的方法总结

Python中连接不同数据库的方法总结

《Python中连接不同数据库的方法总结》在数据驱动的现代应用开发中,Python凭借其丰富的库和强大的生态系统,成为连接各种数据库的理想编程语言,下面我们就来看看如何使用Python实现连接常用的几... 目录一、连接mysql数据库二、连接PostgreSQL数据库三、连接SQLite数据库四、连接Mo
阅读更多...
Git提交代码详细流程及问题总结

Git提交代码详细流程及问题总结

《Git提交代码详细流程及问题总结》：本文主要介绍Git的三大分区,分别是工作区、暂存区和版本库,并详细描述了提交、推送、拉取代码和合并分支的流程,文中通过代码介绍的非常详解,需要的朋友可以参考下... 目录1.git 三大分区2.Git提交、推送、拉取代码、合并分支详细流程3.问题总结4.git push
阅读更多...
Kubernetes常用命令大全近期总结

Kubernetes常用命令大全近期总结

《Kubernetes常用命令大全近期总结》Kubernetes是用于大规模部署和管理这些容器的开源软件-在希腊语中,这个词还有“舵手”或“飞行员”的意思,使用Kubernetes（有时被称为“... 目录前言Kubernetes 的工作原理为什么要使用 Kubernetes？Kubernetes常用命令总
阅读更多...
Python中实现进度条的多种方法总结

Python中实现进度条的多种方法总结

《Python中实现进度条的多种方法总结》在Python编程中,进度条是一个非常有用的功能,它能让用户直观地了解任务的进度,提升用户体验,本文将介绍几种在Python中实现进度条的常用方法,并通过代码... 目录一、简单的打印方式二、使用tqdm库三、使用alive-progress库四、使用progres
阅读更多...
Android数据库Room的实际使用过程总结

Android数据库Room的实际使用过程总结

《Android数据库Room的实际使用过程总结》这篇文章主要给大家介绍了关于Android数据库Room的实际使用过程,详细介绍了如何创建实体类、数据访问对象（DAO）和数据库抽象类,需要的朋友可以... 目录前言一、Room的基本使用1.项目配置2.创建实体类（Entity）3.创建数据访问对象（DAO
阅读更多...
Java向kettle8.0传递参数的方式总结

Java向kettle8.0传递参数的方式总结

《Java向kettle8.0传递参数的方式总结》介绍了如何在Kettle中传递参数到转换和作业中,包括设置全局properties、使用TransMeta和JobMeta的parameterValu... 目录1.传递参数到转换中2.传递参数到作业中总结1.传递参数到转换中1.1. 通过设置Trans的
阅读更多...
C# Task Cancellation使用总结

C# Task Cancellation使用总结

《C#TaskCancellation使用总结》本文主要介绍了在使用CancellationTokenSource取消任务时的行为,以及如何使用Task的ContinueWith方法来处理任务的延... 目录C# Task Cancellation总结1、调用cancellationTokenSource.
阅读更多...
HarmonyOS学习(七)——UI（五）常用布局总结

HarmonyOS学习(七)——UI（五）常用布局总结

自适应布局 1.1、线性布局（LinearLayout） 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列，Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距，达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式，且在各类尺寸屏幕上表现一致，其中交叉轴为垂直时，取值为Vert
阅读更多...
学习hash总结

学习hash总结

2014/1/29/   最近刚开始学hash，名字很陌生，但是hash的思想却很熟悉，以前早就做过此类的题，但是不知道这就是hash思想而已，说白了hash就是一个映射，往往灵活利用数组的下标来实现算法，hash的作用：1、判重；2、统计次数；
阅读更多...
好题——hdu2522（小数问题：求1/n的第一个循环节）

好题——hdu2522（小数问题：求1/n的第一个循环节）

好喜欢这题，第一次做小数问题，一开始真心没思路，然后参考了网上的一些资料。 知识点***********************************无限不循环小数即无理数，不能写作两整数之比*****************************（一开始没想到，小学没学好） 此题1/n肯定是一个有限循环小数，了解这些后就能做此题了。 按照除法的机制，用一个函数表示出来就可以了，代码如下
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2