【CodeForces】91E Igloo Skyscraper

题意：

n幢摩天大楼，第i幢初始高度为a[i]，每个单位时间增长b[i]。

询问区间[x,y]的大楼在t时刻的最大高度。

虽然是区间查询，线段树不会搞。

先读入询问，对时间非降排序，离线搞是很显然的。

分成sqrt(n)块，在区间内的每块在常数时间内得到答案，两端暴力答案。

高度y[i]=a[i]+b[i]*t，是直线方程。所以每块在常数时间得到答案，就要维护每块直线的单调性，剔除不影响答案的直线。

由于块内答案是递增的，所以直线的斜率也是递增的。所以对每块的直线斜率非降排序。

设有k1，k2，k3三条直线，且斜率递增，若k1与k2的交点在k3的下方，那么k2显然是多余的。

纸上yy一下，比较时把除法化为乘法，类似求凸包的思想就可以做到的。

总复杂度 O(nsqrt(n))。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<vector>
typedef long long LL;
#define MAXN 100010
#define MAXM 320
#define EPS 1e-8
using namespace std;
int n, block;
struct node {
    int pos, high, inc;
};
struct seg {
    int pos, x, y, t;
};
node a[MAXN];
seg p[MAXN];
vector<node> b[MAXM];
int pt[MAXM], ans[MAXN];
inline bool cmp1(seg a, seg b) {
    return a.t < b.t;
}
inline bool cmp2(node a, node b) {
    return a.inc < b.inc;
}
void Init() {
    int i;
    memset(pt, 0, sizeof(pt));
    block = (int) (ceil(sqrt((double) n)) + EPS);
    for (i = 0; i < block; i++)
        b[i].clear();
}
inline bool Delete(LL a0, LL b0, LL a1, LL b1, LL a2, LL b2) {
    return b0 * a1 - a0 * b1 <= a2 * (b0 - b1) + b2 * (a1 - a0);
}
void Increase() {
    int i, j, k;
    vector<node> tmp;
    for (i = 0; i < block; i++) {
        tmp.clear();
        for (j = 0; j < (int) b[i].size(); j++)
            tmp.push_back(b[i][j]);
        b[i].clear();
        sort(tmp.begin(), tmp.end(), cmp2);
        for (j = 0; j < (int) tmp.size(); j++) {
            while (b[i].size() > 1) {
                k = (int) b[i].size() - 1;
                if (Delete(b[i][k].high, b[i][k].inc, b[i][k - 1].high,
                        b[i][k - 1].inc, tmp[j].high, tmp[j].inc))
                    b[i].pop_back();
                else
                    break;
            }
            b[i].push_back(tmp[j]);
        }
    }
}
int Query(int x, int y, int t) {
    LL res, tmp;
    int pos, nd, p, q, i;
    p = x / block;
    q = y / block;
    res = 0;
    if (p == q) {
        for (i = x; i <= y; i++) {
            tmp = (LL) a[i].inc * t + a[i].high;
            if (tmp > res) {
                res = tmp;
                pos = i;
            }
        }
    } else {
        if (x % block) {
            for (nd = min(p * block + block, n); x < nd; x++) {
                tmp = (LL) a[x].inc * t + a[x].high;
                if (tmp > res) {
                    res = tmp;
                    pos = x;
                }
            }
        }
        if (y % block != block - 1) {
            for (nd = max(q * block, 1); y >= nd; y--) {
                tmp = (LL) a[y].inc * t + a[y].high;
                if (tmp > res) {
                    res = tmp;
                    pos = y;
                }
            }
        }
        for (p = x / block; x <= y; x += block, p++) {
            while (pt[p] < (int) b[p].size() - 1) {
                if ((LL) b[p][pt[p]].inc * t + b[p][pt[p]].high
                        <= (LL) b[p][pt[p] + 1].inc * t + b[p][pt[p] + 1].high)
                    pt[p]++;
                else
                    break;
            }
            tmp = (LL) b[p][pt[p]].inc * t + b[p][pt[p]].high;
            if (tmp > res) {
                res = tmp;
                pos = b[p][pt[p]].pos;
            }
        }
    }
    return pos;
}
int main() {
    int i, q;
    while (~scanf("%d%d", &n, &q)) {
        Init();
        for (i = 1; i <= n; i++) {
            scanf("%d%d", &a[i].high, &a[i].inc);
            a[i].pos = i;
            b[i / block].push_back(a[i]);
        }
        for (i = 0; i < q; i++) {
            scanf("%d%d%d", &p[i].x, &p[i].y, &p[i].t);
            p[i].pos = i;
        }
        sort(p, p + q, cmp1);
        Increase();
        for (i = 0; i < q; i++)
            ans[p[i].pos] = Query(p[i].x, p[i].y, p[i].t);
        for (i = 0; i < q; i++)
            printf("%d\n", ans[i]);
    }
    return 0;
}