Codeforces Pinely Round 3 (Div. 1 + Div. 2) A~F

A.Distinct Buttons(思维)

题意：

你在开始时站在点 ( 0 , 0 ) (0,0) (0,0)，同时，手上有一个遥控器，上面有四个按钮：

  • U:移动到 ( x , y + 1 ) (x, y + 1) (x,y+1)的位置

  • R:移动到 ( x + 1 , y ) (x + 1, y) (x+1,y)的位置

  • D:移动到 ( x , y − 1 ) (x, y - 1) (x,y−1)的位置

  • L:移动到 ( x − 1 , y ) (x - 1, y) (x−1,y)的位置

如果四个按钮都被按下过，那么遥控器将会被损坏，问能否到达给出的所有 n n n个点。

分析：

如果只能使用三个按键，那么只有在需要到达的所有点均在以下四个面中的一个时才能完成：

  • 所有点都在 x x x轴上方

  • 所有点都在 x x x轴下方

  • 所有点都在 y y y轴左侧

  • 所有点都在 y y y轴右侧

输入时使用数组记录出现的位置，最后判断输出即可。

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;

void solve() {
    int n;
    cin >> n;
    int a[5] = {0, 0, 0, 0};
    for (int i = 0; i < n; i++) {
        int x, y;
        cin >> x >> y;
        if (x > 0) {
            a[0] = 1;
        } else if (x < 0) {
            a[1] = 1;
        }
        if (y > 0) {
            a[2] = 1;
        } else if (y < 0) {
            a[3] = 1;
        }
    }
    if (a[0] + a[1] + a[2] + a[3] > 3) cout << "No" << endl;
    else cout << "Yes" << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

B.Make Almost Equal With Mod(思维)

题意：

给出一个数组 a 1 , a 2 , . . . , a n a_1, a_2, ..., a_n a1​,a2​,...,an​，你可以选择一个数字 k k k，使数组中所有数字对 k k k取模，问 k k k等于多少时，可以使得数组中的数字再操作后恰好包含两种不同的数字。

分析：

依次枚举 2 2 2的次方数即可。

说明：

  • 选择 2 2 2作为 k k k时，剩下的结果仅包含 0 , 1 0, 1 0,1

  • 如果剩下的数字全部为 0 0 0或 1 1 1，继续选择 2 2 = 4 2^2 = 4 22=4作为 k k k，若选择 2 2 2时剩下的数字为 0 0 0，那么选择 k = 4 k = 4 k=4时剩下的就是 0 , 2 0, 2 0,2，同理，剩下数字均为 1 1 1，则选择 k = 4 k = 4 k=4时剩下的数字就是 1 , 3 1, 3 1,3。

  • 依此类推，由于每次取模的结果只会有两种可能性，那么当结果中两种情况均出现就找到了合法的 k k k。

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;

LL a[MAXN];

void solve() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (LL i = 2; ; i <<= 1) {
        set<LL> S;
        for (int j = 1; j <= n; j++) {
            S.insert(a[j] % i);
            if (S.size() > 2) break;
        }
        if (S.size() == 2) {
            cout << i << endl;
            return;
        }
    }
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

C.Heavy Intervals(思维)

题意：

给出 n n n个区间 [ l i , r i ] [l_i, r_i] [li​,ri​]，每个区间包含一个权值 c i c_i ci​，且区间的价值为: c i × ( r i − l i ) c_i \times (r_i - l_i) ci​×(ri​−li​)，你可以在保证区间合法 ( l i < r i ) (l_i < r_i) (li​<ri​)的情况下，对所有区间的 l i , r i , c i l_i, r_i, c_i li​,ri​,ci​进行任意重排，问所有区间的价值之和最小是多少？

分析：

既然要让价值之和最小，那么大的权值 c i c_i ci​就要与长度更小的区间匹配，那要怎么在保证区间合法的情况下，让构造的区间尽可能长呢？

可以使用类似括号匹配的思想，先对 l i l_i li​和 r i r_i ri​进行排序，把 l i l_i li​和 r i r_i ri​视为左右括号进行括号匹配，并将构造成的区间长度记录下来。

完成匹配后，对权值 c i c_i ci​和构造的区间长度 l e n len len进行排序，并按最大的权值和最小的区间长度进行匹配，次大的权值和次小的区间长度进行匹配，依次类推，就能得到最小的价值之和。

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;

LL l[MAXN], r[MAXN], c[MAXN], len[MAXN];

stack<int> st;

void solve() {
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> l[i];
    }
    for (int i = 0; i < n; i++) {
        cin >> r[i];
    }
    for (int i = 0; i < n; i++) {
        cin >> c[i];
    }
    sort(l, l + n);
    sort(r, r + n);
    sort(c, c + n);
    int pos_l = 0, pos_r = 0, cnt = 0;
    for (int i = 0; i < n * 2; i++) {
        if (pos_l < n && pos_r < n) {
            if (l[pos_l] < r[pos_r]) {
                st.push(l[pos_l++]);
            } else {
                len[cnt++] = r[pos_r++] - st.top();
                st.pop();
            }
        } else {
            len[cnt++] = r[pos_r++] - st.top();
            st.pop();
        }
    }
    LL ans = 0;
    sort(len, len + n);
    for (int i = 0, j = n - 1; i < n; i++, j--) {
        ans += len[i] * c[j];
    }
    cout << ans << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

D.Split Plus K(思维)

题意：

给出 n n n个正整数 a 1 , a 2 , . . . , a n a_1, a_2, ..., a_n a1​,a2​,...,an​，你可以进行若干次以下操作：

  • 选择一个数字 x x x，并将这个数字删除。

  • 选择两个正整数 y , z y, z y,z满足 y + z = x + k y + z = x + k y+z=x+k，并将这两个数字放回。

问：能否在经过若干次操作后，使数组中所有数字相同，如果可以，输出最少操作次数，否则，输出-1.

分析：

由于每次产生的两个数字 y , z y, z y,z的总和会比原本的数字 x x x大 k k k，因此，如果一个数字被分解了 m m m次，那么得到的 m + 1 m + 1 m+1个数字的总和就是 x + m × k x + m \times k x+m×k。

令 b 0 , b 1 , . . . , b m b_0, b_1, ..., b_m b0​,b1​,...,bm​为最后生成的 m + 1 m + 1 m+1个数字，由于分解时会增加 k k k，且会增加 m m m次，那么可以将 m m m个 k k k分配给 b 1 ∼ b m b_1 \sim b_m b1​∼bm​，即最后生成的数字为 b 0 , b 1 + k , b 2 + k , . . . , b m + k b_0, b_1 + k, b_2 + k, ..., b_m + k b0​,b1​+k,b2​+k,...,bm​+k。

由题目可得以下两个式子：

  • b 0 = b 1 + k = . . . = b m + k b_0 = b_1 + k = ... = b_m + k b0​=b1​+k=...=bm​+k

  • b 0 + ( b 1 + k ) + . . . + ( b m + k ) = a i + m × k b_0 + (b_1 + k) + ... + (b_m + k) = a_i + m \times k b0​+(b1​+k)+...+(bm​+k)=ai​+m×k

由于无法知道最后分解出的数字数量 m m m到底是多少，因此需要对式子进行化简，让第二个式子两边同时减去 m + 1 m + 1 m+1个 k k k，可得：

  • b 0 − k = b 1 = . . . = b m b_0 - k = b_1 = ... = b_m b0​−k=b1​=...=bm​

  • ( b 0 − k ) + b 1 + . . . + b m = a i − k (b_0 - k) + b_1 + ... + b_m = a_i - k (b0​−k)+b1​+...+bm​=ai​−k

而此时所有的 b 1 ∼ b m b_1 \sim b_m b1​∼bm​以及 b 0 − k b_0 - k b0​−k均为 a i − k a_i - k ai​−k的因子，因此，可以在输入后，将所有 a i a_i ai​均减去 k k k。

然后，需要考虑，如果减去 k k k后的 a a a数组中出现了同时包含正负数或同时出现 0 0 0和其他数字，此时是无法完成构造的，直接输出 − 1 -1 −1。

最后考虑最后生成的数字，既然要让操作次数尽可能少，那么拆出的数字就要尽可能大，怎么选择最大的结果呢？只有选择减去 k k k之后的所有 a i − k a_i - k ai​−k的最大公约数 G G G。

由于每次操作会增加一个数字，因此，将 a i − k a_i - k ai​−k分解为若干个 G G G所需的操作次数为 a i − k G − 1 \frac{a_i - k}{G} - 1 Gai​−k​−1。

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;

LL n, k, a[MAXN];

void solve() {
    cin >> n >> k;
    LL maxn = -1e18, minn = 1e18;
    for (int i = 1; i <= n; i++) cin >> a[i], a[i] -= k, maxn = max(maxn, a[i]), minn = min(minn, a[i]);
    if (maxn == minn) {
        cout << 0 << endl;
        return;
    }
    if (minn < 0 && maxn >= 0 || minn == 0 && maxn > 0) {
        cout << "-1" << endl;
        return;
    }
    LL g = a[1];
    for (int i = 2; i <= n; i++) g = __gcd(g, a[i]);
    LL ans = 0;
    for (int i = 1; i <= n; i++) {
        ans += a[i] / g - 1;
    }
    cout << ans << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

E.Multiple Lamps(二进制)

题意：

现有 n n n盏灯，编号为 1 1 1到 n n n。一开始，所有的灯都是关闭的。

有 n n n个按钮。第 i i i个按钮控制所有编号为 i i i的倍数的灯。当一个灯其对应的按钮被使用时，如果它是关闭的，它将打开；如果它是打开的，它将关闭。

必须按照以下规则按一些按钮：

  • 至少要按一个按钮。
  • 不能多次按同一按钮。
  • 有 m m m个数对 ( u i , v i ) (u_i,v_i) (ui​,vi​)，如果按下按钮 u i u_i ui​，必须同时按下按钮 v i v_i vi​（不一定是在按下按钮 u i u_i ui​之后）。如果按下按钮 v i v_i vi​，则不需要按按钮 u i u_i ui​。

为了环保，请按下一些按钮，使其最后最多点亮 ⌊ n 5 ⌋ ⌊\frac{n}{5}⌋ ⌊5n​⌋盏灯，否则输出 − 1 −1 −1。

分析：

如果按下所有的按钮，灯 i i i就会被 i i i的所有因数各操作一次，所以如果 i i i有奇数个因数，灯 i i i最终就会是亮的。对于这种情况，当 ⌊ n ⌋ ≤ ⌊ n / 5 ⌋ ⌊\sqrt{n}⌋ \le ⌊n/5⌋ ⌊n ​⌋≤⌊n/5⌋，即当 20 ≤ n 20 \le n 20≤n时，按下所有按钮即可。

当 n ≤ 19 n \le 19 n≤19时，最多打开 ⌊ 19 5 ⌋ = 3 ⌊\frac{19}{5}⌋=3 ⌊519​⌋=3盏灯。可以从 1 1 1到 n n n遍历按钮，当且仅当灯 i i i处于错误状态时按下按钮 i i i。最多会遍历 3 3 3个灯的所有子集，并检查相应的按钮选择是否有效(即 m m m约束成立)。可以通过打表预处理出来，然后进行 c h e c k check check。

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 2e5 + 5;
vector<int> arr[20];
int st[20];
int n, m;
int a[MAXN], b[MAXN];

int lowbit(int x) {
    return x & (-x);
}

void init() {
    for (int i = 5; i <= 19; i++) {
        for (int j = 1; j < (1 << i); j++) {
            for (int k = j; k; k ^= lowbit(k)) {
                int x = __builtin_ctz(k) + 1;
                for (int y = x; y <= i; y += x)
                    st[y] ^= 1;
            }
            int sum = 0;
            for (int k = 1; k <= i; k++) {
                sum += st[k], st[k] = 0;
            }
            if (sum * 5 <= i)
                arr[i].push_back(j);
        }
    }
}

bool solve() {
    for (int i: arr[n]) {
        i <<= 1;
        bool f = 0;
        for (int j = 1; j <= m; j++) {
            f |= (i & (1 << a[j])) && !(i & (1 << b[j]));
        }
        if (f)
            continue;
        cout << __builtin_popcount(i) << endl;
        while (i) {
            cout << __builtin_ctz(i) << ' ';
            i ^= lowbit(i);
        }
        cout << endl;
        return 1;
    }
    return 0;
}

int main() {
    init();
    int T;
    cin >> T;
    while (T--) {
        cin >> n >> m;
        for (int i = 1; i <= m; i++) {
            cin >> a[i] >> b[i];
        }
        if (n >= 20) {
            cout << n << endl;
            for (int i = 1; i <= n; i++)
                cout << i << ' ';
            cout << endl;
            continue;
        }
        if (!solve())
            cout << "-1" << endl;
    }
}

F1.Small Permutation Problem(Easy Version)(DP)

题意：

给定一个整数 n n n和一个数组 a 1 , a 2 , … , a n a_1,a_2,…,a_n a1​,a2​,…,an​，数据范围为 [ 0 , n ] [0,n] [0,n]。

对于每个 i i i，若满足以下条件，则 p 1 , p 2 , … , p n ( [ 1 , 2 , … , n ] ) p_1,p_2,…,p_n([1,2,…,n]) p1​,p2​,…,pn​([1,2,…,n])是一个好的排列：

当 a i ≠ − 1 a_i≠−1 ai​=−1时，在 [ p 1 , p 2 , … , p i ] [p_1,p2,…,p_i] [p1​,p2,…,pi​]中小于等于 i i i的数的个数恰好为 a i a_i ai​。

计算 [ 1 , 2 , … , n ] [1,2,…,n] [1,2,…,n]中好的排列的个数，结果对 998244353 998244353 998244353取模。

分析：

本题为动态规划的思想，设 d p i dp_i dpi​表示前 i i i个位置填充了 a i a_i ai​个小于等于 i i i的元素的方案数量。因为 a i a_i ai​和 a i − 1 a_{i-1} ai−1​的关系只有可能为 0 , 1 , 2 0,1,2 0,1,2。故本题总共可分为三种情况讨论：

  • 若 a i = a i + 1 a_i=a_{i+1} ai​=ai+1​，则 d p i = d p i + 1 dp_i=dp_{i+1} dpi​=dpi+1​
  • 若 a i = a i + 1 + 1 a_i=a_{i+1}+1 ai​=ai+1​+1，则需要填入一个小于等于 i i i的数字，有两种方案：方案1：在前 i i i个位置填入 i i i数字，可以填入的方法有 ( i − 1 ) − a i − 1 + 1 (i-1)-a_{i-1}+1 (i−1)−ai−1​+1；方案2：在第 i i i个位置填写一个小于 i i i的数字，可以将 i i i或者之前未填写的小于等于 i i i的数字填入，可以填入的数字有 i − 1 − a i − 1 i-1-a_{i-1} i−1−ai−1​个
  • 若 a i = a i + 1 + 2 a_i=a_{i+1}+2 ai​=ai+1​+2，则需要在前 i − 1 i-1 i−1个位置放数字 i i i，在第 i i i个位置放一个小于 i i i的数字

将上述三种情况分别考虑，遍历即可获得答案，注意需要特判 a n a_n an​，若不为 n n n，则直接输出 0 0 0。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const LL MOD = 998244353;

int n;
LL a[200010];

void solve() {
    cin >> n;
    for (int i = 1; i < n + 1; i++) {
        cin >> a[i];
    }
    if (a[1] > 1) {
        printf("0\n");
        return;
    }
    vector<LL> dp(n + 1, 0);
    dp[1] = 1;

    for (int i = 2; i < n + 1; i++) {
        if (a[i] == a[i - 1]) {
            dp[i] = dp[i - 1];
        } else if (a[i] == a[i - 1] + 1 and a[i] <= i) {
            (dp[i] += dp[i - 1] * ((i - 1) - a[i - 1] + 1)) %= MOD;
            (dp[i] += dp[i - 1] * ((i - 1) - a[i - 1])) %= MOD;
        } else if (a[i] == a[i - 1] + 2 and a[i] <= i) {
            (dp[i] += dp[i - 1] * ((i - 1) - a[i - 1]) % MOD * ((i - 1) - a[i - 1]) % MOD) %= MOD;
        }
    }
    if (a[n] == n) {
        cout << dp[n] << endl;
    } else {
        cout << 0 << endl;
    }
}

int main() {
    int t;
    cin >> t;
    while (t--)
        solve();
    return 0;
}

F2.Small Permutation Problem(Hard Version)(数学)

分析：

对于 F 2 F2 F2：将题目的点想象成一个 n × n n \times n n×n的图，排列中第 i i i个数为 p i p_i pi​时，即可视为选中了 ( i , p i ) (i,p_i) (i,pi​)这个点。

题目条件对 a i a_i ai​的限制，就可以看成是在左上角 i × i i \times i i×i的矩阵中，选了 a i a_i ai​个点

因为有一些位置是 − 1 -1 −1，所以直接找到前一个限制的位置 l a s las las。初始时，可以令 l a s = 0 las=0 las=0， a l a s = 0 a_{las}=0 alas​=0，上一个约束处是 l a s las las，限制为 a l a s a_{las} alas​。当前约束处是 i i i，限制为 a i a_i ai​。

这样处理后可以发现出现一个 L L L形区域可以选点，这部分需要选 v = a i − a l a s v=a_i-a_{las} v=ai​−alas​个点，

如图， w 1 = i − l a s w_1=i-las w1​=i−las， h 1 = l a s − a l a s h_1=las-a_{las} h1​=las−alas​， h 2 = i − l a s h_2=i-las h2​=i−las， w 2 = i − a l a s w_2=i-a_{las} w2​=i−alas​。

枚举 w 1 × h 1 w_1 \times h_1 w1​×h1​这个矩阵中，选了 k k k个点，这 k k k个点选了之后，同行同列不能再选点。

那么对于下面的部分就还剩 h 2 × ( w 2 − k ) h_2 \times (w_2-k) h2​×(w2​−k)这个矩阵，需要选剩下的 v − k v-k v−k个点，可以从 0 0 0枚举到 a i − a l a s a_i-a_{las} ai​−alas​枚举这个 k k k，因为邻相差之和最终等于 n n n，所以复杂度是 O ( n ) O(n) O(n)

对于一个 h × w h \times w h×w的矩阵，在其中选择 k k k个点的方案是： C ( h , k ) × C ( w , k ) × k ! C(h,k) \times C(w,k) \times k! C(h,k)×C(w,k)×k!，即先选择 k k k个横坐标在哪，再选择 k k k个纵坐标在哪，再将纵坐标顺序打乱拼到横坐标上。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;

const int MAXN = 2e5 + 5;
const LL MOD = 998244353;

inline LL qpow(LL b, LL p) {
    LL res = 1;
    while (p) {
        if (p & 1) {
            res = res * b % MOD;
        }
        b = b * b % MOD;
        p >>= 1;
    }
    return res;
}

LL n, fac[MAXN], a[MAXN], ifac[MAXN];

LL A(LL n, LL m) {
    if (n < m || n < 0 || m < 0) {
        return 0;
    } else {
        return fac[n] * ifac[n - m] % MOD;
    }
}

LL C(LL n, LL m) {
    if (n < m || n < 0 || m < 0) {
        return 0;
    } else {
        return fac[n] * ifac[m] % MOD * ifac[n - m] % MOD;
    }
}

LL sum1(LL n, LL m) {
    return C(n, m) * A(n, m) % MOD;
}

void solve() {
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    fac[0] = 1;
    for (int i = 1; i <= n; ++i) {
        fac[i] = fac[i - 1] * i % MOD;
    }
    ifac[n] = qpow(fac[n], MOD - 2);
    for (int i = n - 1; ~i; --i) {
        ifac[i] = ifac[i + 1] * (i + 1) % MOD;
    }
    a[0] = 0;
    if (a[n] != -1 && a[n] != n) {
        cout << "0" << endl;
        return;
    }
    a[n] = n;
    int j = 0;
    LL ans = 1;
    for (int i = 1; i <= n; ++i) {
        if (a[i] != -1) {
            int t = a[i] - a[j], x = j - a[j], y = i - a[j];
            if (t < 0) {
                cout << "0" << endl;
                return;
            }
            LL res = 0;
            for (int i = 0; i <= x && i <= t; ++i) {
                res = (res + ((i & 1) ? MOD - 1 : 1) * sum1(x, i) % MOD * sum1(y - i, t - i)) % MOD;
            }
            ans = ans * res % MOD;
            j = i;
        }
    }
    cout << ans << endl;
}

int main() {
    int T;
    cin >> T;
    while (T--) {
        solve();
    }
    return 0;
}

学习交流

​
以下为学习交流QQ群，群号： 546235402，每周题解完成后都会转发到群中，大家可以加群一起交流做题思路，分享做题技巧，欢迎大家的加入。
​

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

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

相关文章

【《设计模式之美》】如何取舍继承与组合

【《设计模式之美》】如何取舍继承与组合

文章目录 什么情况下不推荐使用继承&#xff1f;组合相比继承有哪些优势&#xff1f;使用组合、继承的时机 本文主要想了解&#xff1a; 为什么组合优于继承&#xff0c;多用组合少用继承。如何使用组合来替代继承哪些情况适用继承、组合。有哪些设计模式使用到了继承、组合。 …
阅读更多...
数据分析-23--糖尿病预测（线性回归模型）（包含数据代码）

数据分析-23--糖尿病预测（线性回归模型）（包含数据代码）

文章目录 0. 数据代码下载1. 项目介绍2. 数据处理1. 导入数据2. 处理数据 3. 建立模型4. 考察单个特征 0. 数据代码下载 关注公众号&#xff1a;『AI学习星球』 回复&#xff1a;糖尿病预测 即可获取数据下载。 算法学习、4对1辅导、论文辅导或核心期刊可以通过公众号或➕v&am…
阅读更多...
软件测试/测试开发丨Python学习笔记之基本数据类型与操作

软件测试/测试开发丨Python学习笔记之基本数据类型与操作

一、变量 1、变量的定义&#xff1a; a. 在python中&#xff0c;变量是一种存储数据的载体。计算机中的变量是实际存在的数据或者说是存储器中存储数据的一块内存空间&#xff1b; b.变量的值可以被读取和修改。 2、命名规则&#xff1a; a.变量名由字母&#xff08;广义的Unic…
阅读更多...
Appium+python自动化（一）- 环境搭建—上（超详解）

Appium+python自动化（一）- 环境搭建—上（超详解）

简介 今天是高考各地由于降水&#xff0c;特别糟糕&#xff0c;各位考生高考加油&#xff0c;全国人民端午节快乐。最近整理了一下自动化的东西&#xff0c;先前整理的python接口自动化已经接近尾声。即将要开启新的征程和篇章&#xff08;Appium&python&#xff09;。那么…
阅读更多...
Python五子棋程序实现详解

Python五子棋程序实现详解

Python五子棋程序实现详解 引言功能实现显示棋盘点击落子判断胜负游戏结束判断交替落子 运行结果完整代码总结 引言 五子棋是一种广泛传播的策略棋类游戏&#xff0c;两人对弈&#xff0c;通过在棋盘上落子&#xff0c;以先形成连续的相同颜色的五子棋为胜利条件。本文将介绍如…
阅读更多...
JavaScript基础知识点总结：从零开始学习JavaScript（四）

JavaScript基础知识点总结：从零开始学习JavaScript（四）

学习目标&#xff1a; 掌握函数的基本使用&#xff0c;让代码具备复用能力 理解封装的意义&#xff0c;能够具备封装函数的能力 学习内容&#xff1a; 函数 综合案例 学习时间&#xff1a; 周一至周五晚上 7 点—晚上9点周六上午 9 点-上午 11 点周日下午 3 点-下午 6 点 学…
阅读更多...
【零成本实现接口自动化测试】Java+TestNG 测试Restful service

【零成本实现接口自动化测试】Java+TestNG 测试Restful service

接口自动化测试 – JavaTestNG 测试 Restful Web Service 关键词&#xff1a;基于Rest的Web服务&#xff0c;接口自动化测试&#xff0c;数据驱动测试&#xff0c;测试Restful Web Service&#xff0c; 数据分离&#xff0c;JavaMavenTestNG 本文主要介绍如何用Java针对Restf…
阅读更多...
金蝶云星空反写规则表结构同步另一个数据库

金蝶云星空反写规则表结构同步另一个数据库

文章目录 金蝶云星空反写规则表结构同步另一个数据库在BOS找到《反写规则》的表反写规则相关表创建反写规则&#xff0c;或者已经创建好的反写规则定位反写规则数据导出表数据执行脚本BOS导入数据库直接执行 金蝶云星空反写规则表结构同步另一个数据库 在BOS找到《反写规则》的…
阅读更多...
k8s 网络

k8s 网络

还没有部署网络。 k8s的网络类型&#xff1a; k8s中的通信模式&#xff1a; 1&#xff0c;pod内部之间容器和容器之间的通信。 在同一个pod中的容器共享资源和网络&#xff0c;使用同一个网络命名空间。可以直接通信的。 2&#xff0c;同一个node节点之内不同pod之间的通信。…
阅读更多...
香橙派5plus从ssd启动Ubuntu

香橙派5plus从ssd启动Ubuntu

官方接口图 我实际会用到的就几个接口&#xff0c;背面的话就一个M.2固态的位置&#xff1a; 其中WIFI模块的接口应该也可以插2230的固态&#xff0c;不过是pcie2.0的速度&#xff0c;背面的接口则是pcie3.0*4的速度&#xff0c;差距还是挺大的。 开始安装系统 准备工作 一张…
阅读更多...
开源轻量级分布式文件系统FastDFS本地部署并实现远程访问服务器

开源轻量级分布式文件系统FastDFS本地部署并实现远程访问服务器

文章目录 前言1. 本地搭建FastDFS文件系统1.1 环境安装1.2 安装libfastcommon1.3 安装FastDFS1.4 配置Tracker1.5 配置Storage1.6 测试上传下载1.7 与Nginx整合1.8 安装Nginx1.9 配置Nginx 2. 局域网测试访问FastDFS3. 安装cpolar内网穿透4. 配置公网访问地址5. 固定公网地址5.…
阅读更多...
算法学习系列（十三）：Trie树

算法学习系列（十三）：Trie树

目录 引言一、Trie概念二、Trie树模板三、例题 引言 这个Trie还是比较有用的&#xff0c;主要的功能就是高效的存储和查找字符串的数据结构。 一、Trie概念 假设这个Trie只存储小写字母的话&#xff1a; 这个大概就是这么个概念&#xff0c;就是头结点是0号&#xff0c;然后…
阅读更多...
使用腾讯云轻量应用服务器基于SRS搭建个人直播间

使用腾讯云轻量应用服务器基于SRS搭建个人直播间

使用腾讯云轻量应用服务器基于SRS音视频服务器应用模板镜像即可一键搭建个人直播间&#xff0c;SRS Stack让你一键拥有自己的视频云解决方案&#xff0c;可以在云上或私有化部署&#xff0c;支持丰富的音视频协议&#xff0c;提供鉴权、私人直播间、多平台转播、录制、虚拟直播…
阅读更多...
js中变量的使用

js中变量的使用

文章目录 一、变量二、声明三、赋值四、更新变量五、声明多个变量(不推荐)六、变量的本质七、关键字八、变量名命名规则 一、变量 理解变量是计算机存储数据的“容器”&#xff0c;掌握变量的声明方式 白话&#xff1a;变量就是一个装东西的盒子。通俗&#xff1a;变量是计算机…
阅读更多...
【MySQL学习笔记007】约束

【MySQL学习笔记007】约束

1、概述 &#xff08;1&#xff09;概念&#xff1a;约束是作用于表中字段上的规则&#xff0c;用于限制存储在表中的数据。 &#xff08;2&#xff09;目的&#xff1a;保证数据库中数据的正确、有效性和完整性。 &#xff08;3&#xff09;分类 约束 描述 关键字 …
阅读更多...
ZStack Cube超融合一体机助力电子支付企业升级改造

ZStack Cube超融合一体机助力电子支付企业升级改造

电子支付服务企业实壹信息通过ZStack Cube超融合一体机为业务生产环境构建新一代云基础设施&#xff0c;结合V2V迁移模块实现ZStack社区版云平台应用迁移到全新的云基础设施ZStack Cube 超融合一体机上&#xff0c;同时共享分布式存储和外接FC-SAN存储。此外&#xff0c;运维人…
阅读更多...
Android 8.1 设置USB传输文件模式（MTP）

Android 8.1 设置USB传输文件模式（MTP）

项目需求&#xff0c;需要在电脑端adb发送通知手机端接收指令&#xff0c;将USB的仅充电模式更改成传输文件&#xff08;MTP&#xff09;模式&#xff0c;便捷用户在我的电脑里操作内存文件&#xff0c;下面是我们的常见的修改方式 1、android12以下、android21以上是这种方式…
阅读更多...
Elasticsearch：在不停机的情况下优化 Elasticsearch Reindex

Elasticsearch：在不停机的情况下优化 Elasticsearch Reindex

实现零停机、高效率和成功迁移更新的指南。更多阅读&#xff1a;Elasticsearch&#xff1a;如何轻松安全地对实时 Elasticsearch 索引 reindex 你的数据。 在使用 Elasticsearch 的时候&#xff0c;总会有需要修改索引映射的时候&#xff0c;遇到这种情况&#xff0c;我们只能做…
阅读更多...
go语言，ent库与gorm库，插入一条null值的time数据

go语言，ent库与gorm库，插入一条null值的time数据

情景介绍 使用go语言&#xff0c;我需要保存xxxTime的字段至数据库中&#xff0c;这个字段可能为空&#xff0c;也可能是一段时间。我采取的是统一先赋值为空&#xff0c;若有需要&#xff0c;则再进行插入&#xff08;需要根据另一个字段判断是否插入&#xff09; 在我的数据…
阅读更多...
PTS 3.0：可观测加持的下一代性能测试服务

PTS 3.0：可观测加持的下一代性能测试服务

作者&#xff1a;肖长军&#xff08;穹谷&#xff09; 大家好&#xff0c;我是来自阿里云云原生应用平台的肖长军&#xff0c;花名穹谷&#xff0c;我此次分享的主题是《可观测加持的下一代性能测试服务》。提到性能测试大家并不陌生&#xff0c;性能测试已成为评估系统能力、…
阅读更多...
最新文章

Copyright @ 2022~2023