The 2022 ICPC Asia Xian Regional Contest

news/2024/9/19 20:43:25/文章来源:https://www.cnblogs.com/luckyblock/p/18418794

目录
  • 写在前面
  • F 签到
  • J 签到
  • C 贪心，模拟
  • G 字符串，哈希
  • L 贪心，结论
  • E 数学，模拟
  • B 结论，网络流
  • A LCT or 根号预处理 or 线段树分治维护连通性
  • D 倍增，DP
  • 写在最后

写在前面

比赛地址：https://codeforces.com/gym/104077。

以下按个人向难度排序。

vp 8 题 900+ 罚时差 100 罚时金。

唉唉现在题数够了还是很爽的，然而唐氏太多白白吃好多发不该。

而且感觉队友在线时长不够啊呃呃必须要 push 一下、、、

F 签到

祝大秦酒店越办越好。

不对我草今年估计 EC 西安应该能拿个名额怎么轮到我去住大秦酒店了我草

Code by wenqizhi：

#include<bits/stdc++.h>
using namespace std;#define ll long long
#define ull unsigned long longint read()
{int x = 0; bool f = false; char c = getchar();while(c < '0' || c > '9') f |= (c == '-'), c = getchar();while(c >= '0' && c <= '9') x = (x << 1) + (x << 3) + (c & 15), c = getchar();return f ? -x : x;
}const int N = 1000;
int n, c1, c2;
char s[100];
int main()
{n = read(), c1 = read(), c2 = read(), c1 = min(c1, c2);if(c1 * 2 <= c2){ printf("%lld\n", 3ll * n * c1); return 0; }ll ans = 0;for(int i = 1; i <= n; ++i){scanf("%s", s + 1);int flag = 0;if(s[1] == s[2] || s[1] == s[3] || s[2] == s[3]) flag = 1;if(flag) ans += c1 + c2;else ans += c1 * 3;}printf("%lld\n", ans);return 0;
}

J 签到

考虑枚举选的数中下标 \(i\) 的最大值，发现之后仅能在 \(1\sim i-1\) 中再选一个数，优先队列搞一下即可。

//
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
//=============================================================
//=============================================================
//=============================================================
int main() {//freopen("1.txt", "r", stdin);std::ios::sync_with_stdio(0), std::cin.tie(0);int n; std::cin >> n;std::priority_queue <int> q;LL ans = 0;for (int i = 1; i <= n; ++ i) {int a; std::cin >> a;LL sum = a;if (!q.empty()) sum += std::max(0, q.top());ans = std::max(ans, sum);q.push(a);}std::cout << ans << "\n";return 0;
}

C 贪心，模拟

发现所有人先进行复制再进行造题一定是最优的，若某轮中既有造题的又有复制的，将这轮都改成复制，则最终结束时刻一定不会更靠后。

复制时数量是倍增的，于是直接枚举复制几轮即可。

Code by dztlb：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=1e5+5;
const int inf=1e9;
int T;
int a,b,c;
signed main(){cin>>T;while(T--){cin>>a>>b>>c;int ans=inf*inf;for(int i=0;i<=30;++i){int cnt=1;int tmp=0;for(int j=1;j<=i;++j){cnt*=2;tmp+=a;}int now=(c/cnt);if(c%cnt!=0) ++now;tmp+=now*b;ans=min(ans,tmp);}cout<<ans<<'\n';}return 0;
}

G 字符串，哈希

显然答案一定是给定的 \(n\) 个字符串中的某个。

答案 \(s_1s_2\cdots s_{|s|}\) 的所有子串均在给定的 \(n\) 个字符串中出现过，发现这等价于：\(s_2s_2\cdots s_{|s|}\) 与 \(s_1s_2\cdots s_{|s|-1}\) 均出现过。

于是考虑把所有字符串哈希一下用于判重，然后按照长度枚举所有字符串，通过上述结论判断当前字符串是否合法并标记即可。

被标记的最长的字符串即为答案。

有唐氏写哈希忘驱魔了呃呃

//
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
const int kN = 1e5 + 10;
const LL p = 1e9 + 7;
const LL c = 1331;
//=============================================================
int n;
std::string s[kN];
bool yes[kN];
std::set<LL> hash;
//=============================================================
bool cmp(const std::string &fir_, const std::string &sec_) {return fir_.length() < sec_.length();
}
//=============================================================
int main() {// freopen("1.txt", "r", stdin);std::ios::sync_with_stdio(0), std::cin.tie(0);std::cin >> n;for (int i = 1; i <= n; ++ i) std::cin >> s[i];std::sort(s + 1, s + n + 1, cmp);int ans = 0;for (int i = 1; i <= n; ++ i) {int len = s[i].length();LL h = 0, h1 = 0, h2 = 0;if (len == 1) {yes[i] = 1;} else {for (int j = 0; j < len - 1; ++ j) h1 = (c * h1 + s[i][j]) % p;for (int j = 1; j < len; ++ j) h2 = (c * h2 + s[i][j]) % p;yes[i] = (hash.count(h1) && hash.count(h2));}h = (c * h1 + s[i][len - 1]) % p;if (yes[i]) ans = std::max(ans, len), hash.insert(h);}std::cout << ans << "\n";return 0;
}
/*
5
a
aa
aaa
aaaa
aaaaa
*/

L 贪心，结论

有唐氏写的一坨嗯吃两发被我狠狠批判然后五分钟重构一发过了。

题意等价于使用极大的链或反链完全覆盖一棵有根树的最小覆盖次数。

发现若使用反链进行覆盖，最优的情况是每次选择当前有根树的所有叶节点。若不覆盖叶节点则既不能减少链的数量，从而便于使用链覆盖，且之后不可避免地还需要覆盖叶节点。

叶节点至多仅有 \(O(n)\) 层，于是考虑模拟地不断使用反链覆盖，枚举删去叶节点的层数，则之后需要的链覆盖的次数即为当前叶节点数量。

//
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
const int kN = 2e6 + 10;
//=============================================================
std::vector<int> leaves[2];
int n, fa[kN], son[kN];
//=============================================================
//=============================================================
int main() {//freopen("1.txt", "r", stdin);std::ios::sync_with_stdio(0), std::cin.tie(0);int T; std::cin >> T;while (T --) {std::cin >> n;leaves[0].clear(), leaves[1].clear();for (int i = 1; i <= n; ++ i) son[i] = fa[i] = 0;for (int i = 2; i <= n; ++ i) {std::cin >> fa[i];++ son[fa[i]];}for (int i = 1; i <= n; ++ i) {if (son[i] == 0) leaves[0].push_back(i);}int ans = leaves[0].size(), now = 0;for (int i = 1; i <= n; ++ i, now ^= 1) {if (leaves[now].empty()) break;leaves[now ^ 1].clear();for (auto u: leaves[now]) {-- son[fa[u]];if (son[fa[u]] == 0) leaves[now ^ 1].push_back(fa[u]);}ans = std::min(ans, (int) (i + leaves[now ^ 1].size()));}std::cout << ans << "\n";}return 0;
}
/*
3
7
1 1 2 2 2 3
5
1 2 3 4
11
1 2 3 4 5 2 3 4 5 6
*/

E 数学，模拟

发现给定式子相当于考虑 \(x\) 的三进制表示，\(f(x)\) 即三进制下的位数+三进制各位之和。

于是大力讨论即可。最优情况是各位全部取 2，需要讨论被上下界限制时取不到最优情况。

Code by wenqizhi：

#include<bits/stdc++.h>
using namespace std;#define ll long long
#define ull unsigned long longll read()
{ll x = 0; bool f = false; char c = getchar();while(c < '0' || c > '9') f |= (c == '-'), c = getchar();while(c >= '0' && c <= '9') x = (x << 1) + (x << 3) + (c & 15), c = getchar();return f ? -x : x;
}const int N = 105;
ll sum[N];void init()
{sum[0] = 1;for(int i = 1; i; ++i){sum[i] = sum[i - 1] * 3;if(sum[i] > 1e18) break;}
}int get(int len, ll r)
{ll L = sum[len - 1];int cnt = 1;for(int i = 1; i <= len; ++i){for(int j = 1; j <= 2 - (i == len); ++j)if(sum[i - 1] + L <= r) ++cnt, L += sum[i - 1];}return cnt;
}void solve()
{ll l = read(), r = read(), L = l;int ans = 0;int len = 0, cnt = 0;while(L){cnt += L % 3;L /= 3;++len;}L = l;len = max(len, 1);ans = max(ans, cnt);for(int i = 1; i <= len; ++i){int res = 3 - l / sum[i - 1] % 3 - 1;for(int j = 1; j <= res; ++j)if(sum[i - 1] + L <= r) ++cnt, L += sum[i - 1];}ans = max(ans, cnt + len);for(int i = len + 1; i; ++i){if(sum[i - 1] > r || sum[i - 1] == 0) break;ans = max(ans, get(i, r) + i);}printf("%d\n", ans);
}int main()
{init();int T = read();while(T--) solve();return 0;
}

B 结论，网络流

我去这题给 dztlb 大神开出来了真是我叠吧

根据给定的变量的含义，颜色数量 \(k\) 与填 0 数量 \(z\) 显然成反比关系，则容易看出 \(ck+dz\) 是关于 \(k\) 的单谷函数。于是考虑三分，检查在使用 \(k\) 种颜色情况下，最少填多少 0（最多可以填多少非 0）可以合法，即可求得对应的 \(ck+dz\) 的值。

发现问题可以看做是在给定颜色种类数限制下，保证每行/每列同种非 0 颜色数量不大于 1，最大化填的非 0 的数量，又数据范围很小，一个显然的想法是通过网络流进行非 0 的填色最大化流量，跑最大流即为所求。

对于上述问题，记三分量为 \(\operatorname{mid}\)，dztlb 大神的建图策略如下：

  • 先统计每行/每列的空格数量，记为 \(\operatorname{cntx}, \operatorname{cnty}\)；
  • 对每行/每列建点，编号分别为 \(1\sim n\)，\(n + 1\sim n + m\)；
  • 对于第 \(i\) 行，若有 \(\operatorname{cntx}_i\ge \operatorname{mid}\)，连边 \((S, i, \operatorname{cntx}_i - \operatorname{mid})\)，然后枚举列 \(j\)，若有 \(\operatorname{cnty}_j\ge \operatorname{mid}\)，连边 \((i, n+j, 1)\)；
  • 对于第 \(j\) 列，若有 \(\operatorname{cnty}_j\ge \operatorname{mid}\)，连边 \((n+j, T, \operatorname{cnty}_j - \operatorname{mid})\)；
  • 则最小化填 0 数量即：\(\sum \operatorname{cntx} + \sum \operatorname{cnty} - \operatorname{maxflow}\)。

建边数量为 \(O(nm)\) 级别，但是这图只有 4 层根本跑不满，实际运行效率非常高。

然后我当代码黑奴给 dztlb 大神写了最大流写了三分就过了哈哈

//知识点：网络最大流，Dinic
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
const int kN = 1e5 + 10;
const int kM = 2e6 + 10;
const LL kInf = 1e18 + 2077;
//=============================================================
int n, m, c, d, S, T;
int nodenum, maxnodenum, edgenum = 1, v[kM], ne[kM], head[kN];
int cur[kN], dep[kN];
std::string map[kN];
int cn[kN],cm[kN];
LL w[kM];
//=============================================================
void addedge(int u_, int v_, LL w_) {v[++ edgenum] = v_;w[edgenum] = w_;ne[edgenum] = head[u_];head[u_] = edgenum;v[++ edgenum] = u_;w[edgenum] = 0;ne[edgenum] = head[v_];head[v_] = edgenum;
}
void init() {edgenum = 1;nodenum = n + m;maxnodenum = 3 * n + 2;S = ++ nodenum, T = ++ nodenum;for (int i = 1; i <= maxnodenum; ++ i) {head[i] = 0;}
}
bool bfs() {std::queue <int> q;memset(dep, 0, (nodenum + 1) * sizeof (int));dep[S] = 1; //注意初始化 q.push(S); while (!q.empty()) {int u_ = q.front(); q.pop();for (int i = head[u_]; i > 1; i = ne[i]) {int v_ = v[i], w_ = w[i];if (w_ > 0 && !dep[v_]) {dep[v_] = dep[u_] + 1;q.push(v_);}}}return dep[T];
}
LL dfs1(int u_, LL into_) {if (u_ == T) return into_; LL ret = 0;for (int i = cur[u_]; i > 1 && into_; i = ne[i]) {int v_ = v[i];LL w_ = w[i];if (w_ && dep[v_] == dep[u_] + 1) {LL dist = dfs1(v_, std::min(into_, w_));if (!dist) dep[v_] = kN;into_ -= dist; ret += dist;w[i] -= dist, w[i ^ 1] += dist;if (!into_) return ret;}}if (!ret) dep[u_] = 0; return ret;
}
LL dinic() {LL ret = 0;while (bfs()) {memcpy(cur, head, (nodenum + 1) * sizeof (int));ret += dfs1(S, kInf);}return ret;
}
LL check(LL mid_) {init();LL tmp=0;for(int i=1;i<=n;++i){if(cn[i]>mid_){addedge(S,i,cn[i]-mid_);tmp+=cn[i]-mid_;for(int j=1;j<=m;++j){if(cm[j]>mid_){addedge(i,n+j,1);}}}}for(int i=1;i<=m;++i){if(cm[i]>mid_){addedge(n+i,T,cm[i]-mid_);tmp+=cm[i]-mid_;}}return 1ll * mid_ * c + d * (tmp - dinic());
}
//=============================================================
int main() {// freopen("1.txt", "r", stdin);std::ios::sync_with_stdio(0), std::cin.tie(0);std::cin >> n >> m >> c >> d;for (int i = 1; i <= n; ++ i) {std::cin >> map[i]; map[i] = "$" + map[i];}for(int i=1;i<=n;++i){for(int j=1;j<=m;++j){if(map[i][j]=='.'){cn[i]++,cm[j]++;}}}LL lmid, rmid, lans = kInf, rans = kInf;for (LL l = 0, r = std::max(n, m); l <= r; ) {lmid = l + (r - l) / 3;rmid = r - (r - l) / 3;lans = check(lmid), rans = check(rmid);if (rans <= lans) l = lmid + 1;else r = rmid - 1;}std::cout << std::min(lans, rans) << "\n";return 0;
}
/*
5 5 3 1
*..*.
...**
.*...
..*..
..*..
*/

A LCT or 根号预处理 or 线段树分治维护连通性

我去这题给我开出来了最后十分钟一发过了我真是叠吧

保证一个点至多连一条桥，则从每个起点出发，到达的终点一定是不同且唯一的。

发现在 \((a, b), (a + 1, b)\) 连边，对移动路径的影响，等价于断开边：\((a, b)\rightarrow (a, b + 1), (a+1, b)\rightarrow (a+1, b + 1)\)，然后连边：\((a, b)\rightarrow (a+1, b + 1), (a+1, b)\rightarrow (a, b + 1)\)。

发现断边连边后，给定的图仍是 \(n\) 条长度为 \(m+1\) 的链，一个显然的想法是使用 LCT 直接维护，考虑仅令每条链结尾的点权值为其链号，则查询仅需查询给定起点对应链的树的权值和即可。

然而有 \(O(nm)\) 个点并不能直接做，但是发现至多只有 \(q\) 次操作，则有影响的点仅有 \(O(n+q)\) 级别，于是考虑将每行的点按是否连了桥进行分段，则每段都可以直接缩成一个点考虑，就能直接上 LCT 了。

我的分段缩点方法是先将每条链看做一个点，然后模拟连桥后将原来的点分裂得到新点，比较唐呃呃，优美做法可见 HolyK 的这发提交：https://codeforces.com/gym/104077/submission/183684508。

std 是根号预处理；此外还有大神的线段树分治维护连通性，可见这发提交：https://codeforces.com/gym/104077/submission/272665032。

//
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
#define pr std::pair
#define mp std::make_pair
const int kN = 5e5 + 10;
//=============================================================
int n, m, q, a[kN], ans[kN];
struct O {int opt, a, b;
} op[kN];
struct Node {int id, a, l, r, val;bool operator <(const Node& sec_) const {if (a != sec_.a) return a < sec_.a;if (r != sec_.r) return r < sec_.r;if (l != sec_.l) return l < sec_.l;if (id != sec_.id) return id < sec_.id;return val < sec_.val;} 
} node[kN];
int nodenum, next[kN];
std::set<Node> st;
//=============================================================
inline int read() {int f = 1, w = 0; char ch = getchar();for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;for (; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0'); return f * w;
}
namespace LCT {#define f fa[now_]#define ls son[now_][0]#define rs son[now_][1]int fa[kN], son[kN][2];int val[kN], sum[kN], sum1[kN];bool rev[kN];void clear(int now_) {ls = rs = f = val[now_] = 0;}void Pushup(int now_) {sum[now_] = (sum[ls] + sum[rs] + val[now_] + sum1[now_]);}void Rev(int now_) {if (!now_) return ;std::swap(ls, rs);rev[now_] ^= 1;}void Pushdown(int now_) {bool rev_ = rev[now_];if (rev_) Rev(ls), Rev(rs);rev[now_] = 0;}bool Isroot(int now_) {return son[f][0] != now_ && son[f][1] != now_;}bool Whichson(int now_) {return son[f][1] == now_;}void Rotate(int now_) {int fa_ = f, ffa = fa[f], w = Whichson(now_);if (!Isroot(f)) son[fa[f]][Whichson(f)] = now_;f = fa[f];son[fa_][w] = son[now_][w ^ 1];fa[son[fa_][w]] = fa_;son[now_][w ^ 1] = fa_;fa[fa_] = now_;Pushup(fa_), Pushup(now_), Pushup(ffa);}void Update(int now_) {if (!Isroot(now_)) Update(f);Pushdown(now_);}void Splay(int now_) {Update(now_);for (; !Isroot(now_); Rotate(now_)) {if (!Isroot(f)) Rotate(Whichson(f) == Whichson(now_) ? f : now_);}}void Access(int now_) {for (int last = 0; now_; last = now_, now_ = f) {Splay(now_); sum1[now_] += sum[rs] - sum[last];rs = last;Pushup(now_);}}void Makeroot(int now_) {Access(now_);Splay(now_);Rev(now_);}int Find(int now_) {Access(now_);Splay(now_);while (ls) now_ = ls;Splay(now_);return now_;}void Split(int x_, int y_) {Makeroot(x_);Access(y_);Splay(y_);}void Link(int x_, int y_) {Makeroot(x_);// fa[x_] = y_;if (Find(y_) != x_) fa[x_] = y_;}void Cut(int x_, int y_) {// Split(x_, y_);// fa[x_] = son[y_][0] = 0;// Pushup(y_);Makeroot(x_);if (Find(y_) != x_ || fa[y_] != x_ || son[y_][0]) return ;fa[y_] = son[x_][1] = 0;Pushup(x_);}int query(int x_) {Makeroot(x_);return sum[x_];}void Init() {for (int i = 1; i <= nodenum; ++ i) {val[i] = sum[i] = node[i].val;}for (int i = 1; i <= nodenum; ++ i) {if (next[i]) Link(i, next[i]);}}
}
void Init() {n = read(), m = read(), q = read();nodenum = n;for (int i = 1; i <= n; ++ i) {node[i] = (Node) {i, i, 1, m + 1, i};st.insert(node[i]);}for (int i = 1; i <= q; ++ i) {int opt = read();if (opt == 1) {int a = read(), b = read();Node u1 = *st.lower_bound((Node) {0, a, 0, b, 0});Node u2 = *st.lower_bound((Node) {0, a + 1, 0, b, 0});node[++ nodenum] = (Node) {nodenum, a, b + 1, u1.r, u1.val};node[++ nodenum] = (Node) {nodenum, a + 1, b + 1, u2.r, u2.val};node[u1.id].r = node[u2.id].r = b;node[u1.id].val = node[u2.id].val = 0;st.erase(st.lower_bound(u1)), st.erase(st.lower_bound(u2));st.insert(node[u1.id]), st.insert(node[u2.id]);st.insert(node[nodenum - 1]), st.insert(node[nodenum]);/*struct Node {int id, a, l, r, val;*/op[i] = (O) {1, a, b};} else {int a = read();op[i] = (O) {2, a, 0};}}for (std::set<Node>::iterator it = st.begin(); it != st.end(); ++ it) {std::set<Node>::iterator it1 = it;++ it1;if (it1 == st.end()) break;if (it->a != it1->a) continue;next[it->id] = it1->id;}LCT::Init();
}
void modify(int x_, int y_) {int u1 = st.lower_bound((Node) {0, x_, 0, y_, 0})->id;int u2 = st.lower_bound((Node) {0, x_ + 1, 0, y_, 0})->id;LCT::Cut(u1, next[u1]), LCT::Cut(u2, next[u2]);std::swap(next[u1], next[u2]);LCT::Link(u1, next[u1]), LCT::Link(u2, next[u2]);
}
int query(int x_) {return LCT::query(st.lower_bound((Node) {0, x_, 0, 0, 0})->id);
}
//=============================================================
int main() {// freopen("1.txt", "r", stdin);Init();for (int i = 1; i <= q; ++ i) {if (op[i].opt == 2) {printf("%d\n", query(op[i].a));} else {modify(op[i].a, op[i].b);}}return 0;
}

D 倍增，DP

唉唉这不比 A 简单？

写在最后

学到了什么：

  • A：转化为经典数据结构问题；LCT 通过维护虚子树，维护可加性的子树信息。
  • B：双变量函数，但是两个变量有线性关系——则双变量函数对于单变量为单峰/单谷。

然后是日常的夹带私货环节：

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Z-BlogPHP 模板文件与模板标签

Z-BlogPHP 模板文件与模板标签

在 Z-BlogPHP 中，模板文件和模板标签是非常重要的组成部分，用于生成前端页面。下面详细介绍 Z-BlogPHP 的模板文件结构和常用的模板标签。 模板文件结构 Z-BlogPHP 的模板文件通常位于 /zb_users/theme/你的主题名字/template/ 目录下。常见的模板文件包括：index.php：首页模…
阅读更多...
Z-Blog的安装与升级注意事项

Z-Blog的安装与升级注意事项

升级说明自动升级从下载页面下载最新版本的 Z-Blog 自动安装升级包。 解压缩安装包，并将包中文件上传至服务器。手动升级备份你的旧版 Z-Blog 程序到本地。 从下载页面下载最新版本的 Z-Blog 手动安装包。 解压缩安装包。 删除新版程序的 DATA 目录中的 zblog.mdb 文件，将旧数…
阅读更多...
主机安装zblog 无法登陆：错误原因:登录失败

主机安装zblog 无法登陆：错误原因:登录失败

当你遇到在主机上安装 ZBlog 后无法登录后台，并且收到“错误原因:登录失败”的提示时，可以尝试以下几种方法来解决问题：检查用户名和密码：确认你输入的用户名和密码是否正确，注意区分大小写。清除浏览器缓存和Cookies：清除浏览器中的缓存数据和Cookies，有时候这些数据可…
阅读更多...
CPU上下⽂切换是什么意思

CPU上下⽂切换是什么意思

什么是 CPU 上下文？ 多个进程竞争 CPU 会导致平均负载（ Load Average）升高，但是进程在竞争 CPU 的时候并没有真正运⾏，为什么还会导致系统的负载升⾼呢？原因就在于CPU 上下⽂切换。Linux 是⼀个多任务操作系统，它⽀持远⼤于 CPU 数量的任务同时运⾏。当然，这些任务实际…
阅读更多...
虚拟主机子目录安装了zblog 文章发布提示错误

虚拟主机子目录安装了zblog 文章发布提示错误

如果你在虚拟主机的一个子目录中安装了 Z-Blog，并且在发布文章时遇到错误提示，那么这个问题可能与文件路径、配置设置、权限或服务器环境有关。以下是一些可能的原因及解决方法： 1. 检查文件路径问题描述：文件路径配置不正确可能导致发布文章时出现问题。 解决方法：确认 c…
阅读更多...
《鸿蒙/Harmony | 开发日志》选择文件或拍照功能

《鸿蒙/Harmony | 开发日志》选择文件或拍照功能

鸿蒙系统提供无需用户授权的文件选择API，支持照片、视频和文件分类选择，具备临时只读权限，优化了安全性和用户体验。鸿蒙选择文件或拍照的功能，有直接可以用的 API，而且和Android相比，最大的好处，是不需要向用户索要文件权限。 不需要索要权限的原因是，鸿蒙的权限改动升…
阅读更多...
EF使用

EF使用

EF命令使用问题描述： PM> Add-Migration InitialCreate Add-Migration : 无法将“Add-Migration”项识别为 cmdlet、函数、脚本文件或可运行程序的名称。请检查名称的拼写，如果包括路径，请确保路径正确，然后再试一次。 所在位置 行:1 字符: 1 + Add-Migration InitialCr…
阅读更多...
hackmyvm Hades5变量劫持提权

hackmyvm Hades5变量劫持提权

在这个目录下有个./uid的程序分别运行./uid 和 id 发现我们在 uid一行是有不一样的我们猜测 在./uid里面他先用chown把我们的 uid改写成了anthea 然后运行id 然后再把我们的uid改回andromeda 那么我们怎么拿到这个anthea的权限呢这里就需要用到变量劫持的思想 如果我们把 id 这…
阅读更多...
SPDIF接口介绍

SPDIF接口介绍

SPDIF接口介绍 S/PDIF接口规范详解 S/PDIF是sony和philips在80年代为一般家用器材所定制出来的一种数字讯号传输接口，基本上是以AES/EBU(也称AES3)专业用数字接口为参考然后做了一些小变动而成的家用版本。 可以使用成本较低的硬件来实现数字讯号传输。为了定制一个统一的接口…
阅读更多...
通过 NSSM 把 FastAPI+Celery+Flower 注册成 3个Windos 服务

通过 NSSM 把 FastAPI+Celery+Flower 注册成 3个Windos 服务

通过 NSSM 把 FastAPI+Celery+Flower 注册成 3个Windos 服务 什么是 nssm？ 是一个服务封装程序，它可以将普通exe程序封装成服务，实现开机自启动，同类型的工具还有微软自己的srvany，不过nssm更加简单易用，并且功能强大。nssm官网 nssm 常用命令 nssm install servername /…
阅读更多...
zblogPHP后台时一切正常，但登出后再次登录提示“错误原因:登录失败；帐户和密码都是对的

zblogPHP后台时一切正常，但登出后再次登录提示“错误原因:登录失败；帐户和密码都是对的

当使用 Z-Blog PHP 后台时，如果登出后再次登录提示“错误原因:登录失败”，即使确认账户和密码输入正确，可能的原因包括 cookie 问题、缓存问题、数据库问题或配置问题等。以下是一些排查和解决此类问题的方法： 1. 清除浏览器缓存和 cookie问题描述：浏览器缓存或 cookie 可…
阅读更多...
想成为Admineloper？Salesforce全新职业解析，机会就在眼前！

想成为Admineloper？Salesforce全新职业解析，机会就在眼前！

每个Salesforce管理员在思考自己的职业生涯时，可能都会想到：下一步是往架构师，或者开发，还是咨询的方向发展。无论哪种职业规划，都需要培养新的技能。 由于角色职责、团队、客户需求等的变化，许多管理员在晋升之前就开始培养这种新技能。管理员可能需要学习Apex或利用现有…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023