【多校训练】2022杭电多校4补题

已于 2023-07-08 07:41:56 修改
阅读量236 收藏
点赞数
分类专栏： # 多校训练 文章标签： 算法
于 2023-06-21 22:19:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30320171/article/details/131311543
版权

官方数据和标程：2022杭电多校资料包

目录

难度评价

中后段题目跨度很大的一场。
7题一百名，5题快两百名，4题四百名。至少补到6题，金牌补到8题以上。
D、F、G、K签到，A、B、C中等，E困难，H、I、J大难。

A. Link with Bracket Sequence II

DP

待补

B. Link with Running

图论

显然直接跑最短路即可得到答案1，最短路图是一个DAG，在DAG上跑最长路（拓扑排序递推DP）即可求得答案2。
然而本题边权可能为0，这意味着在dijkstra中，即使一个点 u u u 已被访问过，如果对边 ( v → u , w = 0 ) (v \rightarrow u,w=0) (v→u,w=0) 有 d [ v ] + 0 = = d [ u ] d[v]+0==d[u] d[v]+0==d[u]，则它也应该出现在最短路图中。由此可以发现最短路图可能存在0环，即它不是DAG。

在这里插入图片描述
如图，对应的图中存在0环，且该图直接等价于其最短路图。因为不是DAG，所以不能DP求最长路，如果尝试大力跑SPFA最长路会喜提TLE，dijkstra跑最长路会直接WA。因此需要先缩点成DAG，再跑拓扑排序。

注：题目保证答案存在且不为无穷大，说明如果在1到n的路径上有0环，则第二权值 p p p 也一定全为0；如果该0环不在1到n的路径上，则对答案无影响。

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

constexpr int MAXN = 1e5 + 5;
using tpl = tuple<int, int, int>;
using PII = pair<int, int>;
vector<tpl> G[MAXN], T[MAXN], E[MAXN];
int n, m, d[MAXN], low[MAXN], num[MAXN], c[MAXN], in[MAXN], dfn, cnt;
bool vis[MAXN], inst[MAXN];
stack<int> st;

void dijkstra(int s = 1)
{
    fill(vis + 1, vis + n + 1, 0);
    fill(d + 1, d + n + 1, 1e18);
    d[s] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> q;
    q.emplace(0, s);
    while (!q.empty())
    {
        auto [_, v] = q.top();
        q.pop();
        if (vis[v])
            continue;
        vis[v] = 1;

        for (auto [u, w, p] : G[v])
            if (d[v] + w < d[u])
                d[u] = d[v] + w, q.emplace(d[u], u);
    }
    for (int v = 1; v <= n; v++)
        for (auto [u, w, p] : G[v])
            if (d[v] + w == d[u])
                T[v].emplace_back(u, w, p);
}

void tarjan(int v)
{
    low[v] = num[v] = ++dfn;
    st.push(v), inst[v] = 1;
    for (auto [u, w, p] : T[v])
    {
        if (!num[u])
        {
            tarjan(u);
            low[v] = min(low[v], low[u]);
        }
        else if (inst[u])
            low[v] = min(low[v], num[u]);
    }
    if (num[v] == low[v])
    {
        ++cnt;
        int z;
        do
        {
            z = st.top(), st.pop(), inst[z] = 0;
            c[z] = cnt;
        } while (v != z);
    }
}

void connect()
{
    for (int v = 1; v <= n; v++)
        for (auto [u, w, p] : T[v])
            if (c[v] != c[u])
                E[c[v]].emplace_back(c[u], w, p), ++in[c[u]];
}

int topoSort()
{
    vector<int> dp(cnt + 1);
    queue<int> q;
    for (int i = 1; i <= cnt; i++)
        if (in[i] == 0)
            q.push(i);
    while (!q.empty())
    {
        int v = q.front();
        q.pop();
        for (auto [u, w, p] : E[v])
        {
            dp[u] = max(dp[u], dp[v] + p);
            if (--in[u] == 0)
                q.push(u);
        }
    }
    return dp[c[n]];
}

void clear()
{
    dfn = cnt = 0;
    fill(num + 1, num + n + 1, 0);
    for (int i = 1; i <= n; i++)
        G[i].clear(), T[i].clear(), E[i].clear();
}

int32_t main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t;
    cin >> t;
    while (t--)
    {
        cin >> n >> m;
        while (m--)
        {
            int x, y, w, p;
            cin >> x >> y >> w >> p;
            G[x].emplace_back(y, w, p);
        }
        dijkstra();
        for (int i = 1; i <= n; i++)
            if (!num[i])
                tarjan(i);
        connect();
        cout << d[n] << " " << topoSort() << endl;
        clear();
    }

    return 0;
}

C. Magic

图论

比较明显的差分约束，容易想到用前缀和 a [ i ] a[i] a[i] 表示前 i i i 个位置放的魔法原料之和，则不等式组为
{ a [ m i n ( n , i + k − 1 ) ] − a [ m a x ( 0 , i − k ) ] ≥ p i ( 1 ) a [ R j ] − a [ L j − 1 ] ≤ B j ( 2 ) a [ i ] − a [ i − 1 ] ≥ 0 ( 3 ) \begin{cases} a[min(n,i+k-1)]-a[max(0,i-k)] \geq p_i & (1) \\ a[R_j]-a[L_j-1] \leq B_j & (2)\\ a[i]-a[i-1] \geq 0 & (3)\\ \end{cases} ⎩ ⎨ ⎧​a[min(n,i+k−1)]−a[max(0,i−k)]≥pi​a[Rj​]−a[Lj​−1]≤Bj​a[i]−a[i−1]≥0​(1)(2)(3)​
其中 ( 1 ) (1) (1) 代表位置 i i i 的魔力值要大于 p i p_i pi​， ( 2 ) (2) (2) 代表第 j j j 个约束条件所规定的区间 [ L j , R j ] [L_j,R_j] [Lj​,Rj​] 內的原料之和不能多于 B j B_j Bj​， ( 3 ) (3) (3) 是容易遗漏的条件，代表每个位置的原料数必须非负。
因为要求最小值，建出图后跑spfa最长路即可，有正环无解。

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

constexpr int MAXN = 1e4 + 5;
vector<pair<int, int>> G[MAXN];
int n, k, q, cnt[MAXN], d[MAXN];
bool inq[MAXN];

bool spfa(int s = 0)
{
    fill(d, d + n + 1, -1e9);
    fill(inq, inq + n + 1, 0);
    fill(cnt, cnt + n + 1, 0);
    queue<int> q;
    q.push(s);
    d[s] = 0, cnt[s]++, inq[s] = 1;
    while (!q.empty())
    {
        int v = q.front();
        q.pop();
        inq[v] = 0;
        for (auto [u, w] : G[v])
        {
            if (d[u] < d[v] + w)
            {
                d[u] = d[v] + w;
                if (!inq[u])
                {
                    q.push(u);
                    if (++cnt[u] > n)
                        return 1;
                    inq[u] = 1;
                }
            }
        }
    }
    return 0;
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t;
    cin >> t;
    while (t--)
    {
        cin >> n >> k;
        for (int i = 1, p; i <= n; i++)
        {
            cin >> p;
            G[max(0, i - k)].emplace_back(min(n, i + k - 1), p); // a[min(n, i+k-1)] - a[max(0, i-k)] >= p
        }
        cin >> q;
        while (q--)
        {
            int l, r, b;
            cin >> l >> r >> b;
            G[r].emplace_back(l - 1, -b); // a[r] - a[l-1] <= b
        }
        for (int i = 1; i <= n; i++)
        {
            G[i - 1].emplace_back(i, 0); // a[i] - a[i-1] >= 0
            G[0].emplace_back(i, 0);
        }
        cout << (spfa() ? -1 : d[n]) << "\n";
        for (int i = 0; i <= n; i++)
            G[i].clear();
    }

    return 0;
}

D. Link with Equilateral Triangle

构造

诈骗签到题。连 n = 3 n=3 n=3 都画不出来，直接猜无解。也许可以打表看小数据，但是复杂度也挺高的。证明可以参照官方题解。

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

int main()
{
    int t;
    cin >> t;
    while (t--) cout << "No\n";
    return 0;
}

E. Link with Level Editor II

数学、数据结构、双指针

注意到图很小，考虑用矩阵维护点对可达性（就是邻接矩阵），则矩阵乘即为方案数。如下图所示，

在这里插入图片描述
在这里插入图片描述
由于题目要求方案数不多于 k k k，对一个可行区间 [ l , r ] [l,r] [l,r]，显然 r r r 增大时方案数非降， l l l 增大时方案数非升，比较明显的双指针性质，于是枚举区间可以在 O ( N ) O(N) O(N) 时间复杂度內完成。
则问题在于如何快速支持查询。因为是区间矩阵乘，自然想到线段树，则复杂度包括建树和每次区间查询，为 O ( N M 3 + N M 3 l o g N ) O(NM^3+NM^3logN) O(NM3+NM3logN)，因为还有多测，太慢而无法通过。官方题解使用了对顶栈的做法，这可以避免线段树每次都重新查询区间矩阵乘的弊端，实现了和矩阵求逆一样的效果，在 O ( N M 3 ) O(NM^3) O(NM3) 时间内通过本题。然而线段树做法仍然有优化空间。
瓶颈来自于每次暴力矩阵乘，考虑到我们只关心 1 1 1 到 n n n 的方案数，仅使用一个单位矩阵 [ 1 , 0 , 0 , ⋯   , 0 ] [1,0,0,\cdots,0] [1,0,0,⋯,0] 右乘上线段树区间即可优化掉一个 M M M 的复杂度，总时间复杂度为 O ( N M 3 + N M 2 l o g N ) O(NM^3+NM^2logN) O(NM3+NM2logN)。

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

constexpr int MAXN = 5005, M = 21;
int n, m;
int64_t k, mat[MAXN << 2][M][M], tmp1[M][M], tmp2[M], f[M];

void mul(int64_t res[M][M], int64_t a[M][M], int64_t b[M][M])
{
    for (int i = 1; i <= m; i++)
        for (int j = 1; j <= m; j++)
            tmp1[i][j] = 0;
    for (int i = 1; i <= m; i++)
        for (int j = 1; j <= m; j++)
            for (int k = 1; k <= m; k++)
                tmp1[i][j] += a[i][k] * b[k][j];
    for (int i = 1; i <= m; i++)
        for (int j = 1; j <= m; j++)
            res[i][j] = tmp1[i][j];
}

void mul(int64_t res[M], int64_t a[M], int64_t b[M][M])
{
    for (int i = 1; i <= m; i++)
        tmp2[i] = 0;
    for (int i = 1; i <= m; i++)
        for (int j = 1; j <= m; j++)
            tmp2[i] += a[j] * b[j][i];
    for (int i = 1; i <= m; i++)
        res[i] = tmp2[i];
}

void build(int l, int r, int rt)
{
    if (l == r)
    {
        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= m; j++)
                mat[rt][i][j] = (i != j ? 0 : 1);
        int e, v, u;
        cin >> e;
        while (e--)
            cin >> v >> u, mat[rt][v][u] = 1;
        return;
    }
    int mid = (l + r) >> 1;
    build(l, mid, rt << 1);
    build(mid + 1, r, rt << 1 | 1);
    mul(mat[rt], mat[rt << 1], mat[rt << 1 | 1]);
}

void query(int L, int R, int l, int r, int rt)
{
    if (L <= l && r <= R)
    {
        mul(f, f, mat[rt]);
        return;
    }
    int mid = (l + r) >> 1;
    if (L <= mid)
        query(L, R, l, mid, rt << 1);
    if (R > mid)
        query(L, R, mid + 1, r, rt << 1 | 1);
}

bool check(int l, int r)
{
    for (int i = 1; i <= m; i++)
        f[i] = 0;
    f[1] = 1;
    query(l, r, 1, n, 1);
    return f[m] <= k;
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t;
    cin >> t;
    while (t--)
    {
        cin >> n >> m >> k;
        build(1, n, 1);
        int l = 1, r = 0, ans = 0;
        while (l <= n)
        {
            while (r < n && check(l, r + 1))
                ++r;
            ans = max(ans, r - l + 1);
            ++l;
        }
        cout << ans << "\n";
    }

    return 0;
}

F. BIT Subway

数学、模拟

实际价格直接模拟算，以为的价格计算起来有点阅读理解，但是注意到票可以任意拆开，意味着可以分段享受所有优惠而不亏损，因此求出票价和 s s s，答案是关于 s s s 的分段函数（注意区分花费与票价和，例如票价和为225时花费才200）
a n s = { s , 0 ≤ s ≤ 100 100 + ( s − 100 ) ∗ 0.5 , 100 < s ≤ 225 200 + ( s − 225 ) ∗ 0.8 , s > 225 ans= \begin{cases} \qquad \qquad s, & & 0 \leq s \leq 100 \\ 100+(s-100)*0.5, & & 100 < s \leq 225 \\ 200+(s-225)*0.8, & & s > 225 \end{cases} ans=⎩ ⎨ ⎧​s,100+(s−100)∗0.5,200+(s−225)∗0.8,​​0≤s≤100100<s≤225s>225​

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

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cout << fixed << setprecision(3);
    int t;
    cin >> t;
    while (t--)
    {
        int n;
        cin >> n;
        vector<int> a(n);
        for (auto &x : a)
            cin >> x;
        double ans1 = accumulate(a.begin(), a.end(), 0), ans2 = 0;
        if (ans1 > 100 && ans1 <= 225)
            ans1 = 100 + 0.8 * (ans1 - 100);
        else if (ans1 > 225)
            ans1 = 200 + 0.5 * (ans1 - 225);
        for (auto x : a)
        {
            if (ans2 < 100)
                ans2 += x;
            else if (ans2 >= 100 && ans2 < 200)
                ans2 += x * 0.8;
            else
                ans2 += x * 0.5;
        }
        cout << ans1 << " " << ans2 << endl;
    }

    return 0;
}

G. Climb Stairs

贪心、模拟、数据结构

显然每次跳过一些怪物后，必须一直往下打败它们，再往上跳，对于多个可选跳点 r 1 , r 2 , ⋯   , r i r_1,r_2,\cdots,r_i r1​,r2​,⋯,ri​，选择 r 1 r_1 r1​ 总不劣（因为依然可以跳到已有跳点，还可能增加新的跳点）。于是问题变为每次寻找一个最小的 r r r。
设当前在 c u r cur cur，已访问过的最远点为 t o p top top，暴力枚举端点 t o p < c u r + i ≤ m i n ( c u r + k , n ) top<cur+i \leq min(cur+k,n) top<cur+i≤min(cur+k,n)，并检查其是否是可能的跳点，如图所示。
在这里插入图片描述
注意到每次检查失败就会进行区间加，容易想到线段树，但是贡献来自单点，区间操作很尴尬。稍作转换，只要左侧最小值大于等于右侧最小值，所有不等式即满足，区间最小值和区间加可以用线段树维护。
实际上不需要线段树，因为这里的区间加是全局加，线性方法详见代码。

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

constexpr int MAXN = 1e5 + 5;
int64_t a[MAXN], sum[MAXN];

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t;
    cin >> t;
    while (t--)
    {
        int n, k, cur = 0, top = 0;
        int64_t atk;
        cin >> n >> atk >> k;
        for (int i = 1; i <= n; i++)
            cin >> a[i], sum[i] = sum[i - 1] + a[i];
        while (top != n)
        {
            bool ok = 0;
            int64_t mn = 1e18;
            for (int i = top - cur + 1; i <= k && cur + i <= n; i++)
            {
                mn = min(mn, atk - a[cur + i]);
                if (mn >= 0)
                {
                    atk += sum[cur + i] - sum[top];
                    top = cur + i, ++cur;
                    ok = 1;
                    break;
                }
                mn += a[cur + i + 1];
            }
            if (!ok)
                break;
        }
        cout << (top == n ? "YES\n" : "NO\n");
    }

    return 0;
}

H. Fight and upgrade

计算几何、数据结构

过难

I. Fall with Full Star

DP、贪心

过难

J. Fall with Intersection

博弈论、计算几何

过难

K. Link is as bear

数学

举例子直接猜测是线性基板题，即在 n n n 个数中选出若干个数，使得它们的异或和最大。详细证明见官方题解。

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

int64_t p[64];

void insert(int64_t x)
{
    for (int i = 60; i >= 0; i--)
    {
        if (!(x >> i))
            continue;
        if (!p[i])
        {
            p[i] = x;
            break;
        }
        x ^= p[i];
    }
}

int64_t getMax()
{
    int64_t ans = 0;
    for (int i = 60; i >= 0; i--)
        ans = max(ans, ans ^ p[i]);
    return ans;
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t;
    cin >> t;
    while (t--)
    {
        memset(p, 0, sizeof(p));
        int n;
        cin >> n;
        int64_t x;
        for (int i = 1; i <= n; i++)
            cin >> x, insert(x);
        cout << getMax() << "\n";
    }

    return 0;
}
NoobDream_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【多校训练】2022杭电多校1补题
分享XCPC常用算法和相关技巧
06-17 252
2022hdu多校第一场
【多校训练】2022杭电多校2补题
分享XCPC常用算法和相关技巧
06-19 509
2022hdu多校第二场
【多校训练】2023杭电多校4补题
分享XCPC常用算法和相关技巧
07-30 705
2023hdu多校第四场
2019杭电多校训练营（第三场）
wang_viscaria的博客
09-26 251
Rank Solved A B C D E F G H I J k 40/875 4/11 . . . O . O O . O . O O: 当场通过 Ø: 赛后通过 .: 尚未通过 A Azshara’s deep sea B Blow up the city C Yukikaze and Demons D Distribution of books E Easy Math ...
杂题收录+简要题解3【杭电多校】
beginend
07-21 896
hdu 6756 Finding a MEX 给一个无向图，点有点权。每次修改一个点的点权，或询问与某个点相连的所有点的点权的mex。 n,m,q≤105n,m,q\le 10^5n,m,q≤105 把点按照度数是否大于 n\sqrt nn​ 分类，称为小点和大点。对每个大点用分块维护mex。修改点权时，维护相连的大点的答案。询问时，小点暴力询问，大点分块询问。 hdu 6760 Math is Simple 给出 nnn，计算∑1≤a<b≤n,gcd⁡(a,b)=1,a+b≥n1ab\sum_
杭电计组实验3多功能ALU设计实验
04-22
多功能ALU设计实验报告 本实验报告介绍了杭州电子科技大学计算机学院计算机组成原理与系统结构课程设计的实验报告，实验名称为多功能ALU设计实验。实验的目的是学习多功能ALU的工作原理，掌握运算器的设计方法，...
2018杭电多校第二场题解1
08-03
这篇题解涵盖了多个不同的编程竞赛题目，涉及到概率计算、图论、动态规划、组合数学以及字符串处理等多个领域的知识点。下面是对各个题目解法的详细解释： 1. **咕咕咕，咕咕咕 (Absolute)**: 此题是关于计算期望值...
hdoj杭电入门训练题
11-15
### hdoj杭电入门训练题 #### 概述 杭电在线评测系统（HDOJ）是中国杭州电子科技大学提供的一套在线编程题库平台，主要用于计算机程序设计竞赛（ACM-ICPC）的训练与选拔。对于初学者而言，通过解决HDOJ中的题目可以...
杭电操作系统大作业 dos系统多线程
02-20
#include #include #include #include #include #include #include #define GET_INDOS 0X34 #define GET_CRITICAL_ERROR 0X5D06 #define TIMEUNIT 10 #define MAXSOTRE 10 #define FINISHED 0 ...
杭电多媒体通信课件
03-05
杭州电子科技大学 研究生 多媒体通信 课件
【秋招笔试】8.11大疆秋招(第二套)-测开岗
清隆学长的博客
08-12 866
> 🍒 本专栏已收集 70+套笔试题，`笔试真题` 会在第一时间跟新 > > 🍹 近期会进行一波价格调整，没订阅的朋友抓紧冲！！！
四十一、【人工智能】【机器学习】- Bayesian Logistic Regression算法模型
技术分享、程序员趣事、行业趋势等内容！
08-19 570
监督学习（Supervised Learning）是机器学习中的一种主要方法，其核心思想是通过已知的输入-输出对（即带有标签的数据集）来训练模型，从而使模型能够泛化到未见的新数据上，做出正确的预测或分类。在监督学习过程中，算法“学习”的依据是这些已标记的例子，目标是找到输入特征与预期输出之间的映射关系。Bayesian Logistic Regression是一种统计建模方法，它结合了Logistic回归的原理和贝叶斯统计的框架。
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 740
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 428
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
算法之递归和迭代
qq_28576837的博客
08-16 343
斐波那契数列（Fibonacci sequence），又称黄金分割数列，这个数列最早是由印度数学家提出来的。如果是用迭代，那么就是用循环从前往后计算，前两个数是固定的，先根据前两个数可以计算出第三个数，然后把第三个数和第二个数再赋值给之前的变量，再相加即可。使用递归时，如果要计算第100个数，那么要先直到第99和第98个，要知道第99个和第98个，就要分别进行递归，直到最后一层，再返回递归回来进行计算。这个序列的前几项是这样的：0,1,1,2,3,5,8,13,21,34,⋯。自然，用递归函数最容易实现。
24/8/18算法笔记 目标导向强化学习
yyyy2711的博客
08-18 400
初始化DDPG模型data = {'over':[],#Data采样函数#采样结果sample = {'over':[],#采样N个数据#随机一局游戏#随机游戏中的一步，这里除了最后一步#提取数据#设置fake goal#随机选择step后面的某一步#以后面某个步的状态为一个伪的终点，也就是希望先走到这里再说#求二范数mod = [#再自己重新计算reward和over#以伪终点构建新的state#计算最后10个数据reward_sum的值。
湖北师范大学-Python程序设计-3.1 中国古代数学问题(project)
最新发布
柠檬喝汽水的博客
08-19 423
唐朝时，一斗酒的斗所采用的度量是小斗，也就是4斤，当时一斤取值范围大约在500多到600克左右，换算一下可知唐朝一斗酒的重量取值范围在2000克到2400克左右。有一座八层宝塔，每一层都有一些琉璃灯，每一层的灯数都是上一层的二倍，已知共有 765 盏琉璃灯，计算并输出每层各有多少盏琉璃灯。输出不超过 n 且满足条件的物品个数 m，如果有多个解，则分行输出，每行一个解；第二行输出 2 个浮点数，依次为小鼠和大鼠打洞的距离，单位为尺，保留小数点后 1 位数字。一个浮点数 f，表示李白的酒壶原来有 f 斗酒。
【LeetCode】字母异位词分组
LittleFishC的博客
08-14 302
使用unordered_map（哈希表）将排序后的字符串映射到一个字符串列表中。哈希表的键是排序后的字符串，值是所有与该键对应的原始字符串组成的列表。输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]给你一个字符串数组，请你将字母异位词组合在一起。字母异位词是由重新排列源单词的所有字母得到的一个新单词。输出: [[“a”]]输出: [[“”]]
二分查找5️⃣-山脉数组的封顶索引
2202_75331338的博客
08-15 309
对于山峰来说，我们会发现封顶的值是最大，对于封顶左边来说，后一个数比前一个数大；◦ 如果 mid 位置呈现上升趋势，说明我们接下来要在 [mid + 1, right] 区间继续搜索；◦ 如果 mid 位置呈现下降趋势，说明我们接下来要在 [left, mid - 1] 区间搜索；◦ 因此，我们可以遍历数组内的每一个元素，找到某一个元素比两边的元素大即可。本题的数组不是有序数组，但我们依然可以使用二分查找，原因是因为我们发现了。输入：arr = [0,2,1,0]◦ 峰顶的特点：比两侧的元素都要大。
2024杭电多校1001
07-22
抱歉，您的问题似乎是指向某个特定的时间点或活动，但是提供的信息"2024杭电多校1001"不够明确，无法直接给出详细解释。这可能是2024年浙江大学（杭州电子科技大学缩写为“杭电”）举办的一场或多场高校之间的联合招生、竞赛，或者是某个项目的编号，比如计算机程序设计比赛中的一个题目代号。 通常这类竞赛会有数学科目、编程挑战等内容，参赛者可能会解决复杂的算法问题、软件设计或者其他相关技术难题。如果这是关于一场具体的学术活动，可能需要查看当时的官方通知或相关网站获取准确信息。 如果你能提供更多上下文或说明，我可以提供更精确的帮助。例如，你是对比赛时间、内容还是报名参与有疑问？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

NoobDream_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值