2019牛客多校训练第一场题解

最新推荐文章于 2020-08-06 02:47:33 发布
最新推荐文章于 2020-08-06 02:47:33 发布
阅读量162 收藏
点赞数
文章标签： 数据结构与算法 python
原文链接：http://www.cnblogs.com/heyuhhh/p/11215696.html
版权

2019牛客多校训练第一场题解

题目链接

A.Equivalent Prefixes

考虑位置\(i\)为区间最小值的下标，那么只需要找到左边第一个值比它小的位置就行了。单调栈搞一搞就行。

Code

#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int a[2][N];
int n;
int L[2][N];
int sta[2][N];
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    while(cin >> n) {
        for(int i = 1; i <= n; i++) cin >> a[0][i];
        for(int i = 1; i <= n; i++) cin >> a[1][i];
        for(int i = 1; i <= n; i++) L[0][i] = L[1][i] = i;
        L[0][n + 1] = -1;
        for(int k = 0; k < 2; k++) {
            int top = 0;
            for(int i = n; i >= 0; i--) {
                if(top == 0) {
                    sta[k][++top] = i;
                    continue ;
                }
                while(top && a[k][sta[k][top]] > a[k][i]) {
                    L[k][sta[k][top]] = i;
                    top--;
                }
                sta[k][++top] = i;
            }
        }
        for(int i = 1; i <= n + 1; i++) {
            if(L[0][i] != L[1][i]) {
                cout << i - 1 << '\n';
                break ;
            }
        }
    }
    return 0;
}

 

B. Integration

题解参见：传送门

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e3 + 5, MOD = 1e9 + 7;
int n;
ll a[N];
ll qp(ll A, ll B) {
    ll ans = 1;
    for(; B; B >>= 1) {
        if(B & 1) ans = ans * A % MOD;
        A = A * A % MOD;
    }
    return ans ;
}
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    while(cin >> n) {
        for(int i = 1; i <= n; i++) cin >> a[i];
        ll ans = 0;
        for(int i = 1; i <= n; i++) {
            ll tmp = 2ll * a[i];
            for(int j = 1; j <= n; j++) {
                if(i == j) continue ;
                tmp = (tmp * (a[j] + a[i]) % MOD * (a[j] - a[i]) % MOD + MOD) % MOD;
            }
            ans = (ans + qp(tmp, MOD - 2)) % MOD;
        }
        cout << ans << '\n';
    }
    return 0;
}

 

C.Euclidean Distance

题解说的用拉格朗日乘子法，但蒟蒻不会= =
后面知道直接贪心就行了，首先将\(a_i\)从大到小排个序，因为题目的条件：\(\sum{p_i}=1\)且\(p_i>=0\)，我们可以先提取一个\(m^2\)出来，那么我们需要最小化的式子就变为了\((a_i-m*p_i)^2\)。
然后我们感性理解一下这个式子，相当于把数\(m\)分配，然后用\(a_i\)减去。所以直接贪心地想，每次不断减少当前最大的\(a_i\)就行了，如果有多个都最大就一起减就是了。

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e4 + 5;
int n, m;
int a[N] ;
ll gcd(ll A, ll B) {
    return B == 0 ? A : gcd(B, A % B);
}
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    while(cin >> n >> m) {
        for(int i = 1; i <= n; i++) cin >> a[i];
        ll fm, fz = 0;
        ll remain = m, cnt = 0, last;
        sort(a + 1, a + n + 1);
        for(int i = n; i >= 2; i--) {
            cnt++;
            int d = a[i] - a[i - 1];
            if(remain >= d * cnt) {
                remain -= d * cnt;
            } else {
                last = cnt * a[i] - remain;
                remain = -1;
                break ;
            }
        }
        if(remain >= 0) {
            cnt++;
            last = cnt * a[1] - remain;
        }
        fm = cnt * cnt;
        for(int i = n - cnt; i >= 1; i--) {
            fz += fm * a[i] * a[i];
        }
        fz += cnt * last * last; fm *= (m * m);
        ll g = gcd(fz, fm);
        fz /= g, fm /= g;
        if(fm == 1 || !fz) cout << fz << '\n';
        else cout << fz << '/' << fm << '\n';
    }
    return 0;
}

 

E.ABBA

这题有两种解法，计数dp或者组合数学来搞。
dp的话，设\(dp[x][y]\)表示目前有\(x\)个\(A\)，\(y\)个\(B\)且满足条件的前缀串的个数，那么转移方程就是\(dp[x][y]=dp[x-1][y]+dp[x][y-1]\)，即分别考虑当前位为\(A\)或\(B\)。
但并不是所有的状态都能转移过来，所以就需要一些限制，就以当前考虑放的是\(A\)，已经有\(x\)个\(A\)，\(y\)个\(B\)为例。因为要合法，所以就有限制条件：\(y>=x+1-n\)，也就是说，先尽可能地\(AB\)配对，然后会剩下一些\(A\)，这些就只能\(BA\)配对了，此时\(B\)的个数要不小于剩下的，如果小于就说明会多出一对\(AB\)了。
另外一个限制条件同理可得。

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e3 + 5, MOD = 1e9 + 7;
int n, m;
ll dp[N][N];
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    while(cin >> n >> m) {
        for(int i = 0; i <= n + m; i++)
            for(int j = 0; j <= n + m; j++) dp[i][j] = 0;
        dp[0][0] = 1;
        for(int i = 0; i <= n + m; i++) {
            for(int j = 0; j <= n + m; j++) {
                if(i + 1 - n <= j) dp[i + 1][j] = (dp[i + 1][j] + dp[i][j]) % MOD;
                if(j + 1 - m <= i) dp[i][j + 1] = (dp[i][j + 1] + dp[i][j]) % MOD;
            }
        }
        cout << dp[n + m][n + m] << '\n';
    }
    return 0;
}

 

组合数学的话核心思想就是容斥一下，所有情况减去不合法的，证明过程有点类似于卡特兰数的证明过程。
所有的情况很显然为\(C_{2*(n+m)}^{n+m}\)，对于不合法的情况，还是只拿一个举例，另一个同理。
上面说过要满足\(y>=x-n\)，不合法的话说明就存在一个有\(x\)个\(A\)，\(y\)个\(B\)的前缀，满足\(x=y+n+1\)。然后我们将这个前缀的\(A\),\(B\)互换，会得到一个有\(m-1\)个\(A\)，\(n+m+n+1\)个\(B\)的序列。而这两个序列是一一对应的。那么易知不合法的方案数就为\(C_{2*(n+m)}^{m-1}\)，同理另一个为\(C_{2*(n+m)}^{n-1}\)。
\(n=0\)或\(m=0\)的情况单独考虑一下就行了，具体来推也是上面的方法。
代码如下：

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 4e3 + 5, MOD = 1e9 + 7;
int n, m;
ll fac[N], inv[N];
ll qp(ll a, ll b) {
    ll ans = 1;
    for(; b; b >>= 1) {
        if(b & 1) ans = ans * a % MOD;
        a = a * a % MOD;
    }
    return ans ;
}
ll C(ll a, ll b) {
    return fac[a] * inv[b] % MOD * inv[a - b] % MOD;
}
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    fac[0] = inv[0] = 1;
    for(int i = 1; i < N; i++) fac[i] = fac[i - 1] * i % MOD, inv[i] = qp(fac[i], MOD - 2) ;
    while(cin >> n >> m) {
        ll ans = C(2 * (n + m), n + m);
        if(n) ans -= C(2 * (n + m), n - 1);
        if(m) ans -= C(2 * (n + m), m - 1);
        cout << (ans % MOD + MOD) % MOD << '\n';
    }
    return 0;
}

 

F.Random Point in Triangle

emmm，找到重心然后推一下就行了，可以用等边三角形来搞一搞。
求期望面积，而底边确定，那么我们就只需要求期望高度，也就是要确定一个点，多边形可以看作一个质量均匀分布的物体，所以找重心就好了。
详细证明可以参见：传送门
代码如下：

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a1, a2, a3, b1, b2, b3;
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    while(cin >> a1 >> b1 >> a2 >> b2 >> a3 >> b3) {
        ll x1 = a1 - a2, y1 = b1 - b2;
        ll x2 = a1 - a3, y2 = b1 - b3;
        ll ans = 11 * labs(x1 * y2 - x2 * y1);
        cout << ans << '\n';
    }
    return 0;
}

 

H.XOR

直接考虑子集不好思考，所以我们考虑每个数对答案的贡献。
先插入\(n\)个数的线性基，得秩为\(r\)，那么现在从非基底中选择一个，它与其余\(n-r-1\)个的组合的异或值都能被这\(r\)个基底表示（线性基的性质），这些非基底的贡献还是比较好算的。
求基底的贡献就需要搞点事情了。一个基底有贡献也就等价于需要它来进行异或，也就是说它能被其余的数给异或出来。所以我们就可以枚举基底将其去掉，求出剩下\(n-1\)个数的基来看是否能够异或出我们枚举的（也可以直接用秩来判断），如果是，那么贡献就为\(2^{n-r-1}\)，因为其余的组合也能被异或出；否则就没有贡献。
这题的关键就是将问题转化为求每个数的贡献，其它的只要比较了解线性基以及异或的一些性质就行了。
代码如下：

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX = 64, N = 1e5 + 5, MOD = 1e9 + 7;
int n;
ll a[N];
struct linerbase{
    int SZ;
    ll v[MAX];
    void Clear() {
        SZ = 0, memset(v, 0, sizeof(v));
    }
    void Copy(linerbase a) {
        SZ = a.SZ; memcpy(v, a.v, sizeof(v));
    }
    bool Ins(ll x) {
        for(int i = 63; i >= 0; i--) {
            if(x >> i & 1) {
                if(!v[i]) {
                    v[i] = x;
                    SZ++;
                    break;
                } else x ^= v[i];
            }
        }
        return x > 0;
    }
}b1, b2, b3;
vector <int> ID;
ll qp(ll A, ll B) {
    ll ans = 1;
    while(B) {
        if(B & 1) ans = A * ans % MOD;
        A = A * A % MOD;
        B >>= 1;
    }
    return ans;
}
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    while(cin >> n) {
        for(int i = 1; i <= n; i++) cin >> a[i];
        ll ans = 0, cnt = 0;
        b1.Clear(), b2.Clear(), b3.Clear(), ID.clear();
        for(int i = 1; i <= n; i++) {
            if(!b1.Ins(a[i])) {
                b2.Ins(a[i]);
            } else {
                ID.push_back(i);
            }
        }
        if(b1.SZ != n) {
            cnt = qp(2, n - b1.SZ - 1);
            ans = (ans + cnt * (n - b1.SZ) % MOD) % MOD;
        }
        for(auto i : ID) {
            b3.Copy(b2);
            for(auto j : ID) if(i != j) b3.Ins(a[j]);
            if(b3.SZ == b1.SZ) ans = (ans + cnt) % MOD;
        }
        cout << ans << '\n';
    }
    return 0;
}

 

I.Points Division

不是很懂的线段树+dp。
分析题目条件可以知道如果一个点属于集合\(B\)，那么其右下角的所有点都必须属于\(B\)集合。那么最后就会形成一个不降的折线段，之后就在这上面dp。
排序后枚举每个点然后分情况来转移，如果这个点在折线段上面，那么就从\(1\)到\(y_i\)上面找一个最大值mx，进行转移\(dp[y_i]=mx+b_i\)；否则，我们就需要对之前的dp值进行更新，对于所有\(y\)值大于\(y_i\)的就加上\(b_i\)，小于的就加上\(a_i\)。
可以证明这样来搞是不会损失最优解的。
代码如下：

Code

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int N = 1e5 + 5;
int n;
struct node{
    int x, y;
    ll a, b;
    bool operator < (const node &A)const {
        if(A.x == x) return y > A.y;
        return x < A.x;
    }
}p[N];
int Hash[N];
ll maxx[N << 2], add[N << 2];
void push_up(int o) {
    maxx[o] = max(maxx[o << 1], maxx[o << 1|1]);
}
void push_down(int o) {
    if(add[o]) {
        add[o << 1] += add[o];
        add[o << 1|1] += add[o];
        maxx[o << 1] += add[o];
        maxx[o << 1|1] += add[o];
        add[o] = 0;
    }
}
void build(int o, int l, int r) {
    add[o] = 0;
    if(l == r) {
        maxx[o] = 0;
        return ;
    }
    int mid = (l + r) >> 1;
    build(o << 1, l, mid), build(o << 1|1, mid + 1, r);
    push_up(o);
}
ll query(int o, int l, int r, int L, int R) {
    if(L <= l && r <= R) return maxx[o];
    push_down(o);
    int mid = (l + r) >> 1;
    ll mx = 0;
    if(L <= mid) mx = max(mx, query(o << 1, l, mid, L, R));
    if(R > mid) mx = max(mx, query(o << 1|1, mid + 1, r, L, R));
    return mx;
}
void update(int o, int l, int r, int k, ll v) {
    if(l == r && l == k) {
        maxx[o] = v;
        return ;
    }
    push_down(o);
    int mid = (l + r) >> 1;
    if(k <= mid) update(o << 1, l, mid, k, v);
    else update(o << 1|1, mid + 1, r, k, v);
    push_up(o);
}
void update2(int o, int l, int r, int L, int R, int v) {
    if(L <= l && r <= R) {
        maxx[o] += v;
        add[o] += v;
        return ;
    }
    push_down(o);
    int mid = (l + r) >> 1;
    if(L <= mid) update2(o << 1, l, mid, L, R, v);
    if(R > mid) update2(o << 1|1, mid + 1, r, L, R, v);
    push_up(o);
}
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    while(cin >> n) {
        int D = 0;
        Hash[++D] = -INF, Hash[++D] = INF;
        for(int i = 1; i <= n; i++) {
            cin >> p[i].x >> p[i].y >> p[i].a >> p[i].b;
            Hash[++D] = p[i].y;
        }
        sort(p + 1, p + n + 1);
        sort(Hash + 1, Hash + D + 1);
        D = unique(Hash + 1, Hash + D + 1) - Hash - 1;
        for(int i = 1; i <= n; i++) p[i].y = lower_bound(Hash + 1, Hash + D + 1, p[i].y) - Hash;
        build(1, 1, D);
        for(int i = 1; i <= n; i++) {
            ll mx = query(1, 1, D, 1, p[i].y) ;
            update(1, 1, D, p[i].y, mx + p[i].b);
            update2(1, 1, D, 1, p[i].y - 1, p[i].a);
            update2(1, 1, D, p[i].y + 1, D, p[i].b);
        }
        cout << query(1, 1, D, 1, D) << '\n';
    }
    return 0;
}

 

J.Fraction Comparision

python大法好。

Code

while True:
    try:
        x,a,y,b = map(int,input().split())
        x = x * b
        y =y *a
        if x==y:
            print("=")
        elif x<y:
            print('<')
        else:
            print('>')
    except:
        break;

转载于:https://www.cnblogs.com/heyuhhh/p/11215696.html

dft539533
关注
2019年牛客多校第一场B题 Integration 数学
Dillonh的博客
07-18 770
题目链接 传送门 思路 首先我们对∫0∞1∏i=1n(ai2+x2)dx\int_{0}^{\infty}\frac{1}{\prod\limits_{i=1}^{n}(a_i^2+x^2)}dx∫0∞​i=1∏n​(ai2​+x2)1​dx进行裂项相消： 1∏i=1n(ai2+x2)=1(a12+x2)(a22+x2)×1∏i=3n(ai2+x2)=1a22+a12×(1a12+x2−1a22+...
题解 | RNGs-2019牛客暑期多校训练营第四场H题
lastbye的博客
09-02 275
题目来源于牛客竞赛：https://ac.nowcoder.com/acm/contest/discuss 题目描述： typedef unsigned int u32; typedef unsigned long long u64; struct RNG { virtual void srand(u32 seed)=0; virtual bool gen()=0; }; struct RNG0...
2019牛客多校第一场A题
binarycopycode
07-20 338
传送门https://ac.nowcoder.com/acm/contest/881/A 比赛的时候二分答案，然后用单调栈统计每个数字统治的区间只要相同那么这个答案就是可行的 后来看到牛逼网友的做法，直接O(n)单调栈扫一遍，然后只要判断统治区间(在这区间内最小)的左端相不相同，找到第一个不相同的位置，那里就是不行的。理性分析一下，因为右端是随便截取的，假设前i个可以，那么增加第i+1个时，新...
2019牛客多校第一场（补题检讨）
mlm5678的博客
07-19 260
A Equivalent Prefixes 点击查看 659/4657 B Integration(不补数论) 点击查看 156/911 C Euclidean Distance(不补数论) 点击查看 28/279 D Parity of Tuples(不补数论) 点击查看 1/4 E ABBA 点...
2019 牛客多校第一场 F
binarycopycode
07-19 350
题目传送门：https://ac.nowcoder.com/acm/contest/881#question 考场上看到输出36E，且保证36E是整数，然后想起整点三角形，面积一定是x/2，那么可以猜出期望是三角形面积的x/18。 理性分析，期望肯定大于1/2，不会超过2/3，或者超过一点，于是盲猜一发11/18过了。 然后看到了正解，其实好像还挺好算了。。。。不过求图形期望这种没什么经验，...
「2019牛客多校第一场I」Points Division【线段树+dp】
wzw
07-22 236
题目链接：https://ac.nowcoder.com/acm/contest/881/I 题面 题解 很妙的线段树维护dpdpdp的题 首先需要明确的是需要怎样将其划分为两个满足条件的集合，根据题意，可以知道可以用一个台阶将集合划分，如图 然后就可以将每个点的yyy进行离散化，然后考虑将这些点优先按照xxx升序，然后yyy升序的规则排序，显然每经过一个点，它所带来的贡献需要修改的是一个区...
题解 | Checkers-2019牛客暑期多校训练营第九场G题
lastbye的博客
09-07 240
题目来源于牛客竞赛：https://ac.nowcoder.com/acm/contest/discuss 题目描述： 输入描述： 输出描述： 示例1： 题解： 代码： #include <bits/stdc++.h> #include <ext/pb_ds/assoc_container.hpp> #include <ext/pb_ds/tree_poli...
[2019牛客多校训练第3场]Median
dxyinme-Zz
08-14 331
链接：https://ac.nowcoder.com/acm/contest/883/I 来源：牛客网 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32768K，其他语言65536K Special Judge, 64bit IO Format: %lld 分数：2500 题目描述 JSB has an integer sequence a1,a2,…,ana_1, a_2, ...
题解 | Blackjack-2019牛客暑期多校训练营第十场A题
lastbye的博客
09-09 246
题目来源于牛客竞赛：https://ac.nowcoder.com/acm/contest/discuss 题目描述： 输入描述： 输出描述： 示例1： 示例2： 题解： 代码： #include<bits/stdc++.h> using namespace std; typedef double db; const int maxn=505; int d[maxn],n...
2019牛客多校训练 第六场 B-Shorten IPv6 Address（思维题）
zhz的博客
08-10 167
2019牛客多校训练 第六场 B-Shorten IPv6 Address 题目 https://ac.nowcoder.com/acm/contest/886/B 题意 给你长度为128的01字符串s,让你把他转换成16进制的字符串。字符串s分为8组，长度为16分为一组，每组都对应转换为16进制的字符串。 为了使16进制字符串尽可能的短，前导0可以忽略省略，为了使每组都分开要求用“:”将两组分开...
牛客_01背包问题
zhangvalue的博客
09-11 686
题目： 购买礼品是，每一款礼品的受欢迎程度(热度值)各不相同，现给出总金额以及各个礼品的单价和热度值，且每个礼品只购买一个，如何购买可以使得所有礼品的总热度值最高。 * 输入： 第一行是一个正整数，表示总金额(不大于1000) 第二行是一个长度为n的正整数数组，表示礼品单价(n不大于100) 第三行是一个长度为n的正整数数组，表示对应礼品的热度值 ...
牛客多校8 - All-Star Game(线段树分治+并查集按秩合并的撤销操作)
Falcon的博客
08-06 606
题目链接：点击查看 题目大意：有 n 个球员和 m 个球迷，一个球员可能是多个球迷的粉丝，需要选择最少的球员进行比赛，使得所有的球迷都愿意观看（对于每个球迷来说，都有至少一个其喜欢的球员入选比赛） 对于球迷与球员之间的关系，如果球迷a 喜欢球员 b ，且球迷 c 喜欢球迷 b ，那么球迷 a 也会喜欢球迷 c 所喜欢的其他球员，对于球迷 c 同理 现在有 q 次粉丝关系的修改（增加或删除），对于每次修改后回答询问 题目分析：画画图不难看出，球迷与球员连边，设 cnt 为总的连通块的个数，设 cnt.
地形编辑器【前缀和】
哇-WA 的博客
04-06 416
1066: 地形编辑器时间限制: 1 Sec  内存限制: 128 MB提交: 30  解决: 3[提交][状态][讨论版]题目描述zdw很喜欢玩红警, 他经常制作一些奇奇怪怪的红警地图当他制作地图的时候, 经常需要用到地形编辑器zdw可以用这个编辑器将地图上的某个区域的高度改变x来创造地形一次显然是不够的, 而经过若干次的操作后, 地图上将会出现各种山脉和峡谷现给出zdw的所有操作, 求这些操作...
2020牛客暑期多校训练营（第八场）
Yubing792289314的博客
08-03 444
A All-Star Game B Bon Voyage C Cinema D Disgusting Relationship E Enigmatic Partition F Factorio G. Game SET #include <bits/stdc++.h> using namespace std; const int N = 1e6 + 10; int n; string str[13] = { "one", "two", "three",
2019牛客网多校赛（第一场）题解
git1314的博客
07-19 1550
官方题解：https://ac.nowcoder.com/discuss/208642?type=101&order=0&pos=9&page=1 A ： Equivalent Prefixes 题目链接 ：https://ac.nowcoder.com/acm/contest/881/A 题解： #include <iostream...
jzoj 3195.【HNOI模拟题】数学 分治+单调栈
liangzihao1的博客
01-30 360
由于题目描述过于沙雕，这里给出题目大意： 在坐标系内有nnn个点。如果一对点xxx和yyy是合法的，满足一个边平行于坐标轴的矩形仅包含这两个点，求合法点对数。 n&amp;lt;=105n&amp;lt;=10^5n&lt;=105 分析： 这题和bzoj 4237：稻草人是一个道理。 有几个注意的地方，首先还要计算上朝下的，而且在直线上相邻的两个点也有贡献。 因为这题不保证xix_ixi​和yi...
单调栈poj2796
weixin_33781606的博客
06-23 88
题意：给你一段区间，需要你求出（在这段区间之类的最小值*这段区间所有元素之和）的最大值...... 例如： 6 3 1 6 4 5 2 以4为最小值，向左右延伸，6 4 5  值为60....... 思路：解决完为这道题目，我才真正明白了单调栈的原理，它就是以某一个值为最小（最大）值，向这个值的两侧延伸，遇到大于它（小于它）的值，就将它延伸的范围扩大，当然，一般来说，要这样做的算法复杂度...
2020牛客暑期多校训练营（第四场）
qq_35975367的博客
07-21 315
2020牛客暑期多校训练营（第四场） 这场属实有点难受 文章目录A Ancient DistanceB Basic Gcd Problem题目代码：C Count New StringD Dividing StringsE Eliminate++F Finding the Order题意：题解：代码：G Geometry ChallengeH Harder Gcd ProblemI Investigating LegionsJ Jumping on the Graph A Ancient Distance
2019牛客暑期多校训练营（第一场）A Equivalent Prefixes 单调栈
还我笑颜
07-18 812
题目链接：https://ac.nowcoder.com/acm/contest/881/A 题意：求最大的p，满足[1, p] 任何区间的最小值的下标都相等 题解：假设前面的都符合了，在判断到第i个时，判断前面第一个比a[i], b[i] 小的位置k1, k2是否相同，因为在这个范围内，是a[i]和b[i]小，k1 k2 往前就是已经符合好的了 #include<bits/stdc...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值