SpongeBob_Y
SpongeBob_Y

ACM 线段树，树状数组入门题（附代码解释）

如果是初学者建议先看看这篇博客，写的很不错传送门

目录

HDU 1166 敌兵布阵（线段树）

HDU 1698 Just a Hook（线段树）

POJ 3468 A Simple Problem with Integers（线段树区间修改+求和）

HDU 1540 Tunnel Warfare（最长连续区间+单点修改）

洛谷 P3372 【模板】线段树 1

洛谷 P3373 【模板】线段树 2

洛谷 P1198 [JSOI2008]最大数（线段树或RMQ）

洛谷 P1531 I Hate It（线段树或树状数组）

2018年全国多校算法寒假训练营练习比赛（第五场）逆序数（树状数组）

2018年全国多校算法寒假训练营练习比赛（第五场）H Tree Recovery（线段树）

power oj 2821: 小Y学长的GCD难题（线段树区间求最大公因数+区间修改）

区间 (interval)（牛客小白月赛5）（差分）

POJ2299 Ultra-QuickSort（树状数组求逆序数）

HDU4000 Fruit Ninja（树状数组）

POJ2481 Cows（树状数组）

POJ 1990 MooFest（树状数组）

POJ 3264 Balanced Lineup（RMQ）

HDU 1166 敌兵布阵（线段树）

题解：线段树的模板题，但是用树状数组更简单一点，这里前面的这个树状数组的代码，后面的是线段树的代码。

树状数组：

#include 
#include
#include
#include
#include
#include
#include
#include
#include
#include

const int maxn = 5e4 + 1000;
const int mod = 1e9 + 7;
const int inf = 1e9;
#define me(a, b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
int bit[maxn];

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

void update(int x, int c) {
    while (x < maxn) {
        bit[x] += c;
        x += lowbit(x);
    }
}

int qeroy(int x) {
    int sum = 0;
    while (x) {
        sum += bit[x];
        x -= lowbit(x);
    }
    return sum;
}

int main() {
    int t;
    cin >> t;
    for (int tt = 1; tt <= t; tt++) {
        cout << "Case " << tt << ":" << endl;
        me(bit, 0);
        char s[10];
        int n, a, b, x;
        scanf("%d", &n);
        for (int i = 1; i <= n; i++) {
            scanf("%d", &x);
            update(i, x);
        }
        while (scanf("%s", s) != EOF) {
            if (s[0] == 'E')
                break;
            scanf("%d%d", &a, &b);
            if (s[0] == 'Q')
                printf("%d\n", qeroy(b) - qeroy(a - 1));
            else if (s[0] == 'A')
                update(a, b);
            else
                update(a, -b);
        }
    }
    return 0;
}

线段树：

#include 
#include
#include
#include
#include
#include
#include
#include
#include
#include

const int maxn = 5e4 + 5;
const int mod = 1e9 + 7;
const int inf = 1e9;
#define me(a, b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
int sum[maxn << 2];

void build(int l, int r, int rt) {
    if (l == r) {
        scanf("%d", &sum[rt]);
        return;
    }
    int mid = (l + r) >> 1;
    build(l, mid, rt << 1);
    build(mid + 1, r, rt << 1 | 1);
    sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}

int num(int L, int R, int l, int r, int rt) {
    if (l >= L && R >= r)
        return sum[rt];
    int m = (l + r) >> 1;
    int s = 0;
    if (L <= m)
        s += num(L, R, l, m, rt << 1);
    if (R > m)
        s += num(L, R, m + 1, r, rt << 1 | 1);
    return s;
}

void update(int s, int c, int l, int r, int rt) {
    if (l == r) {
        sum[rt] += c;
        return;
    }
    int m = (l + r) >> 1;
    if (s <= m)
        update(s, c, l, m, rt << 1);
    else
        update(s, c, m + 1, r, rt << 1 | 1);
    sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}

int main() {
    int t;
    cin >> t;
    for (int tt = 1; tt <= t; tt++) {
        cout << "Case " << tt << ":" << endl;
        me(sum, 0);
        int n;
        string s;
        scanf("%d", &n);
        build(1, n, 1);
        while (cin >> s) {
            if (s == "End")
                break;
            int a, b;
            scanf("%d%d", &a, &b);
            if (s == "Query")
                printf("%d\n", num(a, b, 1, n, 1));
            else if (s == "Add")
                update(a, b, 1, n, 1);
            else
                update(a, -b, 1, n, 1);
        }
    }
    return 0;
}

 

HDU 1698 Just a Hook（线段树）

题解：这个题看题就知道是一个很裸线段树的区间修改问题。

#include 
#include
#include
#include
#include
#include
#include
#include
#include
#include

const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
const int inf = 1e8;
#define me(a, b) memset(a,b,sizeof(a))
#define lowbit(x) x&(-x)
typedef long long ll;
using namespace std;
int num[maxn << 2], add[maxn << 2];

void up_data(int rt) {
    num[rt] = num[rt << 1] + num[rt << 1 | 1];
}

void build(int l, int r, int rt) {
    if (l == r) {
        num[rt] = 1;
        return;
    }
    int m = (l + r) >> 1;
    build(l, m, rt << 1);
    build(m + 1, r, rt << 1 | 1);
    up_data(rt);
}

void push_down(int rt, int l, int r) {
    if (add[rt]) {
        int m = (l + r) >> 1;
        num[rt << 1] = (m - l + 1) * add[rt];
        num[rt << 1 | 1] = (r - m) * add[rt];
        add[rt << 1] = add[rt << 1 | 1] = add[rt];
        add[rt] = 0;
    }
}

void push_data(int x, int L, int R, int l, int r, int rt) {
    if (L <= l && R >= r) {
        num[rt] = (r - l + 1) * x;
        add[rt] = x;
        return;
    }
    push_down(rt, l, r);
    int m = (l + r) >> 1;
    if (L <= m)
        push_data(x, L, R, l, m, rt << 1);
    if (R > m)
        push_data(x, L, R, m + 1, r, rt << 1 | 1);
    up_data(rt);
}

int main() {
    int t, Case = 1;
    cin >> t;
    while (t--) {
        me(num, 0), me(add, 0);
        int n, m;
        cin >> n;
        build(1, n, 1);
        cin >> m;
        while (m--) {
            int l, r, x;
            scanf("%d%d%d", &l, &r, &x);
            push_data(x, l, r, 1, n, 1);
        }
        cout << "Case " << Case++ << ": The total value of the hook is " << num[1] << "." << endl;
    }
    return 0;
}

 

POJ 3468 A Simple Problem with Integers（线段树区间修改+求和）

#include 
#include
#include
#include
#include
#include
#include
#include
#include
#include

const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
const int inf = 1e8;
#define me(a, b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
ll num[maxn << 2], add[maxn << 2];

void pushup(int rt) {
    num[rt] = num[rt << 1] + num[rt << 1 | 1];
}

void build(int l, int r, int rt) {
    if (l == r) {
        scanf("%lld", &num[rt]);
        return;
    }
    int m = (l + r) >> 1;
    build(l, m, rt << 1);
    build(m + 1, r, rt << 1 | 1);
    pushup(rt);
}

void updata(int l, int r, int rt) {
    if (add[rt]) {
        int m = (l + r) >> 1;
        add[rt << 1] += add[rt];
        add[rt << 1 | 1] += add[rt];
        num[rt << 1] += add[rt] * (m - l + 1);
        num[rt << 1 | 1] += add[rt] * (r - m);
        add[rt] = 0;
    }
}

void pushdata(int L, int R, int c, int l, int r, int rt) {
    if (L <= l && R >= r) {
        num[rt] += (r - l + 1) * c, add[rt] += c;
        return;
    }
    int m = (l + r) >> 1;
    updata(l, r, rt);
    if (L <= m)
        pushdata(L, R, c, l, m, rt << 1);
    if (R > m)
        pushdata(L, R, c, m + 1, r, rt << 1 | 1);
    pushup(rt);
}

ll getsum(int L, int R, int l, int r, int rt) {
    if (L <= l && R >= r)
        return num[rt];
    ll sum = 0;
    updata(l, r, rt);
    int m = (l + r) >> 1;
    if (L <= m)
        sum += getsum(L, R, l, m, rt << 1);
    if (R > m)
        sum += getsum(L, R, m + 1, r, rt << 1 | 1);
    return sum;
}

int main() {
    int m, n;
    while (cin >> n >> m) {
        me(num, 0), me(add, 0);
        build(1, n, 1);
        while (m--) {
            char s[5];
            scanf("%s", s);
            if (s[0] == 'Q') {
                int x, y;
                scanf("%d%d", &x, &y);
                cout << getsum(x, y, 1, n, 1) << endl;
            } else {
                int x, y, c;
                scanf("%d%d%d", &x, &y, &c);
                pushdata(x, y, c, 1, n, 1);
            }
        }
    }
    return 0;
}

 

HDU 1540 Tunnel Warfare（最长连续区间+单点修改）
 

题意：

操作一：某个村庄被毁灭。

操作二：给出一个村庄的坐标，求包含包含这个村庄的的最长未被村庄的长度。

操作三：最后一个被摧毁的村庄被修复。

题解：首先我们可以想到用线段树来维护最长连续区间长度，我们现在可以用1代表改点没有被破坏，用0表示改点被破坏，然后用一个栈或数组来装上次破坏的点。然后就是线段树维护1的最长长度了。
 

#include 
#include
#include
#include
#include
#include
#include
#include
#include
#include

const int maxn = 5e4 + 5;
const int mod = 10007;
const int inf = 1e9;
const long long onf = 1e18;
#define me(a, b) memset(a,b,sizeof(a))
#define lowbit(x) x&(-x)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define PI 3.14159265358979323846
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
int ls[maxn << 2], rs[maxn << 2], sum[maxn << 2];
///sum表示区间最长连续序列，ls表示从左端点开始最长连续前缀，rs表示从r开始最长后缀
int n, m;

void push_up(int l, int r, int rt) {
    int mid = (l + r) >> 1;
    ls[rt] = ls[rt << 1];
    if (ls[rt << 1] == mid - l + 1)///要是左区间最长长度等于左区间长度，那么区间最长前缀长度要加上右儿子区间的最长前缀
        ls[rt] += ls[rt << 1 | 1];
    rs[rt] = rs[rt << 1 | 1];
    if (rs[rt << 1 | 1] == r - mid)///与上面情况一样
        rs[rt] += rs[rt << 1];
    sum[rt] = max(ls[rt], rs[rt]);
    sum[rt] = max(sum[rt], max(sum[rt << 1], sum[rt << 1 | 1]));
    sum[rt] = max(sum[rt], rs[rt << 1] + ls[rt << 1 | 1]);
    ///区间的最长连续长度为，左区间，右区间最长连续长度，和左区间的最长后缀+右区间的最长前缀的三者最大。（最后一种情况表示最长连续区间在中间）
}

void build(int l, int r, int rt) {
    if (l == r) {
        ls[rt] = rs[rt] = sum[rt] = 1;///初始化所有点都没有被破坏
        return;
    }
    int mid = (l + r) >> 1;
    build(lson);
    build(rson);
    push_up(l, r, rt);
}

void push_date(int pos, int x, int l, int r, int rt) {
    sum[rt] = ls[rt] = rs[rt] = 0;
    if (l == r) {
        sum[rt] = ls[rt] = rs[rt] = x;
        return;
    }
    int mid = (l + r) >> 1;
    if (pos <= mid)
        push_date(pos, x, lson);
    else
        push_date(pos, x, rson);
    push_up(l, r, rt);
}

int query(int pos, int l, int r, int rt) {
    if (l == r)
        return sum[rt];
    int mid = (l + r) >> 1;
    if (pos <= mid) {///点在左儿子区间里
        if (pos >= mid - rs[rt << 1] + 1)
            return ls[rt << 1 | 1] + rs[rt << 1];///要是点正好在左儿子的最长后缀中，肯定最长区间和就是左儿子的最长后缀长度+右儿子的最长前缀（左儿子的最长后缀与右儿子的最长前缀是连着的）
        else
            return query(pos, lson);///要是没有落在最长后缀中，就不用考虑是否加上右儿子的最长前缀，直接往下找就行了
    } else {
        if (pos <= mid + ls[rt << 1 | 1])///与上面情况类似
            return ls[rt << 1 | 1] + rs[rt << 1];
        else
            return query(pos, rson);
    }
}

int main() {
    while (scanf("%d%d", &n, &m) != EOF) {
        build(1, n, 1);
        stack q;
        while (m--) {
            char str[2];
            int x;
            scanf("%s", str);
            if (str[0] == 'D') {
                scanf("%d", &x);
                push_date(x, 0, 1, n, 1);
                q.push(x);
            } else if (str[0] == 'Q') {
                scanf("%d", &x);
                printf("%d\n", query(x, 1, n, 1));
            } else {
                if (q.size()) {
                    push_date(q.top(), 1, 1, n, 1);
                    q.pop();
                }
            }
        }
    }
    return 0;
}

 

洛谷 P3372 【模板】线段树 1

题解：裸的线段树。

#include 
#include
#include
#include
#include
#include
#include
#include
#include
#include

const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
const int inf = 1e8;
#define me(a, b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
ll sum[maxn << 2], add[maxn << 2];

void updata(int rt) {
    sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}

void lazy(int l, int r, int rt) {
    if (add[rt]) {
        int m = (l + r) >> 1;
        sum[rt << 1] += (m - l + 1) * add[rt];
        sum[rt << 1 | 1] += (r - m) * add[rt];
        add[rt << 1] += add[rt];
        add[rt << 1 | 1] += add[rt];
        add[rt] = 0;
    }
}

void build(int l, int r, int rt) {
    if (l == r) {
        scanf("%lld", &sum[rt]);
        return;
    }
    int m = (l + r) >> 1;
    build(l, m, rt << 1);
    build(m + 1, r, rt << 1 | 1);
    updata(rt);
}

void pushdata(int L, int R, int x, int l, int r, int rt) {
    if (L <= l && R >= r) {
        sum[rt] += (r - l + 1) * x;
        add[rt] += x;
        return;
    }
    lazy(l, r, rt);
    int m = (l + r) >> 1;
    if (L <= m)
        pushdata(L, R, x, l, m, rt << 1);
    if (R > m)
        pushdata(L, R, x, m + 1, r, rt << 1 | 1);
    updata(rt);
}

ll getsum(int L, int R, int l, int r, int rt) {
    if (L <= l && R >= r)
        return sum[rt];
    lazy(l, r, rt);
    int m = (l + r) >> 1;
    ll s = 0;
    if (L <= m)
        s += getsum(L, R, l, m, rt << 1);
    if (R > m)
        s += getsum(L, R, m + 1, r, rt << 1 | 1);
    return s;
}

int main() {
    int n, m;
    cin >> n >> m;
    build(1, n, 1);
    while (m--) {
        int a, x, y, k;
        scanf("%d", &a);
        if (a == 1) {
            scanf("%d%d%d", &x, &y, &k);
            pushdata(x, y, k, 1, n, 1);
        } else {
            scanf("%d%d", &x, &y);
            printf("%lld\n", getsum(x, y, 1, n, 1));
        }
    }
    return 0;
}

 

洛谷 P3373 【模板】线段树 2

题解：还是一个线段树的裸题，但是在区间修改的时候，他要乘上一个数，这时候懒标记下放，是要把下面要加的懒标记和要乘的懒标记的都要下放。

#include 
#include
#include
#include
#include
#include
#include
#include
#include
#include

const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
const int inf = 1e8;
#define me(a, b) memset(a,b,sizeof(a))
#define lowbit(x) x&(-x)
typedef long long ll;
using namespace std;
ll num[maxn << 2], add[maxn << 2], ch[maxn << 2];
ll n, m, p;

void init(int n) {
    for (int i = 1; i <= 4 * n; i++)
        num[i] = add[i] = 0, ch[i] = 1;
}

void updata(int rt) {
    num[rt] = (num[rt << 1] + num[rt << 1 | 1]) % p;
}

void build(int l, int r, int rt) {
    if (l == r) {
        scanf("%lld", &num[rt]);
        return;
    }
    int m = (l + r) >> 1;
    build(l, m, rt << 1);
    build(m + 1, r, rt << 1 | 1);
    updata(rt);
}

void push_down(int l, int r, int rt) {
    int m = (l + r) >> 1;
    add[rt << 1] = (add[rt << 1] * ch[rt] + add[rt]) % p;
    add[rt << 1 | 1] = (add[rt << 1 | 1] * ch[rt] + add[rt]) % p;
    ch[rt << 1] = (ch[rt << 1] * ch[rt]) % p;
    ch[rt << 1 | 1] = (ch[rt << 1 | 1] * ch[rt]) % p;
    num[rt << 1] = (num[rt << 1] * ch[rt] + (m - l + 1) * add[rt]) % p;
    num[rt << 1 | 1] = (num[rt << 1 | 1] * ch[rt] + (r - m) * add[rt]) % p;
    ch[rt] = 1, add[rt] = 0;
}

void push_data(int flog, int x, int L, int R, int l, int r, int rt) {
    if (L <= l && R >= r) {
        if (flog == 1) {
            add[rt] = (add[rt] * x) % p;
            ch[rt] = (ch[rt] * x) % p;
            num[rt] = (num[rt] * x) % p;
        } else {
            add[rt] = (add[rt] + x) % p;
            num[rt] = (num[rt] + (r - l + 1) * x) % p;
        }
        return;
    }
    int m = (l + r) >> 1;
    push_down(l, r, rt);
    if (L <= m)
        push_data(flog, x, L, R, l, m, rt << 1);
    if (R > m)
        push_data(flog, x, L, R, m + 1, r, rt << 1 | 1);
    updata(rt);
}

ll get_sum(int L, int R, int l, int r, int rt) {
    if (L <= l && R >= r)
        return num[rt];
    int m = (l + r) >> 1;
    push_down(l, r, rt);
    ll s = 0;
    if (L <= m)
        s = (s + get_sum(L, R, l, m, rt << 1)) % p;
    if (R > m)
        s = (s + get_sum(L, R, m + 1, r, rt << 1 | 1)) % p;
    return s % p;
}

int main() {
    cin >> n >> m >> p;
    init(n);
    build(1, n, 1);
    while (m--) {
        int flog, x, y, k;
        scanf("%d", &flog);
        if (flog == 3) {
            scanf("%d%d", &x, &y);
            printf("%lld\n", get_sum(x, y, 1, n, 1));
        } else {
            scanf("%d%d%d", &x, &y, &k);
            push_data(flog, k, x, y, 1, n, 1);
        }
    }
    return 0;
}

 

洛谷 P1198 [JSOI2008]最大数（线段树或RMQ）

题解：这是一个裸的线段树和RMQ的题，这里把这两种代码都贴出来。

#include 
#include
#include
#include
#include
#include
#include
#include
#include
#include

const int maxn = 2e5 + 10;
const int mod = 1e9 + 7;
const int inf = 1e8;
#define me(a, b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
int ma[maxn][21], a[maxn];

void RMQ(int u) {
    ma[u][0] = a[u];
    for (int i = 1; (1 << i) <= u; i++)
        ma[u][i] = max(ma[u][i - 1], ma[u - (1 << (i - 1))][i - 1]);
}

int getmax(int l, int r) {
    int x = log(r - l + 1.0) / log(2.0);
    return max(ma[l][x], ma[l + (1 << x) - 1][x]);
}

int main() {
    int n, d;
    cin >> n >> d;
    int l = 0, t = 0;
    while (n--) {
        char str[5];
        scanf("%s", str);
        if (str[0] == 'A') {
            int x;
            scanf("%d", &x);
            a[++l] = (x + t) % d;
            RMQ(l);
        } else {
            int x;
            scanf("%d", &x);
            int ans = getmax(l - x + 1, l);
            printf("%d\n", ans);
            t = ans;
        }
    }
    return 0;
}

线段树：

#include 
#include
#include
#include
#include
#include
#include
#include
#include
#include

const int maxn = 2e5 + 10;
const int mod = 1e9;
const int inf = 1e9;
#define me(a, b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
int ma[maxn << 2];

void updata(int rt) {
    ma[rt] = max(ma[rt << 1], ma[rt << 1 | 1]);
}

void build(int l, int r, int rt) {
    if (l == r) {
        ma[rt] = -inf;
        return;
    }
    int m = (l + r) >> 1;
    build(l, m, rt << 1);
    build(m + 1, r, rt << 1 | 1);
}

void charu(int c, int x, int l, int r, int rt) {
    if (l == r) {
        ma[rt] = x;
        return;
    }
    int m = (l + r) >> 1;
    if (c <= m)
        charu(c, x, l, m, rt << 1);
    else
        charu(c, x, m + 1, r, rt << 1 | 1);
    updata(rt);
}

int getmax(int L, int R, int l, int r, int rt) {
    if (L <= l && R >= r)
        return ma[rt];
    int m = (l + r) >> 1;
    int temp = -2147283647;
    if (L <= m)
        temp = max(temp, getmax(L, R, l, m, rt << 1));
    if (R > m)
        temp = max(temp, getmax(L, R, m + 1, r, rt << 1 | 1));
    return temp;
}

int main() {
    int n, d, temp = 0, l = 0;
    cin >> n >> d;
    build(1, maxn, 1);
    while (n--) {
        char str[5];
        scanf("%s", str);
        if (str[0] == 'A') {
            int x;
            scanf("%d", &x);
            l++;
            charu(l, (x + temp) % d, 1, maxn, 1);
        } else {
            int x;
            scanf("%d", &x);
            temp = getmax(l - x + 1, l, 1, maxn, 1);
            printf("%d\n", temp);
        }
    }
    return 0;
}

 

洛谷 P1531 I Hate It（线段树或树状数组）

题解：裸的线段树。

线段树：

#include 
#include
#include
#include
#include
#include
#include
#include
#include
#include

const int maxn = 2e5 + 10;
const int mod = 1e9 + 7;
const int inf = 1e8;
#define me(a, b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
int ma[maxn << 2];

void updata(int rt) {
    ma[rt] = max(ma[rt << 1], ma[rt << 1 | 1]);
}

void build(int l, int r, int rt) {
    if (l == r) {
        scanf("%d", &ma[rt]);
        return;
    }
    int m = (l + r) >> 1;
    build(l, m, rt << 1);
    build(m + 1, r, rt << 1 | 1);
    updata(rt);
}

void pushdata(int c, int x, int l, int r, int rt) {
    if (l == r) {
        if (ma[rt] < x)
            ma[rt] = x;
        return;
    }
    int m = (l + r) >> 1;
    if (c <= m)
        pushdata(c, x, l, m, rt << 1);
    else
        pushdata(c, x, m + 1, r, rt << 1 | 1);
    updata(rt);
}

int getmax(int L, int R, int l, int r, int rt) {
    if (L <= l && R >= r)
        return ma[rt];
    int m = (l + r) >> 1;
    int ma1 = 0, ma2 = 0;
    if (L <= m)
        ma1 = getmax(L, R, l, m, rt << 1);
    if (R > m)
        ma2 = getmax(L, R, m + 1, r, rt << 1 | 1);
    return max(ma1, ma2);
}

int main() {
    int n, m;
    cin >> n >> m;
    me(ma, 0);
    build(1, n, 1);
    while (m--) {
        char str[2];
        int a, b;
        scanf("%s%d%d", str, &a, &b);
        if (str[0] == 'Q')
            printf("%d\n", getmax(a, b, 1, n, 1));
        else
            pushdata(a, b, 1, n, 1);
    }
    return 0;
}

 

2018年全国多校算法寒假训练营练习比赛（第五场）逆序数（树状数组）

题解：裸的数组树状数组求逆序数，所以可以声明一个数组，记录比当前位置大的数，因为逆序数，正好是前面出现的比后面大的数，所以只要在前面输入一个数，就把比他小的数的数组加一，最后直接加数组里的数，就是前面比当前输入数大的数的个数。

#include 
#include
#include
#include
#include
#include
#include
#include

const int maxn = 5e5 + 5;
const int mod = 1e9 + 7;
#define me(a, b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
int bit[maxn], n;

struct node {
    int x, i;

    bool friend operator<(node a, node b) {
        if (a.x == b.x)
            return a.i < b.i;
        return a.x < b.x;
    }
} a[maxn];

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

void updata(int x) {
    while (x <= n) {
        bit[x] += 1;
        x += lowbit(x);
    }
}

int ss(int x) {
    int s = 0;
    while (x) {
        s += bit[x];
        x -= lowbit(x);
    }
    return s;
}

int main() {
    while (~scanf("%d", &n) && n) {
        me(bit, 0);
        for (int i = 1; i <= n; i++) {
            scanf("%d", &a[i].x);
            a[i].i = i;
        }
        sort(a + 1, a + 1 + n);
        ll sum = 0;
        for (int i = 1; i <= n; i++) {
            updata(a[i].i);
            sum += i - ss(a[i].i);
        }
        cout << sum << endl;
    }
    return 0;
}

 

2018年全国多校算法寒假训练营练习比赛（第五场）H Tree Recovery（线段树）

#include 
#include
#include
#include
#include
#include
#include
#include
#include
#include

const int maxn = 1e5 + 5;
const int mod = 1e9 + 7;
const int inf = 1e9;
#define me(a, b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
int num[maxn << 2], add[maxn << 2];

void build(int l, int r, int rt) {
    if (l == r) {
        scanf("%d", &num[rt]);
        return;
    }
    int m = (l + r) >> 1;
    build(l, m, rt << 1);
    build(m + 1, r, rt << 1 | 1);
    num[rt] = num[rt << 1] + num[rt << 1 | 1];
}

void pushdown(int ln, int rn, int rt) {
    if (add[rt]) {
        add[rt << 1] += add[rt];
        add[rt << 1 | 1] += add[rt];
        num[rt << 1] += add[rt] * ln;
        num[rt << 1 | 1] += add[rt] * rn;
        add[rt] = 0;
    }
}

void updata(int L, int R, int c, int l, int r, int rt) {
    if (L <= l && R >= r) {
        num[rt] += (r - l + 1) * c;
        add[rt] += c;
        return;
    }
    int m = (l + r) >> 1;
    pushdown(m - l + 1, r - m, rt);
    if (L <= m)
        updata(L, R, c, l, m, rt << 1);
    if (R > m)
        updata(L, R, c, m + 1, r, rt << 1 | 1);
    num[rt] = num[rt << 1] + num[rt << 1 | 1];
}

int query(int L, int R, int l, int r, int rt) {
    if (L <= l && R >= r)
        return num[rt];
    int s = 0;
    int m = (l + r) >> 1;
    pushdown(m - l + 1, r - m, rt);
    if (L <= m)
        s += query(L, R, l, m, rt << 1);
    if (R > m)
        s += query(L, R, m + 1, r, rt << 1 | 1);
    return s;
}

int main() {
    int n, m;
    cin >> n >> m;
    build(1, n, 1);
    while (m--) {
        string s;
        int a, b, c;
        cin >> s;
        if (s == "Q") {
            scanf("%d%d", &a, &b);
            cout << query(a, b, 1, n, 1) << endl;
        } else {
            scanf("%d%d%d", &a, &b, &c);
            updata(a, b, c, 1, n, 1);
        }
    }
    return 0;
}

 

power oj 2821: 小Y学长的GCD难题（线段树区间求最大公因数+区间修改）

#include 
#include
#include
#include
#include
#include
#include
#include
#include
#include

const int maxn = 2e5 + 10;
const int mod = 1e9 + 7;
const int inf = 1e8;
#define me(a, b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
int d[maxn << 2], lazy[maxn << 2];

int gcd(int a, int b) {
    if (!b)
        return a;
    return gcd(b, a % b);
}

void update(int rt) {
    d[rt] = gcd(d[rt << 1], d[rt << 1 | 1]);
}

void build(int l, int r, int rt) {
    if (l == r) {
        scanf("%d", &d[rt]);
        return;
    }
    int m = (l + r) >> 1;
    build(l, m, rt << 1);
    build(m + 1, r, rt << 1 | 1);
    update(rt);
}

void pushdown(int rt) {
    if (lazy[rt]) {
        d[rt << 1] = d[rt << 1 | 1] = lazy[rt];
        lazy[rt << 1] = lazy[rt << 1 | 1] = lazy[rt];
        lazy[rt] = 0;
    }
}

void pushdate(int L, int R, int c, int l, int r, int rt) {
    if (L <= l && R >= r) {
        d[rt] = lazy[rt] = c;
        return;
    }
    pushdown(rt);
    int m = (l + r) >> 1;
    if (L <= m)
        pushdate(L, R, c, l, m, rt << 1);
    if (R > m)
        pushdate(L, R, c, m + 1, r, rt << 1 | 1);
    update(rt);
}

int getgcd(int L, int R, int l, int r, int rt) {
    if (L <= l && R >= r)
        return d[rt];
    pushdown(rt);
    int m = (l + r) >> 1;
    int a = 0, b = 0;
    if (L <= m)
        a = getgcd(L, R, l, m, rt << 1);
    if (R > m)
        b = getgcd(L, R, m + 1, r, rt << 1 | 1);
    return gcd(a, b);
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n, q;
        cin >> n >> q;
        me(d, 0), me(lazy, 0);
        build(1, n, 1);
        while (q--) {
            int x, a, b, c;
            scanf("%d", &x);
            if (x == 1) {
                scanf("%d%d%d", &a, &b, &c);
                pushdate(min(a, b), max(a, b), c, 1, n, 1);
            } else {
                scanf("%d%d", &a, &b);
                printf("%d\n", getgcd(min(a, b), max(a, b), 1, n, 1));
            }
        }
    }
    return 0;
}

 

区间 (interval)（牛客小白月赛5）（差分）

题解：可以用线段树做，但是那样有点麻烦，这里可以用差分，这样只用更新，边界节点了。具体思想可以看代码理解。

#include 
#include
#include
#include
#include
#include
#include
#include

const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const int inf = 1e9;
#define me(a) memset(a,0,sizeof(a))
typedef long long ll;
using namespace std;
ll num[maxn], a[maxn];

int main() {
    int n, m;
    while (cin >> n >> m) {
        me(num);
        for (int i = 1; i <= n; i++) {
            scanf("%lld", &a[i]);
            num[i] = a[i] - a[i - 1];
        }
        while (m--) {
            int q, l, r, p;
            scanf("%d%d%d%d", &q, &l, &r, &p);
            if (q == 1) {
                num[l] -= p;
                num[r + 1] += p;
            } else {
                num[l] += p;
                num[r + 1] -= p;
            }
        }
        for (int i = 1; i <= n; i++)
            a[i] = a[i - 1] + num[i];
        int x, y;
        cin >> x >> y;
        ll sum = 0;
        for (int i = x; i <= y; i++)
            sum += a[i];
        cout << sum << endl;
    }
    return 0;
}

 

POJ2299 Ultra-QuickSort（树状数组求逆序数）

题解：前面已经有类似题了，但是没有说清楚，这里说的比较详细点。

这个需要用到离散化，

建立一个结构体包含val和id， val就是输入的数，id表示输入的顺序。然后按照val从小到大排序，如果val相等，那么就按照id排序。如果没有逆序的话，肯定id是跟i（表示拍好后的顺序）一直一样的，如果有逆序数，那么有的i和id是不一样的。所以，利用树状数组的特性，我们可以简单的算出逆序数的个数。

如果还是不明白的话举个例子。（输入4个数）

输入：9 -1 18 5

输出 3.

输入之后对应的结构体就会变成这样

val：9 -1 18 5

id：  1  2  3  4

排好序之后就变成了

val ：  -1 5 9 18

id：      2 4  1  3

2 4 1 3 的逆序数 也是3

之后再利用树状数组的特性就可以解决问题了；

因为数字可能有重复， 所以添加操作不再单纯的置为1 ，而是 ++；

#include 
#include
#include
#include
#include
#include
#include
#include

const int maxn = 5e5 + 5;
const int mod = 1e9 + 7;
#define me(a, b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
int bit[maxn], n;

struct node {
    int x, i;

    bool friend operator<(node a, node b) {
        if (a.x == b.x)
            return a.i < b.i;
        return a.x < b.x;
    }
} a[maxn];

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

void updata(int x) {
    while (x <= n) {
        bit[x] += 1;
        x += lowbit(x);
    }
}

int ss(int x) {
    int s = 0;
    while (x) {
        s += bit[x];
        x -= lowbit(x);
    }
    return s;
}

int main() {
    while (~scanf("%d", &n) && n) {
        me(bit, 0);
        for (int i = 1; i <= n; i++) {
            scanf("%d", &a[i].x);
            a[i].i = i;
        }
        sort(a + 1, a + 1 + n);
        ll sum = 0;
        for (int i = 1; i <= n; i++) {
            updata(a[i].i);
            sum += i - ss(a[i].i);
        }
        cout << sum << endl;
    }
    return 0;
}

 

HDU4000 Fruit Ninja（树状数组）

题意：给出n个数，求所有的i

题解：题目也就是让最后那个数第二大。我们输入第i个数字a，那么我们用的树状数组存的就是sum(a-1),sum(a-1)表示在a这个位置，在前i-1个数中，有sum(a-1)个数比a小，那么我们就可以求出在后面的(i+1,n)的序列中，有R=(n-a)-(i-1-sum(a-1))个数比a要大，(n-a)表示有这么多个数比a大，(i-1-sum(a-1))表示前i-1个数里面有sum(a-1)个数比a大，那么R=(n-a)-(i-1-sum(a-1))就表示后面有多少个数比a要大。然后，我们思考一下，a当作三个数里面的最小值，然后让它们组合，是不是就是有C(R,2)即R*(R-1)/2，因为后面的序列都是固定的，所以并没有排序的概念，也就是说，原本序列1 5 4 ,那么我们没有必要去思考1 4 5的情况,因为它已经固定好了，所以后面的序列选的时候直接从R个选2个就可以了，然后C(R,2)表示所有的a+两个大的(也就是小中大，小大中都包含在里面了)，那么我们要求的是小大中，所以对于每一个a来说，我们都需要减去小中大的情况，那么小中大=sum(a-1)*R，所以最后答案就是对于（1，n）所有数，求和SUM（C(R,2)-sum(a-1)*R。

#include 
#include
#include
#include
#include
#include
#include
#include

const int maxn = 5e5 + 5;
const int mod = 1e8 + 7;
#define me(a, b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
int n, bit[maxn];

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

void updata(int x) {
    while (x <= n) {
        bit[x]++;
        x += lowbit(x);
    }
}

int getsum(int x) {
    int s = 0;
    while (x) {
        s += bit[x];
        x -= lowbit(x);
    }
    return s;
}

int main() {
    int t, Case = 0;
    cin >> t;
    while (t--) {
        me(bit, 0);
        scanf("%d", &n);
        ll sum = 0, x, l, r;///l,前面输入比x小的数的个数，r表示输入数中比x大的数的个数。
        for (int i = 0; i < n; i++) {
            scanf("%lld", &x);
            updata(x);
            l = getsum(x - 1);
            r = (n - x) - (i - l - 1);///(n-x)表示有这么多个数比x大，(i-1-l)表示前i-1个数里面有sum(x-1)个数比a大
            sum += r * (r - 1) / 2 - r * l;
        }
        printf("Case #%d: %lld\n", ++Case, sum % mod);
    }
    return 0;
}

 

POJ2481 Cows（树状数组）

题意：先说下题意吧，其实就是输入一些线段，问能找到这条线段最多包含几条线段If Si <= Sj and Ej <= Ei and Ei - Si > Ej - Sj。

题解：这样问题就很简单了，我们可以按照后节点从大到小排序，如果后节点相等，前节点从小到大排序。这样排完序后，我们只需要找前面比前节点小的节点的个数就行了。

#include 
#include
#include
#include
#include
#include
#include
#include
#include

const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
#define me(a, b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
int n, bit[maxn];

struct node {
    int s, e, i;

    bool friend operator<(node a, node b) {
        if (a.e == b.e)
            return a.s < b.s;
        return a.e > b.e;
    }
} a[maxn];

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

void updata(int x) {
    while (x <= n) {
        bit[x]++;
        x += lowbit(x);
    }
}

int getsum(int x) {
    int sum = 0;
    while (x) {
        sum += bit[x];
        x -= lowbit(x);
    }
    return sum;
}

int main() {
    while (cin >> n && n) {
        int s[maxn];
        me(bit, 0);
        for (int i = 1; i <= n; i++) {
            scanf("%d%d", &a[i].s, &a[i].e);
            a[i].i = i;
            a[i].s++;///因为s可能会为0，所以这里都加一
        }
        sort(a + 1, a + n + 1);
        for (int i = 1; i <= n; i++) {
            if (a[i].s == a[i - 1].s && a[i].e == a[i - 1].e)///若两区间相等,该值等于上一个的值
                s[a[i].i] = s[a[i - 1].i];
            else
                s[a[i].i] = getsum(a[i].s);///更新节点信息
            updata(a[i].s);
        }
        for (int i = 1; i <= n; i++) {
            if (i != n)
                printf("%d ", s[i]);
            else
                printf("%d\n", s[i]);
        }
    }
    return 0;
}

 

POJ 1990 MooFest（树状数组）

题意：当两头牛i，j交流的时候，交流的最小声音为max{v[i],v[j]}*他们之间的距离。现在有n头牛，求他们之间两两交流最少要的音量和。

题解：如果用暴力的话肯定会超时的，所以现在可以用树状数组。首先将牛按发出声音的值，按从小到大排序。然后声明两个数组，一个记录当前输入的牛的前面位置比它小的牛的个数，一个记录这些牛的位置和。现在就是怎么求当前牛与其他牛的不同值了。这个分两部分计算，一个是位置比当前牛小的牛和位置比当前牛大的牛。位置小的牛很好计算，就是当前牛的听力值乘以比当前牛位置小的所有牛的位置差。比它大的牛计算有点麻烦。现在用树状数组求出当前输入的所有牛的位置和，减去位置比它小的牛的位置和，位置比它大的牛的位置和。在乘以他的听力值，就是这头牛与其他牛的所有不同值得和，因为按听力排序的，所以当前牛的听力值是最大的，直接乘就行了。

#include 
#include
#include
#include
#include
#include
#include
#include
#include
#include

const int maxn = 2e4 + 5;
const int mod = 1e9 + 7;
const int inf = 1e9;
#define me(a, b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
ll s[maxn], c[maxn];

struct node {
    int v, i;

    bool friend operator<(node a, node b) {
        if (a.v == b.v)
            return a.i < b.i;
        return a.v < b.v;
    }
} a[maxn];

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

void update(ll a[], int x, int s) {
    while (x <= maxn) {
        a[x] += s;
        x += lowbit(x);
    }
}

ll getsum(ll a[], int x) {
    int sum = 0;
    while (x) {
        sum += a[x];
        x -= lowbit(x);
    }
    return sum;
}

int main() {
    int n;
    while (~scanf("%d", &n)) {
        for (int i = 0; i < n; i++)
            scanf("%lld%lld", &a[i].v, &a[i].i);
        sort(a, a + n);
        ll sum = 0;
        for (int i = 0; i < n; i++) {
            ll xzs = getsum(c, a[i].i);//下标比他小的牛的个数
            ll xs = getsum(s, a[i].i);//下标比他小的牛的下标和
            ll ds = getsum(s, maxn);//当前输入所有牛的下标和
            sum += a[i].v * (xzs * a[i].i - xs + (ds - xs) - (i - xzs) * a[i].i);
            //(xzs*a[i].i-xs),位置比当前牛小的位置差的和。（(ds-xs)-(i-xzs)*a[i].i）比当前牛位置大的位置差的和。
            update(c, a[i].i, 1);
            update(s, a[i].i, a[i].i);
        }
        printf("%lld\n", sum);
    }
    return 0;
}

 

POJ 3264 Balanced Lineup（RMQ）

题解：这个题可以用线段树维护，但是这里用RMQ更方便。

#include 
#include
#include
#include
#include
#include
#include
#include
#include
#include

const int maxn = 5e4 + 10;
const int mod = 1e9 + 7;
const int inf = 1e8;
#define me(a, b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
int ma[maxn][40], mi[maxn][40], n, m;

void inct() {
    for (int j = 1; (1 << j) <= n; j++)
        for (int i = 1; i + (1 << j) - 1 <= n; i++) {
            ma[i][j] = max(ma[i][j - 1], ma[i + (1 << (j - 1))][j - 1]);
            mi[i][j] = min(mi[i][j - 1], mi[i + (1 << (j - 1))][j - 1]);
        }
}

void print(int l, int r) {
    int k = (int) (log(r - l + 1 + 0.0) / log(2.0));///k = log2(r - l + 1);
    int y = max(ma[l][k], ma[r - (1 << k) + 1][k]);
    int x = min(mi[l][k], mi[r - (1 << k) + 1][k]);
    cout << y - x << endl;
}

int main() {
    while (~scanf("%d%d", &n, &m)) {
        me(ma, 0), me(mi, 0);
        for (int i = 1; i <= n; i++) {
            scanf("%d", &ma[i][0]);
            mi[i][0] = ma[i][0];
        }
        inct();
        while (m--) {
            int l, r;
            cin >> l >> r;
            print(l, r);
        }
    }
    return 0;
}

 

你可能感兴趣的:(数据结构,线段树,树状数组)

  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • 数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列C语言
    文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • 4.C_数据结构_队列 荣世蓥 数据结构数据结构
    概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
  • C++八股 Petrichorzncu 八股总结c++开发语言
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
  • 【树一线性代数】005入门 Owlet_woodBird 算法
    Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
  • python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
    在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
  • 【数据结构-一维差分】力扣2848. 与车相交的点 hlc@ 数据结构数据结构leetcode算法
    给你一个下标从0开始的二维整数数组nums表示汽车停放在数轴上的坐标。对于任意下标i，nums[i]=[starti,endi]，其中starti是第i辆车的起点，endi是第i辆车的终点。返回数轴上被车任意部分覆盖的整数点的数目。示例1：输入：nums=[[3,6],[1,5],[4,7]]输出：7解释：从1到7的所有点都至少与一辆车相交，因此答案为7。示例2：输入：nums=[[1,3],[5
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 【高阶数据结构】并查集 椿融雪 数据结构与算法数据结构并查集
    文章目录一、并查集原理二、并查集实现三、并查集应用一、并查集原理在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，
  • python中文版软件下载-Python中文版 编程大乐趣
    python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
  • 开发游戏的学习规划 杰克逊的日记 游戏学习
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
  • 六、全局锁和表锁：给表加个字段怎么有这么多阻碍 nieniemin
    数据库锁设计的初衷是处理并发问题。作为多用户共享的资源，当出现并发访问的时候，数据库需要合理地控制资源的访问规则。而锁就是用来实现这些访问规则的重要数据结构。根据加锁的范围，MySQL里面的锁大致可以分成全局锁、表级锁和行锁三类。6.1全局锁全局锁就是对整个数据库实例加锁。MySQL提供了一个加全局读锁的方法，命令是Flushtableswithreadlock(FTWRL)。当你需要让整个库处于
  • Golang Channel PandaSkr golang
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
  • ⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表 英雄哪里出来 《LeetCode算法全集》算法数据结构链表c++归并排序
    饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述  将两个不降序链表合并为一个新的不降
  • 数据结构 1 五花肉村长 数据结构算法开发语言c语言visualstudio
    1.什么是数据结构数据结构（DataStructure）是计算机存储和组织数据的方式，是指相互之间存在的一种或多种特定关系的数据元的集合。2.什么是算法算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《
  • 【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】 NeVeRMoRE_2024 数据结构与算法实践数据结构算法leetcodeb树
    数据结构和算法实践-树-LeetCode113-路径总和Ⅱ题目MyThought代码示例JAVA-8题目给你二叉树的根节点root和一个整数目标和targetSum，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。叶子节点是指没有子节点的节点输入：root=[5,4,8,11,null,13,4,7,2,null,null,5,1],targetSum=22输出：[[5,4,11,2],[
  • 【Python】数据结构,链表,算法详解 AIAdvocate python数据结构链表排序算法广度优先深度优先
    今日内容大纲介绍自定义代码-模拟链表删除节点查找节点算法入门-排序类的冒泡排序选择排序插入排序快速排序算法入门-查找类的二分查找-递归版二分查找-非递归版分线性结构-树介绍基本概述特点和分类自定义代码-模拟二叉树1.自定义代码-模拟链表完整版"""案例:自定义代码,模拟链表.​背景: 顺序表在存储数据的时候,需要使用到连续的空间,如果空间不够,就会导致扩容失败,针对于这种情况,我们可以通过链表实现
  • AI教你学Python 第4天：函数和模块 凡人的AI工具箱 AI教你学Pythonpython开发语言人工智能AIGC
    第四天：数据结构一、什么是数据结构？数据结构是计算机科学中用于组织和存储数据的特定方式。良好的数据结构能够提高数据的访问效率、修改频率和管理能力。Python提供了多种内置数据结构，如列表、元组、字典和集合，便于开发者更有效地处理数据。二、Python中的基本数据结构1.列表（List）定义：列表是一个有序的可变集合，允许重复元素。使用方括号[]表示。#示例：定义一个列表fruits=['appl
  • 互联网 Java 工程师面试题（Java 面试题四） 苹果酱0567 面试题汇总与解析java中间件开发语言springboot后端
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
  • C# Tuple、ValueTuple 語衣 C#知识补充c#
    栏目总目录TupleTuple是C#4.0引入的一个新特性，主要用于存储一个固定数量的元素序列，且这些元素可以具有不同的类型。Tuple是一种轻量级的数据结构，非常适合用于临时存储数据，而无需定义完整的类或结构体。优点简便性：可以快速创建一个包含多个不同类型数据的对象，而无需定义新的类或结构体。灵活性：元素数量和类型在编译时确定，但可以在不同上下文中重复使用不同元素的Tuple。缺点性能：作为引用
  • Rust中的所有权和借用规则详解 代码云1 rust开发语言后端
    Rust是一种系统编程语言，其设计目标包括内存安全、并发安全以及性能。为了实现这些目标，Rust引入了一系列独特的编程概念，其中最为核心的就是所有权（Ownership）和借用（Borrowing）规则。本文将详细解释Rust中的所有权和借用规则，以及它们如何确保内存安全和并发安全。一、所有权规则在Rust中，每一个值都有一个与之关联的所有者。这个所有者可以是变量、数据结构或者是其他形式的存储。所
  • BZOJ 五月胡乱补题 nike0good 其他屯题bzoj博客补档
    旧博客搬运部分格式还没来得及改T_T【BZOJ4806:炮】同BZOJ1801【BZOJ3242:[Noi2013]快餐店】树形dp，要么最远点在同一颗树上（dp），要么在不同树上，此时答案=去掉任何一条边后形成的树的答案的最小值，我们枚举去掉的那条边。由于答案=s[i]-s[j]+dis[i]+dis[j]，i，j可以分开考虑，也可以用线段树解决。【BZOJ4878:[Lydsy2017年5月月
  • 二叉树--python 电子海鸥 Python数据结构与算法python开发语言数据结构
    二叉树一、概述1、介绍是一种非线性数据结构，将数据一分为二，代表根与叶的派生关系，和链表的结构类似，二叉树的基本单元是结点，每个节点包括值和左右子节点引用。每个节点都有两个引用（类似于双向链表），分别指向左子节点和右子节点，该节点被称为这两个子节点的父节点。当给定一个二叉树的结点时，我们将在该节点的左子节点以及其以下结点所形成的树称为左子树，同理，右子节点的部分被称为右子树。在二叉树中，除了叶节点
  • 使用WAF防御网络上的隐蔽威胁之反序列化攻击 baiolkdnhjaio 网络安全
    什么是反序列化反序列化是将数据结构或对象状态从某种格式转换回对象的过程。这种格式通常是二进制流或者字符串（如JSON、XML），它是对象序列化（即对象转换为可存储或可传输格式）的逆过程。反序列化的安全风险反序列化的安全风险主要来自于处理不受信任的数据源时的不当反序列化。如果应用程序反序列化了恶意构造的数据，攻击者可能能够执行代码、访问敏感数据、进行拒绝服务攻击等。这是因为反序列化过程中可能会自动触
  • redis学习笔记——不仅仅是存取数据 Everyday都不同 returnSourceexpire/delincr/lpush数据库分区redis
    最近项目中用到比较多redis，感觉之前对它一直局限于get/set数据的层面。其实作为一个强大的NoSql数据库产品，如果好好利用它，会带来很多意想不到的效果。（因为我搞java，所以就从jedis的角度来补充一点东西吧。PS：不一定全，只是个人理解，不喜勿喷）   1、关于JedisPool.returnSource(Jedis jeids)   这个方法是从red
  • SQL性能优化-持续更新中。。。。。。 atongyeye oraclesql
    1 通过ROWID访问表--索引 你可以采用基于ROWID的访问方式情况,提高访问表的效率, , ROWID包含了表中记录的物理位置信息..ORACLE采用索引(INDEX)实现了数据和存放数据的物理位置(ROWID)之间的联系. 通常索引提供了快速访问ROWID的方法,因此那些基于索引列的查询就可以得到性能上的提高. 2 共享SQL语句--相同的sql放入缓存 3 选择最有效率的表
  • [JAVA语言]JAVA虚拟机对底层硬件的操控还不完善 comsci JAVA虚拟机
         如果我们用汇编语言编写一个直接读写CPU寄存器的代码段，然后利用这个代码段去控制被操作系统屏蔽的硬件资源，这对于JVM虚拟机显然是不合法的，对操作系统来讲，这样也是不合法的，但是如果是一个工程项目的确需要这样做，合同已经签了，我们又不能够这样做，怎么办呢？ 那么一个精通汇编语言的那种X客，是否在这个时候就会发生某种至关重要的作用呢？ &n
  • lvs- real 男人50 LVS
    #!/bin/bash # # Script to start LVS DR real server. # description: LVS DR real server # #.  /etc/rc.d/init.d/functions VIP=10.10.6.252 host='/bin/hostname' case "$1" in sta
  • 生成公钥和私钥 oloz DSA安全加密
    package com.msserver.core.util; import java.security.KeyPair; import java.security.PrivateKey; import java.security.PublicKey; import java.security.SecureRandom; public class SecurityUtil {
  • UIView 中加入的cocos2d，背景透明 374016526 cocos2dglClearColor
    要点是首先pixelFormat:kEAGLColorFormatRGBA8，必须有alpha层才能透明。然后view设置为透明glView.opaque = NO;[director setOpenGLView:glView];[self.viewController.view setBackgroundColor:[UIColor clearColor]];[self.viewControll
  • mysql常用命令 香水浓 mysql
    连接数据库 mysql -u troy -ptroy 备份表 mysqldump -u troy -ptroy mm_database mm_user_tbl > user.sql 恢复表（与恢复数据库命令相同） mysql -u troy -ptroy mm_database < user.sql 备份数据库 mysqldump -u troy -ptroy
  • 我的架构经验系列文章 - 后端架构 - 系统层面 agevs JavaScriptjquerycsshtml5
    系统层面： 高可用性 所谓高可用性也就是通过避免单独故障加上快速故障转移实现一旦某台物理服务器出现故障能实现故障快速恢复。一般来说，可以采用两种方式，如果可以做业务可以做负载均衡则通过负载均衡实现集群，然后针对每一台服务器进行监控，一旦发生故障则从集群中移除；如果业务只能有单点入口那么可以通过实现Standby机加上虚拟IP机制，实现Active机在出现故障之后虚拟IP转移到Standby的快速
  • 利用ant进行远程tomcat部署 aijuans tomcat
    在javaEE项目中，需要将工程部署到远程服务器上，如果部署的频率比较高，手动部署的方式就比较麻烦，可以利用Ant工具实现快捷的部署。这篇博文详细介绍了ant配置的步骤（http://www.cnblogs.com/GloriousOnion/archive/2012/12/18/2822817.html），但是在tomcat7以上不适用，需要修改配置，具体如下： 1.配置tomcat的用户角色
  • 获取复利总收入 baalwolf 获取
           public static void main(String args[]){         int money=200;         int year=1;         double rate=0.1; &
  • eclipse.ini解释 BigBird2012 eclipse
    大多数java开发者使用的都是eclipse，今天感兴趣去eclipse官网搜了一下eclipse.ini的配置，供大家参考，我会把关键的部分给大家用中文解释一下。还是推荐有问题不会直接搜谷歌，看官方文档，这样我们会知道问题的真面目是什么，对问题也有一个全面清晰的认识。 Overview 1、Eclipse.ini的作用 Eclipse startup is controlled by th
  • AngularJS实现分页功能 bijian1013 JavaScriptAngularJS分页
            对于大多数web应用来说显示项目列表是一种很常见的任务。通常情况下，我们的数据会比较多，无法很好地显示在单个页面中。在这种情况下，我们需要把数据以页的方式来展示，同时带有转到上一页和下一页的功能。既然在整个应用中这是一种很常见的需求，那么把这一功能抽象成一个通用的、可复用的分页（Paginator）服务是很有意义的。   &nbs
  • [Maven学习笔记三]Maven archetype bit1129 ArcheType
    archetype的英文意思是原型，Maven archetype表示创建Maven模块的模版，比如创建web项目，创建Spring项目等等.   mvn archetype提供了一种命令行交互式创建Maven项目或者模块的方式，   mvn archetype   1.在LearnMaven-ch03目录下，执行命令mvn archetype:gener
  • 【Java命令三】jps bit1129 Java命令
    jps很简单，用于显示当前运行的Java进程，也可以连接到远程服务器去查看   [hadoop@hadoop bin]$ jps -help usage: jps [-help] jps [-q] [-mlvV] [<hostid>] Definitions: <hostid>: <hostname>[:
  • ZABBIX2.2 2.4 等各版本之间的兼容性 ronin47
    zabbix更新很快，从2009年到现在已经更新多个版本，为了使用更多zabbix的新特性，随之而来的便是升级版本，zabbix版本兼容性是必须优先考虑的一点 客户端AGENT兼容 zabbix1.x到zabbix2.x的所有agent都兼容zabbix server2.4：如果你升级zabbix server，客户端是可以不做任何改变，除非你想使用agent的一些新特性。 Zabbix代理（p
  • unity 3d还是cocos2dx哪个适合游戏？ brotherlamp unity自学unity教程unity视频unity资料unity
    unity 3d还是cocos2dx哪个适合游戏？ 问：unity 3d还是cocos2dx哪个适合游戏？ 答：首先目前来看unity视频教程因为是3d引擎，目前对2d支持并不完善，unity 3d 目前做2d普遍两种思路，一种是正交相机，3d画面2d视角，另一种是通过一些插件，动态创建mesh来绘制图形单元目前用的较多的是2d toolkit，ex2d，smooth moves，sm2，
  • 百度笔试题：一个已经排序好的很大的数组，现在给它划分成m段，每段长度不定，段长最长为k，然后段内打乱顺序，请设计一个算法对其进行重新排序 bylijinnan java算法面试百度招聘
    import java.util.Arrays; /** * 最早是在陈利人老师的微博看到这道题： * #面试题#An array with n elements which is K most sorted，就是每个element的初始位置和它最终的排序后的位置的距离不超过常数K * 设计一个排序算法。It should be faster than O(n*lgn)。
  • 获取checkbox复选框的值 chiangfai checkbox
    <title>CheckBox</title> <script type = "text/javascript"> doGetVal: function doGetVal() { //var fruitName = document.getElementById("apple").value;//根据
  • MySQLdb用户指南 chenchao051 mysqldb
    原网页被墙，放这里备用。 MySQLdb User's Guide Contents Introduction Installation _mysql MySQL C API translation MySQL C API function mapping Some _mysql examples MySQLdb
  • HIVE 窗口及分析函数 daizj hive窗口函数分析函数
    窗口函数应用场景： （1）用于分区排序 （2）动态Group By （3）Top N （4）累计计算 （5）层次查询 一、分析函数 用于等级、百分点、n分片等。 函数             说明 RANK()     &nbs
  • PHP ZipArchive 实现压缩解压Zip文件 dcj3sjt126com PHPzip
    PHP ZipArchive 是PHP自带的扩展类，可以轻松实现ZIP文件的压缩和解压，使用前首先要确保PHP ZIP 扩展已经开启，具体开启方法就不说了，不同的平台开启PHP扩增的方法网上都有，如有疑问欢迎交流。这里整理一下常用的示例供参考。 一、解压缩zip文件 01 02 03 04 05 06 07 08 09 10 11
  • 精彩英语贺词 dcj3sjt126com 英语
    I'm always here              我会一直在这里支持你                &nb
  • 基于Java注解的Spring的IoC功能 e200702084 javaspringbeanIOCOffice
                                      
  • java模拟post请求 geeksun java
    一般API接收客户端（比如网页、APP或其他应用服务）的请求，但在测试时需要模拟来自外界的请求，经探索，使用HttpComponentshttpClient可模拟Post提交请求。 此处用HttpComponents的httpclient来完成使命。 import org.apache.http.HttpEntity ; import org.apache.http.HttpRespon
  • Swift语法之 ---- ?和!区别 hongtoushizi ?swift!
    转载自： http://blog.sina.com.cn/s/blog_71715bf80102ux3v.html   Swift语言使用var定义变量，但和别的语言不同，Swift里不会自动给变量赋初始值，也就是说变量不会有默认值，所以要求使用变量之前必须要对其初始化。如果在使用变量之前不进行初始化就会报错： var stringValue : String //
  • centos7安装jdk1.7 jisonami jdkcentos
    安装JDK1.7 步骤1、解压tar包在当前目录 [root@localhost usr]#tar -xzvf jdk-7u75-linux-x64.tar.gz 步骤2：配置环境变量 在etc/profile文件下添加 export JAVA_HOME=/usr/java/jdk1.7.0_75 export CLASSPATH=/usr/java/jdk1.7.0_75/lib
  • 数据源架构模式之数据映射器 home198979 PHP架构数据映射器datamapper
    前面分别介绍了数据源架构模式之表数据入口、数据源架构模式之行和数据入口数据源架构模式之活动记录，相较于这三种数据源架构模式，数据映射器显得更加“高大上”。   一、概念 数据映射器（Data Mapper）：在保持对象和数据库（以及映射器本身）彼此独立的情况下，在二者之间移动数据的一个映射器层。概念永远都是抽象的，简单的说，数据映射器就是一个负责将数据映射到对象的类数据。 &nb
  • 在Python中使用MYSQL pda158 mysqlpython
    缘由 　　近期在折腾一个小东西须要抓取网上的页面。然后进行解析。将结果放到 数据库中。 　　了解到 Python在这方面有优势，便选用之。 　　由于我有台 server上面安装有 mysql，自然使用之。在进行数据库的这个操作过程中遇到了不少问题，这里 记录一下，大家共勉。 　　 python中mysql的调用 　　 百度之后能够通过MySQLdb进行数据库操作。
  • 单例模式 hxl1988_0311 java单例设计模式单件
    package com.sosop.designpattern.singleton; /* * 单件模式：保证一个类必须只有一个实例，并提供全局的访问点 * * 所以单例模式必须有私有的构造器，没有私有构造器根本不用谈单件 * * 必须考虑到并发情况下创建了多个实例对象 * */ /** * 虽然有锁，但是只在第一次创建对象的时候加锁，并发时不会存在效率
  • 27种迹象显示你应该辞掉程序员的工作 vipshichg 工作
    1、你仍然在等待老板在2010年答应的要提拔你的暗示。 2、你的上级近10年没有开发过任何代码。 3、老板假装懂你说的这些技术，但实际上他完全不知道你在说什么。 4、你干完的项目6个月后才部署到现场服务器上。 5、时不时的，老板在检查你刚刚完成的工作时，要求按新想法重新开发。 6、而最终这个软件只有12个用户。 7、时间全浪费在办公室政治中，而不是用在开发好的软件上。 8、部署前5分钟才开始测试。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他