LOJ刷题记录：2006-2011(SCOI2015)

最新推荐文章于 2022-07-28 17:56:39 发布
最新推荐文章于 2022-07-28 17:56:39 发布
阅读量469 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OIljt12138/article/details/77019077
版权

LOJ刷题记录：2006-2011(SCOI2015)

loj#2006. 「SCOI2015」小凸玩矩阵

水题…

二分答案之后用二分图匹配判断能不能取出 k 个比当前答案小的。

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

const int MAXN = 505;

struct node {
    int to, next, flow, neg;
} edge[MAXN*MAXN];
int head[MAXN], top = 0;
inline void push(int i, int j, int f)
{
    ++top, edge[top] = (node) {j, head[i], f, top+1}, head[i] = top;
    ++top, edge[top] = (node) {i, head[j], 0, top-1}, head[j] = top;
}

const int S = MAXN-1, T = S-1;
int lev[MAXN], vis[MAXN], bfstime = 0;
int cur[MAXN];
queue<int> que;

bool bfs()
{
    vis[S] = ++bfstime, lev[S] = 0, que.push(S);
    while (!que.empty()) {
        int nd = que.front(); que.pop();
        for (int i = head[nd]; i; i = edge[i].next) {
            int to = edge[i].to;
            if (vis[to] == bfstime || !edge[i].flow) continue;
            vis[to] = bfstime, lev[to] = lev[nd]+1, que.push(to);
        }
    }
    return vis[T] == bfstime;
}

int dfs(int nd, int flow)
{
    if (nd == T || !flow) return flow;
    int ans = 0, t;
    for (int &i = cur[nd]; i; i = edge[i].next) {
        int to = edge[i].to;
        if (lev[to] != lev[nd]+1 || !edge[i].flow) continue;
        t = dfs(to, min(flow, edge[i].flow));
        ans += t, flow -= t, edge[i].flow -= t, edge[edge[i].neg].flow += t;
        if (!flow) break;
    }
    return ans;
}

int dinic()
{
    int ans = 0;
    while (bfs()) memcpy(cur, head, sizeof head), ans += dfs(S, INT_MAX);
    return ans;
}

int n, m, k;
int a[255][255];

bool judge(int mid)
{
    memset(head, 0, sizeof head);
    top = 0;
    for (int i = 1; i <= n; i++) push(S, i, 1);
    for (int i = 1; i <= m; i++) push(i+n, T, 1);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            if (a[i][j] <= mid)
                push(i, n+j, 1);
    return dinic() >= k;
}

int main()
{
    scanf("%d%d%d", &n, &m, &k);
    k = n-k+1;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            scanf("%d", &a[i][j]);
    int l = 0, r = 1e9, mid;
    while (l <= r) {
        mid = (l+r)>>1;
        if (judge(mid)) r = mid-1;
        else l = mid+1;
    }
    printf("%d\n", r+1);
    return 0;
}

loj#2007. 「SCOI2015」国旗计划

细节神tm多……

考虑贪心，对于每一个战士，我们显然要选取能接上他火炬且右端点尽可能靠后点..这样我们就可以连一条有向边，然后每个战士就要找他的后继中第一个使得覆盖总长超过m的…这显然可以用倍增维护。

这样只要维护 last[nd][i] 为包含 nd 在内向后 2i 个点， nxt[nd][i] 表示不包含 nd 向后 2i 个点， sum[nd][i] 表示包含 nd 向后 2i 的覆盖总长。之所以要记录 last,nxt 两个东西就是要去除中间重复的部分。

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

const int MAXN = 200005;

struct segment {
    int l, r, id;
    friend bool operator < (const segment &a, const segment &b)
    { return a.l < b.l; }
} p[MAXN*2];
int n, m;
int nxt[MAXN][20], last[MAXN][20];
long long sum[MAXN][20];
int dat[MAXN];

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) {
        scanf("%d%d", &p[i].l, &p[i].r), p[i].id = i;
        if (p[i].l > p[i].r) p[i].r += m;
    }
    sort(p+1, p+n+1);
    for (int i = 1; i <= n; i++) p[i+n] = (segment){p[i].l+m, p[i].r+m, i};
    int pt = 1;
    for (int i = 1; i <= n; i++) {
        while (p[pt+1].l <= p[i].r) pt++;
        nxt[i][0] = pt<=n?pt:pt-n;
        sum[i][0] = p[i].r-p[i].l+1;
        last[i][0] = i;
    }
    for (int j = 1; j < 20; j++)
        for (register int i = 1; i <= n; i++)
            nxt[i][j] = nxt[nxt[i][j-1]][j-1], last[i][j] = nxt[last[i][j-1]][j-1];
    for (int j = 1; j < 20; j++)
        for (register int i = 1; i <= n; i++) {
            int R1 = p[last[i][j-1]].r;
            int R2 = p[nxt[i][j-1]].l; if (R2 > m) R2 -= m;
            if (R1 > m) R1 -= m;
            if (R1 < R2) R1 += m;
            sum[i][j] = sum[i][j-1]+sum[nxt[i][j-1]][j-1]-(R1-R2+1);
        }
    for (int i = 1; i <= n; i++) {
        long long cur = 0;
        int pt = i, ans = 0;
        int last_pos = p[i].l-1;
        for (int j = 19; j >= 0; j--) {
            int pre = pt;
                if (sum[pt][j]+cur-(last_pos-p[pt].l+1) <= m) {
                cur += sum[pt][j]-(last_pos-p[pt].l+1), last_pos = p[last[pt][j]].r, pt = nxt[pt][j], ans |= 1<<j;
                if (last_pos > m) last_pos -= m;
            }
        }
        dat[p[i].id] = ans+1;
    }
    for (int i = 1; i <= n; i++) {
        printf("%d ", dat[i]);
    }
    puts("");
    return 0;
}

loj#2008. 「SCOI2015」小凸想跑步

半平面交还是非常好建的…算是第一个成功的板子吧..

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

const int MAXN = 200005;

const double eps = 1e-8;

struct point {
    double x, y;
    double ang;
    friend point operator + (const point &a, const point &b)
    { return (point){a.x+b.x, a.y+b.y}; }
    friend point operator - (const point &a, const point &b)
    { return (point){a.x-b.x, a.y-b.y}; }
    friend double operator * (const point &a, const point &b)
    { return a.x*b.y-a.y*b.x; }
    friend point operator * (double lambda, const point &a)
    { return (point){lambda*a.x, lambda*a.y};  }
    void display()
    { printf("(%.2f, %.2f) ", x, y); }
};

typedef point vec;

struct half_plane {
    point pt;
    vec v;
    friend bool operator < (const half_plane &a, const half_plane &b)
    { return a.v.ang < b.v.ang; }
    inline bool inside(point &p)
    { return v*(p-pt) >= eps; }
    friend point operator * (const half_plane &a, const half_plane &b)
    {
        double lambda = (a.pt*b.v-b.pt*b.v)/(b.v*a.v);
        return a.pt+lambda*a.v;
    }
    void display()
    { pt.display(); printf("+ k"); v.display(), printf("ang = %.2f\n", v.ang);}
};

half_plane p[MAXN*2];
point q[MAXN*2];
int l, r;

double HPC(vector<half_plane> &v)
{
    sort(v.begin(), v.end());
    l = 1, r = 0;
    for (auto i : v) {
        while (l < r && !i.inside(q[r])) r--;
        while (l < r && !i.inside(q[l+1])) l++;
            if (l > r || abs(i.v.ang-p[r].v.ang) >= eps) p[++r] = i, q[r] = i*p[r-1];
    }
    while (l < r && !p[l].inside(q[r])) r--;
    q[r+1] = p[r]*p[l];
    q[r+2] = q[l+1];
    double ans = 0;
    if (r-l+1 >= 3) for (int i = l+1; i <= r+1; i++) ans += q[i]*q[i+1];
    return ans/2;
}

int n;
point pts[MAXN];
vector<half_plane> v;

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i++) scanf("%lf%lf", &pts[i].x, &pts[i].y);
    double sig = 0;
    for (int i = 0; i < n; i++) sig += pts[i]*pts[(i+1)%n];
    sig /= 2;
    for (int i = 0; i < n; i++) {
        vec ps = pts[(i+1)%n]-pts[i]; ps.ang = atan2(ps.y, ps.x);
        v.push_back((half_plane){pts[i], ps});
    }
    for (int i = 1; i < n; i++) {
        point p1 = pts[i], p2 = pts[(i+1)%n], pt;
        double a = p1.y-p2.y-pts[0].y+pts[1].y, b = p2.x-p1.x-pts[1].x+pts[0].x;
        double c = p1*p2-pts[0]*pts[1];
        if (abs(b) <= eps) {
            double xx = -c/a;
            pt = (point) {xx, 0}; 
        } else {
            double xx = -c/b;
            pt = (point) {0, xx};
        }
        v.push_back((half_plane){pt, (vec){b, -a, atan2(-a, b)}});
    }
    double ans = HPC(v);
    printf("%.4f\n", ans/sig);
    return 0;
}

loj#2009. 「SCOI2015」小凸玩密室

好神啊…

用ui,j表示走完i的子树后走到i的深度为j的祖先的兄弟的最小代价；
用vi,j表示走完i的子树后走到i的深度为j的祖先的最小代价，用u算出v。
枚举起点，计算答案。

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

const int MAXN = 200005;
int n;
long long a[MAXN], b[MAXN];
inline int lc(int nd)
{ return nd<<1; }
inline int rc(int nd)
{ return nd<<1|1; }
inline int fa(int nd)
{ return nd>>1; }
inline long long L(int nd)
{ return b[(nd<<1)-1]; }
inline long long R(int nd)
{ return b[nd<<1]; }
long long f[MAXN][20], g[MAXN][20];
int depth[MAXN];
long long dis[MAXN];

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
    for (int i = 1; i < n; i++) scanf("%lld", &b[i]);
        depth[1] = 1, dis[1] = 0;
    for (int i = 2; i <= n; i++) depth[i] = depth[fa(i)]+1, dis[i] = dis[fa(i)]+b[i-1];
    for (int i = n; i >= 1; i--)
        for (int j = depth[i], z = i; j > 1; j--, z = fa(z)) {
            int bro = (z&1)?z-1:z+1;
            if (lc(i)>n && rc(i)>n) f[i][j] = a[bro]*(dis[i]+dis[bro]-2*dis[fa(z)]);
            else if (rc(i)>n) f[i][j] = a[lc(i)]*L(i)+f[lc(i)][j];
            else f[i][j] = min(a[lc(i)]*L(i)+f[lc(i)][depth[i]+1]+f[rc(i)][j], a[rc(i)]*R(i)+f[rc(i)][depth[i]+1]+f[lc(i)][j]);
        }
    for (int i = n; i >= 1; i--)
        for (int j = depth[i], z = i; j >= 0; j--, z = fa(z)) {
            if (lc(i)>n && rc(i)>n) g[i][j] = (dis[i]-dis[z])*a[z];
            else if (rc(i)>n) g[i][j] = a[lc(i)]*L(i)+g[lc(i)][j];
            else g[i][j] = min(a[lc(i)]*L(i)+f[lc(i)][depth[i]+1]+g[rc(i)][j], a[rc(i)]*R(i)+f[rc(i)][depth[i]+1]+g[lc(i)][j]);
        }
    long long ans = g[1][0];
    //cerr << ans << endl;
    for (int i = 2; i <= n; i++) {
        long long cnt = g[i][depth[i]-1];
        int nd = i, p = fa(nd), bro = (nd&1)?nd-1:nd+1;
        while (p) {
            if (rc(p)<=n) cnt += b[bro-1]*a[bro]+g[bro][depth[p]-1];
            else cnt += b[p-1]*a[fa(p)];
            nd = p, p = fa(nd), bro = (nd&1)?nd-1:nd+1;
        }
        //cerr << cnt << endl;
        ans = min(ans, cnt);
    }
    printf("%lld\n", ans);
    return 0;
}

loj2010有点毒…先空着

loj#2011. 「SCOI2015」情报传递

离线处理，树上可持久化线段树即可…然而并跑不过两个log的树剖…

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

const int MAXN = 200005;

int l[MAXN*20], r[MAXN*20], lc[MAXN*20], rc[MAXN*20], sum[MAXN*20], tp = 0, root[MAXN];

void build(int &nd, int opl, int opr)
{
    nd = ++tp, l[nd] = opl, r[nd] = opr;
    if (opl < opr) build(lc[nd], opl, (opl+opr)>>1), build(rc[nd], ((opl+opr)>>1)+1, opr);
}

void modify(int pre, int &nd, int pos)
{
    nd = ++tp, l[nd] = l[pre], r[nd] = r[pre], sum[nd] = sum[pre]+1;
    if (l[nd] < r[nd]) {
        int mid = (l[nd]+r[nd])>>1;
        if (pos <= mid) rc[nd] = rc[pre], modify(lc[pre], lc[nd], pos);
        else lc[nd] = lc[pre], modify(rc[pre], rc[nd], pos);
    }
}

int query(int nd, int opl, int opr)
{
    if (opl > opr) return 0;
    if (l[nd] == opl && r[nd] == opr) return sum[nd];
    else {
        int mid = (l[nd]+r[nd])>>1;
        if (opr <= mid) return query(lc[nd], opl, opr);
        else if (opl > mid) return query(rc[nd], opl, opr);
        else return query(lc[nd], opl, mid)+query(rc[nd], mid+1, opr);
    }
}

struct node {
    int to, next;
} edge[MAXN];
int head[MAXN], top = 0;
inline void push(int i, int j)
{ edge[++top] = (node) {j, head[i]}, head[i] = top; }
int n, f[MAXN], rt, q;
int a[MAXN], b[MAXN], c[MAXN], d[MAXN];
int T[MAXN], ans[MAXN];
int fa[MAXN], vis[MAXN], depth[MAXN];
int findf(int nd)
{ return fa[nd]?fa[nd]=findf(fa[nd]):nd; }

vector<pair<int, int> > qy[MAXN];

void tarjan(int nd)
{
    vis[nd] = 1, depth[nd] = depth[f[nd]]+1;
    for (vector<pair<int, int> >::iterator i = qy[nd].begin(); i != qy[nd].end(); ++i) 
        if (vis[i->first]) ans[i->second] = findf(i->first);
        for (int i = head[nd]; i; i = edge[i].next) {
        int to = edge[i].to;
        if (to != f[nd]) tarjan(to);
    }
    fa[findf(nd)] = findf(f[nd]);
}

void dfs_build(int nd)
{
    if (T[nd]) modify(root[f[nd]], root[nd], T[nd]);
    else root[nd] = root[f[nd]];
    for (int i = head[nd]; i; i = edge[i].next) {
        int to = edge[i].to;
        if (to != f[nd]) dfs_build(to);
    }
}

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &f[i]);
        if (f[i]) push(f[i], i);
        else rt = i;
    }
    scanf("%d", &q);
    for (int i = 1; i <= q; i++) {
        scanf("%d", &a[i]);
        if (a[i] == 1) scanf("%d%d%d", &b[i], &c[i], &d[i]), qy[b[i]].push_back(make_pair(c[i], i)), qy[c[i]].push_back(make_pair(b[i], i));
        else scanf("%d", &b[i]), T[b[i]] = i;
    }
    tarjan(rt);
    build(root[0], 1, n);
    dfs_build(rt);
    for (int i = 1; i <= q; i++) {
        if (a[i] == 2) continue;
        int lca = ans[i], min_pos = max(1, i-d[i]);
        int sig = query(root[b[i]], 1, min_pos-1)+query(root[c[i]], 1, min_pos-1)-query(root[lca], 1, min_pos-1)-query(root[f[lca]], 1, min_pos-1);
        printf("%d %d\n", depth[b[i]]+depth[c[i]]-depth[lca]*2+1, sig);
    }
    return 0;
}
OIljt12138
关注
LOJ刷题记录：2024-2029（SHOI2016）
OIljt12138的博客
08-27 769
LOJ刷题记录：2024-2029
LOJ刷题记录：2018-2020
OIljt12138的博客
08-27 738
LOJ刷题记录：2018-2020
「SCOI2015」小凸玩密室
Johnny817的博客
11-01 218
题目描述 小凸和小方相约玩密室逃脱，这个密室是一棵有 nnn 个节点的完全二叉树，每个节点有一个灯泡。点亮所有灯泡即可逃出密室。每个灯泡有个权值 AiA_iAi​，每条边也有个权值 bib_ibi​。 点亮第 111 个灯泡不需要花费，之后每点亮一个新的灯泡 VVV 的花费，等于上一个被点亮的灯泡 UUU 到这个点 VVV 的距离 D(u,v)D(u, v)D(u,v)，乘以这个点的权值 AvA_...
洛谷 P4253 [SCOI2015]小凸玩密室
liangzihao1的博客
10-08 322
题目描述 小凸和小方相约玩密室逃脱，这个密室是一棵有 nnn 个节点的完全二叉树，每个节点有一个灯泡。点亮所有灯泡即可逃出密室。每个灯泡有个权值 aia_iai​，每条边也有个权值 bib_ibi​。点亮第一个灯泡不需要花费，之后每点亮一个新的灯泡 vvv 的花费，等于上一个被点亮的灯泡 uuu 到这个点 vvv 的距离 Du,vD_{u,v}Du,v​，乘以这个点的权值 ava_vav​。在点灯...
BZOJ 4446: [Scoi2015]小凸玩密室
ypxrain的博客
04-23 211
Description 小凸和小方相约玩密室逃脱，这个密室是一棵有n个节点的完全二叉树，每个节点有一个灯泡。点亮所有灯泡即可 逃出密室。每个灯泡有个权值Ai，每条边也有个权值bi。点亮第1个灯泡不需要花费，之后每点亮1个新的灯泡V的 花费，等于上一个被点亮的灯泡U到这个点V的距离Du,v，乘以这个点的权值Av。在点灯的过程中，要保证任意时刻 所有被点亮的灯泡必须连通，在点亮一个灯泡后必须先...
「SCOI2015」小凸玩密室 解题报告
weixin_30590285的博客
02-27 109
「SCOI2015」小凸玩密室 虽然有心里在想一些奇奇怪怪的事情的原因，不过还是写太久了.. 不过这个题本身也挺厉害的 注意第一个被点亮的是任意选的，我最开始压根没注意到 \(dp_{i,j}\)代表\(i\)号点子树最后连出去的一个点连的是它第\(j\)层的祖先 \(f_{i,j}\)代表\(i\)号点子树最后连出去的一个点连的是它第\(j\)层祖先的另一个儿子 然后我们就可以拼子树，做换根了 ...
loj#2009.「SCOI2015」小凸玩密室
agtvo48266的专栏
09-07 116
题目链接 loj#2009. 「SCOI2015」小凸玩密室 题解 树高不会很高<=20 点亮灯泡x,点亮x的一个子树，再点亮x另外的子树， 然后回到x的父节点，点亮父节点之后再点亮父节点的其他子树 所以对于一个节点x，有这样两种情况 x还没有被点亮，那么下一个被点亮的是x的一个儿子 x是叶子节点，那么下一个被点亮的是它的祖先，或者是它祖先的儿子 设f[i][j]表示点亮i之后回到...
Spring Boot 第三篇：理解 spring-boot-starter-parent
m0_67391401的博客
07-28 2517
本文从maven中的继承开始讲起，然后介绍与替代它的，最后还介绍了SpringBoot项目的依赖版本升级。在介绍的时候我们提到了一个插件可以将项目打成可执行的jar包，这个插件除了打包，还具有在开发环境运行SpringBoot的项目的功能，下篇会重点介绍这个插件如何运行SpringBoot项目的。httpshttpshttpshttpshttpshttpshttpshttpshttps。...
Loj X:创建逻辑电路-开源
07-04
Loj X 是一个开源项目，专注于提供一个平台，让人们能够创建和设计逻辑电路，从而实现基本的计算功能，甚至构建小型的完整处理器。这个工具集成了各种元件，如逻辑门、存储器和程序读取器，使得用户可以构建出复杂的...
各种OJ刷题记录6.27-7.6
OIljt12138的博客
06-29 1010
各种OJ刷题记录6.27-7.6
poj 2451 半平面交　板子
喵喵喵
05-02 226
poj 2451 半平面，一条直线可以把平面分成两部分，即称为半平面 半平面交，即多条直线划分出的相交的平面的面积 学习大佬的代码，清晰易懂，打算当成以后的模板用了 代码(基于poj 2451)： #include <bits/stdc++.h> #include <iostream> #include <cstdio> #include <c...
Loj2009「SCOI2015」小凸玩密室
zsyzClb的博客
06-13 187
仔细观察以后可以发现，关于电灯有以下几个性质： 1 根节点不是1，也就是每个点都可能为根节点，这就意味着不能用O(N^2)的做法，只能考虑O(NlogN)或者O(N） 2 所有点亮的灯都是连在一起的 3 对于一个已经点亮的点，它的左右子树只有3种可能：没有染色，已经全部染完，正在染色 4 当你准备将一个点染色的时候，上一个染色的点可能是它的父亲或者它父亲拥有的另外一棵子树的叶子节点 根据这几个性质，可以想到dp状态： dp[i][j][0]表示将第i个点的子树全部点亮并且上去点亮i的第j个祖先所需的最小费用
SCOI2015 小凸玩密室
玫葵之蝶
11-16 466
Link Difficulty 算法难度5，思维难度7，代码难度6 Description 给定一棵nnn个点的完全二叉树，树边带权，点带val(x)val(x)val(x)的权值。 定义两个点的距离dis(u,v)dis(u,v)dis(u,v)为uuu到vvv的最短路径上经过的边权之和。 你一开始可以选择一个起始点，并点亮这个点，这一步不需要花费。 你在点亮一个点之后，必须紧接着将它的子树内所...
1727008980062_36899042-cccb-455e-a366-ade300382e2a.mp3
最新发布
09-22
1727008980062_36899042-cccb-455e-a366-ade300382e2a.mp3
基于Java和Lua的美食社交APP设计源码
09-22
本项目是基于Java和Lua开发的美食社交APP，包含92个文件，其中包括80个Java源代码文件、4个XML配置文件、2个PNG图像文件、2个Lua脚本文件、1个LICENSE文件、1个Markdown文档文件和1个YAML配置文件。此外，还有1个SQL文件。该项目旨在为用户提供一个便捷、高效的美食社交平台，支持美食分享、社交互动、活动组织等功能，以提升用户体验和社区活跃度。
模数转换器(ADC)技术解析及应用指南
09-22
内容概要：本文全面介绍了模数转换器(ADC)的相关知识和技术，包括ADC的基本原理、关键技术参数、不同类型ADC的工作方式及其应用领域。并通过生动的比喻解释ADC的概念，强调其在日常生活中的实际应用，并提供了选型指南以及对未来发展方向进行了预测。 适用人群：具备一定模拟电子基础知识的研发人员及电子工程专业师生。 使用场景及目标：指导相关人员正确理解和选用ADC，并提升对最新发展的认知。适用于工业、消费电子、汽车电子、通讯和医疗器械等行业。 阅读建议：读者应重点学习ADC的关键指标及各参数间的关联性，并尝试联系具体的应用场景来加深理解。此外还推荐读者扩展学习相关设计实例和技术文章，以更好地吸收和运用知识内容。
基于微信小程序的碎片化驾考论文.docx
09-22
基于微信小程序的碎片化驾考论文
LOJ-6279-数列分块入门3(分块, 二分)
05-24
题目描述 给定一个长度为n的序列a，有m次询问。每次询问给定l, r, k，要求区间[l, r]中第k小的数。 输入格式 第一行两个整数n,m。 接下来一行n个整数，表示序列a。 接下来m行，每行三个整数l,r,k。 输出格式 对于每个询问，输出一行一个数，表示区间[l, r]中第k小的数。 输入样例 5 3 1 3 2 4 5 1 5 2 2 4 1 3 5 3 输出样例 2 3 5 算法1 (分块) $O(n\sqrt n)$ 我们可以预处理出每一个块的信息，每个块又分为若干小块，每个小块中的数都小于等于块中的最大值，可以用二分查找确定小块中满足条件的数的个数，然后用根号分治处理。 时间复杂度 每次查询的时间复杂度是 $O(\sqrt n\log n)$ 的，总时间复杂度是 $O(n\sqrt n\log n)$ 的。 参考文献 算法竞赛进阶指南 C++ 代码 算法2 (二分答案) $O(n\log^2n)$ 我们二分答案，然后统计序列中小于等于这个答案的数的个数，统计方法可以用归并排序，在时间复杂度 $O(n\log n)$ 的时间内完成。 时间复杂度 每次查询的时间复杂度是 $O(n\log^2n)$ 的，总时间复杂度是 $O(mn\log^2n)$ 的。 参考文献 算法竞赛进阶指南 C++ 代码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值