【SPOJ】GSS总结

首先Orz zhonghaoxi找的的神题

GSS1 

Can you answer these queries I : http://www.spoj.com/problems/GSS1/

求区间最大子序和

考虑记录三个标记：tot（区间最大子序和），left（从区间左端开始向右的最大子序和），right（从区间右端开始向左的最大子序和）

Code：

#include <cstdio>
#include <algorithm>
#define maxn 50100
#define INF 1 << 30
#define For(i, n) for (int i = 1; i <= n; i++)
#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#define L rt << 1
#define R rt << 1 | 1
using namespace std;
int n, a[maxn], ans;
struct SegmentTree {
    int tot[maxn << 2], sum[maxn << 2], left[maxn << 2], right[maxn << 2];
    void Update(int rt) {
        sum[rt] = sum[L] + sum[R];
        tot[rt] = max(tot[L], tot[R]); tot[rt] = max(tot[rt], left[R] + right[L]);
        left[rt] = max(left[L], sum[L] + left[R]);
        right[rt] = max(right[R], sum[R] + right[L]);
    }
    void build(int l, int r, int rt) {
        if (l == r) {
            sum[rt] = tot[rt] = left[rt] = right[rt] = a[l]; 
            return;
        }
        int mid = (l + r) >> 1; build(lson), build(rson), Update(rt);
    }
    int query(int flag, int x, int y, int l, int r, int rt) {
        int mid = (l + r) >> 1;
        if (x <= l && r <= y) {
            ans = max(ans, tot[rt]);
            if (flag) return right[rt]; else return left[rt];
        }
        if (y <= mid) return query(0, x, y, lson); else if (mid + 1 <= x) return query(1, x, y, rson);
        int ln = query(1, x, y, lson), rn = query(0, x, y, rson); ans = max(ans, ln + rn);
        if (flag) return max(right[R], sum[R] + ln); else return max(left[L], sum[L] + rn);
    }
}seg;
int main() {
    scanf("%d\n", &n);
    For(i, n) scanf("%d", &a[i]); seg.build(1, n, 1);
    int m, x, y; scanf("%d", &m);
    while (m--) {
        scanf("%d%d", &x, &y); ans = -INF;
        seg.query(0, x, y, 1, n, 1);
        printf("%d\n", ans);
    }
    return 0;
}

 

GSS2

Can you answer these queries II : http://www.spoj.com/problems/GSS2/

求区间最大子序列和,区间相同元素的值只加一次

Code:

#ifdef unix
#define LLD "%lld"
#else
#define LLD "%I64d"
#endif
#include <cstdio>
#include <cstring>
#include <algorithm>
#define LL long long
#define maxn 200010
#define S 100000
#define For(i, n) for (int i = 1; i <= n; i++)
#define lson l, mid , rt << 1
#define rson mid + 1, r, rt << 1 | 1
#define L rt << 1
#define R rt << 1 | 1
using namespace std;
struct SegmentTree {
    int nowsum[maxn << 2], nowup[maxn << 2], totsum[maxn << 2], totup[maxn << 2];
    void build(int l, int r, int rt) {
        nowsum[rt] = nowup[rt] = totsum[rt] = totup[rt] = 0;
        if (l != r) {
            int mid = (l + r) >> 1;
            build(lson), build(rson);
        }
    }
    void PushUp(int rt) {
        totsum[rt] = max(totsum[L], totsum[R]) + nowsum[rt];
        totup[rt] = max(totup[L], totup[R]);
        totup[rt] = max(totup[rt], max(totsum[L], totsum[R]) + nowup[rt]);
    }
    void Down(int a, int b) {
        nowup[b] = max(nowup[b], nowsum[b] + nowup[a]), nowsum[b] += nowsum[a];
        PushUp(b);
    }
    void PushDown(int rt) {Down(rt, L), Down(rt, R);nowsum[rt] = nowup[rt] = 0;}
    void Update(int x, int y, int val, int l, int r, int rt) {
        if (x <= l && r <= y) {
            nowsum[rt] += val;
            nowup[rt] = max(nowup[rt], nowsum[rt]);
            PushUp(rt);
        } else {
            int mid = (l + r) >> 1;
            PushDown(rt);
            if (x <= mid) Update(x, y, val, lson);
            if (y > mid) Update(x, y, val, rson);
            PushUp(rt);
        }
    }
    LL Query(int x, int y, int l, int r, int rt) {
        if (x <= l && r <= y) return totup[rt];
        else {
            int mid = (l + r) >> 1;LL ret = 0;
            PushDown(rt);
            if (x <= mid) ret = max(ret, Query(x, y, lson));
            if (y > mid)  ret = max(ret, Query(x, y, rson));
            return ret;
        }
    }
}seg;
struct node{int l, r, pos;}Q[maxn];
int cmp(node a, node b) {return a.r < b.r;}
int pos[maxn], a[maxn];
LL ans[maxn];
int main() {
    int n, q;
    while (~scanf("%d", &n)) {
        seg.build(1, n, 1);
        memset(pos, 0, sizeof(pos));
        For(i, n) scanf("%d", &a[i]);
        scanf("%d", &q); For(i, q) scanf("%d%d", &Q[i].l, &Q[i].r), Q[i].pos = i;
        sort(Q + 1, Q + 1 + q, cmp);
        for(int i = 1, j = 1; i <= n && j <= q; i++) {
            seg.Update(pos[a[i] + S] + 1, i, a[i], 1, n, 1);
            pos[a[i] + S] = i;
            while (j <= q && i == Q[j].r) ans[Q[j].pos] = seg.Query(Q[j].l, Q[j].r, 1, n, 1), j++;
        }
        For(i, q) printf(LLD "\n", ans[i]);
    }
    return 0;
}

 

GSS3

Can you answer these queries III : http://www.spoj.com/problems/GSS3/

区间最大子序和（同GSS1）+单点修改（基本操作吧）

Code:

#ifdef unix
#define LLD "%lld"
#else
#define LLD "%I64d"
#endif
#include <cstdio>
#include <algorithm>
#define LL long long
#define maxn 50010
#define INF 1 << 30
#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#define L rt << 1
#define R rt << 1 | 1
#define For(i, n) for (int i = 1; i <= n; i++)
using namespace std;
int n, m, a[maxn];LL ans;
struct SegmentTree {
    LL left[maxn << 2], right[maxn << 2], tot[maxn << 2], sum[maxn << 2];
    void Update(int rt) {
        sum[rt] = sum[L] + sum[R];
        tot[rt] = max(tot[L], tot[R]); tot[rt] = max(tot[rt], left[R] + right[L]);
        left[rt] = max(left[L], sum[L] + left[R]);
        right[rt] = max(right[R], sum[R] + right[L]);
    }
    void build(int l, int r, int rt) {
        if (l == r) {
            sum[rt] = left[rt] = right[rt] = tot[rt] = a[l];
            return;
        }
        int mid = (l + r) >> 1;
        build(lson), build(rson), Update(rt);
    }
    void Change(int key, int val, int l, int r, int rt) {
        if (l == r) {
            sum[rt] = tot[rt] = left[rt] = right[rt] = val;
            return;
        }
        int mid = (l + r) >> 1;
        if (key <= mid) Change(key, val, lson); else Change(key, val, rson);
        Update(rt);
    }
    LL Query(int flag, int x, int y, int l, int r, int rt) {
        int mid = (l + r) >> 1;
        if (x <= l && r <= y) {
            ans = max(ans, tot[rt]);
            if (flag) return right[rt]; else return left[rt];
        }
        if (y <= mid) return Query(0, x, y, lson); else if (mid + 1 <= x) return Query(1, x, y, rson);
        LL ln = Query(1, x, y, lson), rn = Query(0, x, y, rson); ans = max(ans, ln + rn);
        if (flag) return max(right[R], sum[R] + ln); else return max(left[L], sum[L] + rn);
    }
}seg;
int main() {
    while (scanf("%d", &n) == 1) {
        For(i, n) scanf("%d", &a[i]); seg.build(1, n, 1);
        scanf("%d", &m);
        while (m--) {
            int x, y, z; scanf("%d%d%d", &z, &x, &y);
            if (z == 0) seg.Change(x, y, 1, n, 1);
            else {
                ans = -INF; seg.Query(0, x, y, 1, n, 1);
                printf(LLD "\n", ans);
            }
        }
    }
    return 0;
}

 

GSS4

Can you answer these queries IV : http://www.spoj.com/problems/GSS4/

区间求和+将给定区间内所有元素更新为其算数平方根

（考虑一个数开根次数有限，当多次开根后，最后被开成0或1就不用再更新了。只用记录每一个数是否能继续开根，每次更新时就沿着没有开尽的地方更新到底）

Code:

#ifdef unix
#define LLD "%lld"
#else
#define LLD "%I64d"
#endif
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
#include <iostream>
#include <cmath>
#define LL long long
#define maxn 100010
#define INF 1 << 30
#define For(i, n) for (int i = 1; i <= n; i++)
#define rep(i, j, k) for (int i = j; i <= k; i++)
#define L rt << 1
#define R rt << 1 | 1
#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
using namespace std;
void file(string s) {
    string in = s + ".in", ou = s + ".out";
    freopen(in.c_str(), "r", stdin);
    freopen(ou.c_str(), "w", stdout);
}
LL a[maxn];int n;
struct SegmentTree {
    LL sum[maxn << 2];int done[maxn << 2];
    void Update(int rt) {
        sum[rt] = sum[L] + sum[R];
        if (done[L] && done[R]) done[rt] = 1; else done[rt] = 0;
    }
    void build(int l, int r, int rt) {
        int mid = (l + r) >> 1;
        if (l == r) {
            sum[rt] = a[l];
            if (a[l] == 0 || a[l] == 1) done[rt] = 1; else done[rt] = 0;
            return;
        }
        build(lson), build(rson), Update(rt);
    }
    void dfs(int l, int r, int rt) {
        int mid = (l + r) >> 1;
        if (l == r) {
            sum[rt] = (LL) sqrt(sum[rt] + 0.5);
            if (sum[rt] == 0 || sum[rt] == 1) done[rt] = 1;
            return;
        }
        if (!done[L]) dfs(lson); if (!done[R]) dfs(rson);
        Update(rt);
    }
    LL Query(int x, int y, int l, int r, int rt) {
        int mid = (l + r) >> 1;
        if (x <= l && r <= y) return sum[rt];
        if (mid >= y) return Query(x, y, lson);
        else if (mid + 1 <= x) return Query(x, y, rson);
        else return Query(x, y, lson) + Query(x, y, rson);
    }
    void Change(int x, int y, int l, int r, int rt) {
        int mid = (l + r) >> 1;
        if (x <= l && r <= y) {if(!done[rt]) dfs(l, r, rt);return;}
        if (mid >= x) Change(x, y, lson);
        if (mid + 1 <= y) Change(x, y, rson);
        Update(rt);
    }
}seg;
int main() {
    //file("1");
    int CAS = 1, q, x, y, z;
    while (scanf("%d", &n) == 1) {
        For(i, n) scanf(LLD, &a[i]);
        seg.build(1, n, 1);
        printf("Case #%d:\n", CAS++);
        scanf("%d", &q);
        For(i, q) {
            scanf("%d%d%d", &z, &x, &y); if (x > y) swap(x, y);
            if (z == 0) seg.Change(x, y, 1, n, 1);
            else printf(LLD "\n", seg.Query(x, y, 1, n, 1));
        }
        printf("\n");
    }
    return 0;
}

 

GSS5

Can you answer these queries V : http://www.spoj.com/problems/GSS5/

考虑两种情况：

1、两个区间隔开-> [x1,y1].....[x2,y2]，所以[y1,x2]这段区间是必须计算的，然后计算出y1为右端店向左的左区间最大子序和、x2为左端点向右的最大子序和。

2、两个区间交错-> [x1,.....[x2,y1],.....y2],我们分3种情况讨论：

　　1）x1<=i<=x2, x2<=j<=y2:left[x1, x2-1]+a[x2]+right[x2+1, y2]

　　2）x2<=i<=y1, y1<=j<=y2:left[x1, y1-1]+a[y1]+right[y1+1, y2]

　　3）x2<=i<=j<=y1:tot[x1, y1]

注：三个标记：tot（区间最大子序和），left（从区间左端开始向右的最大子序和），right（从区间右端开始向左的最大子序和）

Code:

#include <cstdio>
#include <cstring>
#include <algorithm>
#define maxn 10010
#define L rt << 1
#define R rt << 1 | 1
#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#define INF 0x3f3f3f3f
#define For(i, n) for (int i = 1; i <= n; i++)
using namespace std;
int n, sum[maxn], a[maxn];
struct SegmentTree {
    int tot[maxn << 2], left[maxn << 2], right[maxn << 2];
    void Update(int l, int r, int rt) {
        int mid = (l + r) >> 1;
        tot[rt] = max(tot[L], tot[R]); tot[rt] = max(tot[rt], right[L] + left[R]);
        left[rt] = max(left[L], sum[mid] - sum[l - 1] + left[R]);
        right[rt] = max(right[R], sum[r] - sum[mid] + right[L]);
    }
    void build(int l, int r, int rt) {
        int mid = (l + r) >> 1;
        if (l == r) {
            tot[rt] = left[rt] = right[rt] = a[l];
            return;
        }
        build(lson), build(rson), Update(l, r, rt);
    }
    int Query(int flag, int x, int y, int &ans, int l, int r, int rt) {
        int mid = (l + r) >> 1;
        if (x <= l && r <= y) {
            ans = max(ans, tot[rt]);
            if (flag) return right[rt]; else return left[rt];
        }
        if (mid >= y) return Query(0, x, y, ans, lson); else if (mid + 1 <= x) return Query(1, x, y, ans, rson);
        int ln = Query(1, x, y, ans, lson), rn = Query(0, x, y, ans, rson);
        ans = max(ans, ln + rn);
        if (flag) return max(right[R], sum[r] - sum[mid] + ln); else return max(left[L], sum[mid] - sum[l - 1] + rn);
    }
    void Search(int flag, int x, int y, int &ans, int l, int r, int rt) {
        int mid = (l + r) >> 1;
        if (x <= l && r <= y) {
            if (flag) ans = max(ans, sum[y] - sum[r] + right[rt]); else ans = max(ans, sum[l - 1] - sum[x - 1] + left[rt]);
            return;
        }
        if (mid >= x) Search(flag, x, y, ans, lson);
        if (mid + 1 <= y) Search(flag, x, y, ans, rson);
    }
    void init() {
        scanf("%d", &n);
        sum[0] = 0; For(i, n) scanf("%d", &a[i]), sum[i] = sum[i - 1] + a[i];
        build(1, n, 1);
    }
}seg;

int main() {
    int CAS; scanf("%d", &CAS);
    while (CAS--) {
        seg.init();
        int q, ans, t1, t2, x1, x2, y1, y2; scanf("%d", &q);
        For(i, q) {
            scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
            if (y1 < x2) {
                t1 = t2 = -INF;
                seg.Search(1, x1, y1, t1, 1, n, 1);
                seg.Search(0, x2, y2, t2, 1, n, 1);
                printf("%d\n", t1 + t2 + sum[x2 - 1] - sum[y1]);
            }
            else {
                ans = -INF;
                seg.Query(0, x2, y1, ans, 1, n, 1);
                t1 = t2 = -INF;
                seg.Search(1, x1, y1, t1, 1, n, 1);
                seg.Search(0, y1, y2, t2, 1, n, 1);
                ans = max(ans, t1 + t2 - a[y1]);
                t1 = t2 = -INF;
                seg.Search(1, x1, x2, t1, 1, n, 1);
                seg.Search(0, x2, y2, t2, 1, n, 1);
                ans = max(ans, t1 + t2 - a[x2]);
                printf("%d\n", ans);
            }
        }
    }
    return 0;
}

 

GSS6

Can you answer these queries VI : http://www.spoj.com/problems/GSS6/

呃，就是有插入，删除，修改操作，其他的区间最大子序和就向前几题那样处理。 我为了方便，弄了一颗平衡树，结果巨慢巨卡， T了好几次后加了读入优化，勉强AC。囧

Code:

#include <cstdio>
#include <algorithm>
#include <string>
#define maxn 210005
#define INF 0x3f3f3f3f
#define For(i, n) for (int i = 1; i <= n; i++)
#define L ch[x][0]
#define R ch[x][1]
#define lson l, mid - 1, x
#define rson mid + 1, r, x
using namespace std;
int n;
struct SplayTree {
    int sz[maxn], pre[maxn], val[maxn], cnt[maxn], ch[maxn][2], left[maxn], right[maxn], sum[maxn], tot[maxn], a[maxn], rt, top;
    void up(int x) {
        sz[x] = sz[L] + sz[R] + 1;
        sum[x] = sum[L] + sum[R] + val[x];
        tot[x] = max(right[L], 0) + val[x] + max(left[R], 0); tot[x] = max(tot[x], max(tot[L], tot[R]));
        left[x] = max(left[L], sum[L] + val[x] + max(left[R], 0));
        right[x] = max(right[R], sum[R] + val[x] + max(right[L], 0));
    }
    void Rotate(int x, int f) {
        int y = pre[x];
        ch[y][!f] = ch[x][f];
        pre[ch[x][f]] = y;
        pre[x] = pre[y];
        if (pre[x]) ch[pre[y]][ch[pre[y]][1] == y] = x;
        ch[x][f] = y;
        pre[y] = x;
        up(y);
    }
    void Splay(int x, int goal) {
        while (pre[x] != goal) {
            if (pre[pre[x]] == goal) Rotate(x, ch[pre[x]][0] == x);
            else {
                int y = pre[x], z = pre[y], f = (ch[z][0] == y);
                if (ch[y][f] == x) Rotate(x, !f), Rotate(x, f); else Rotate(y, f), Rotate(x, f);
            }
        }
        up(x);
        if (goal == 0) rt = x;
    }
    void RTO(int k, int goal) {
        int x = rt;
        while (k != sz[L] + 1)
            if (k <= sz[L]) x = L; else k -= (sz[L] + 1), x = R;
        Splay(x, goal);
    }
    void Newnode(int &x, int key) {
        x = ++top;
        sz[x] = 1;
        val[x] = sum[x] = tot[x] = left[x] = right[x] = key;
        L = R = 0;
    }
    void build(int &x, int l, int r, int f) {
        int mid = (l + r) >> 1;
        Newnode(x, a[mid]);
        pre[x] = f;
        if (l == r) return;
        if (l < mid) build(L, lson);
        if (mid < r) build(R, rson);
        up(x);
    }
    void init() {
        For(i, n) a[i] = INT();
        top = sz[0] = sum[0] = 0;
        tot[0] = right[0] = left[0] = -INF;
        Newnode(rt, 0), Newnode(ch[rt][1], 0);
        pre[ch[rt][1]] = rt;
        val[rt] = val[ch[rt][1]] = 0;
        if (n) build(ch[ch[rt][1]][0], 1, n, ch[rt][1]);
        up(ch[rt][1]), up(rt);
    }
    void Delete(int x) {
        RTO(x, 0), RTO(x + 2, rt);
        ch[ch[rt][1]][0] = 0;
        up(ch[rt][1]), up(rt);
    }
    void Insert(int x, int y) {
        RTO(x, 0), RTO(x + 1, rt); 
        Newnode(ch[ch[rt][1]][0], y);
        pre[top] = ch[rt][1];
        up(ch[rt][1]), up(rt);
    }
    void Change(int x, int y) {
        RTO(x + 1, 0);
        val[rt] = y;
        up(rt);
    }
    void Query(int l, int r) {
        RTO(l, 0), RTO(r + 2, rt);
        printf("%d\n", tot[ch[ch[rt][1]][0]]);
    }
    int INT() {
        int ret, neg; char ch;
        while (ch = getchar(), !isdigit(ch) && ch != '-');
        if (ch == '-') ret = 0, neg = 1; else ret = ch - '0', neg = 0;
        while (ch = getchar(), isdigit(ch)) ret = ret * 10 + ch - '0';
        if (neg) return -ret; else return ret;
    }
    char CHAR() {
        char ret;
        while (ret = getchar(), !isalpha(ret));
        return ret;
    }
    void solve() {
        int q, x, y; char op;
        init();
        q = INT();
        For(i, q) {
            op = CHAR();
            if (op == 'D') x = INT(), Delete(x);
            else {
                x = INT(), y = INT();
                if (op == 'I') Insert(x, y); else if (op == 'R') Change(x, y); else Query(x, y);
            }
        }
    }
}spt;
int main() {
    while (scanf("%d", &n) == 1) {
        spt.solve();
    }
    return 0;
}

 

GSS7

Can you answer these queries VII : http://www.spoj.com/problems/GSS7/

（呃。改天写吧，又囧。） srO zhonghaoxi Orz