[hdoj5192] 树状数组

枚举所有的区间。对于确定的区间，假设最终的高度为h，
代价是max(∑(Hi−h),∑(h−Hj))（Hi＞h,Hj≤h)
等价于max(∑Hi−cnt(i)∗h,cnt(j)∗h−∑Hj)
(cnt(i)表示满足Hi＞h的堆数, cnt(j)表示满足Hj≤h 的堆数)。∑Hi−cnt(i)∗h关于h呈递减，cnt(j)∗h−∑Hj关于h呈递增。一个递减到0，一个从0开始递增，所以代价与h的函数图像是V字形的，交点处代价最小。此时 ∑Hi−cnt(i)∗h=cnt(j)∗h−∑Hj，h=∑Hi+∑Hjcnt(i)+cnt(j)，分母是总堆数W，分子是这个区间积木的总个数。h实际上就是这个区间的平均高度aver。考虑到四舍五入，答案是aver或者aver+1，当然还需要与题目给定的H做下比较，最终的方案是这3个数之一。确定高度之后，把高的变矮需要知道比当前高度大的个数以及高度总和，把矮的变高类似。因此添加一堆和删除一堆时，需要维护个数和总和。可以通过树状数组维护，整个问题的复杂度O((n+W)logn).
代码如下：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <map>
#include <queue>
#include <cmath>
#include <vector>
#include <ctime>
#include <cctype>

using namespace std;

#define mem0(a) memset(a, 0, sizeof(a))
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
#define define_m int m = (l + r) >> 1
#define Rep(a, b) for(int a = 0; a < b; a++)
#define lowbit(x) ((x) & (-(x)))
#define constructInt3(name, a, b, c) name(int a = 0, int b = 0, int c = 0): a(a), b(b), c(c) {}
#define constructInt2(name, a, b) name(int a = 0, int b = 0): a(a), b(b) {}

typedef double db;
typedef long long LL;

const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, -1, 0, 1};
const int maxn = 1e4 + 7;
const int maxm = 1e5 + 7;
const int MD = 1e9 +7;

struct Point {
    int x, y;
    bool operator < (const Point &opt) const {
        return x < opt.x || x == opt.x && y < opt.y;
    }
    Point operator - (const Point &opt) const {
        return Point(x - opt.x, y - opt.y);
    }
    constructInt2(Point, x, y);
    void inp() {
        scanf("%d %d", &x, &y);
    }
    void outp() {
        printf("(%d, %d), ", x, y);
    }
};

struct Trie {
        const static int char_size = 26;
        int cc;
        int cht[100010][char_size];
        int mark[100010];
        Trie() { cc = 0; mem0(mark); mem0(cht); }
        int Idex(char ch) { return ch - '0'; }
        void Insert(char s[], int v) {
                int pos = 0;
                for(int i = 0; s[i]; i++) {
                        int id = Idex(s[i]);
                        if(!cht[pos][id]) cht[pos][id] = ++cc;
                        pos = cht[pos][id];
                }
                mark[pos] = v;
        }
        bool Find(char s[]) {
                int pos = 0;
                for(int i = 0; s[i]; i++) {
                        int id = Idex(s[i]);
                        if(!cht[pos][id]) return 0;
                        pos = cht[pos][id];
                }
                return mark[pos];
        }
};

struct KMP {
        int next[1000010];
        void GetNext(char s[]) {
                mem0(next);
                next[0] = next[1] = 0;
                for(int i = 1; s[i]; i++) {
                        int j = next[i];
                        while(j && s[i] != s[j]) j = next[j];
                        next[i + 1] = s[j] == s[i]? j + 1 : 0;
                }
        }
        void Match(char s[], char t[]) {
                int j = 0, len = strlen(t);
                for(int i = 0; s[i]; i++) {
                        while(j && s[i] != t[j]) j = next[j];
                        if(s[i] == t[j]) j++;
                        if(j == len) printf("%d
", i - len + 1);
                }
        }
};

struct Matrix {
        int a[3][3];
        Matrix operator * (const Matrix &_A) const {
                Matrix tmp;
                mem0(tmp.a);
                for(int i = 0; i < 3; i++) {
                        for(int j = 0; j < 3; j++) {
                                for(int k = 0; k < 3; k++) {
                                        tmp.a[i][j] = ((LL)a[i][k] * _A.a[k][j] + tmp.a[i][j]) % MD;
                                }
                        }
                }
                return tmp;
        }
};

struct Edge {
    int u, v;
    constructInt2(Edge, u, v);
};

struct Segment {
        Point a, b;
        void inp() {
                scanf("%d%d%d%d", &a.x, &a.y, &b.x, &b.y);
                if(a.x > b.x) {
                        swap(a.x, b.x);
                        swap(a.y, b.y);
                }
        }
};

Matrix CalcMatrix(Matrix a, int n) {
        if(n == 1) return a;
        Matrix tmp = CalcMatrix(a, n >> 1);
        tmp = tmp * tmp;
        if(n & 1) tmp = tmp * a;
        return tmp;
}

inline int ReadInt() {
    char c = getchar();
    while(!isdigit(c)) c = getchar();

    int x = 0;
    while(isdigit(c)) {
        x = x * 10 + c - '0';
        c = getchar();
    }
    return x;
}

inline void WriteInt(int i) {
    int p = 0;
    static int buf[10];
    if(i == 0) p++;
    else while(i) {
        buf[p++] = i % 10;
        i /= 10;
    }
    for(int j = p - 1; j; j--) putchar('0' + buf[j]);
}

int Cross(Point a, Point b) {
    return a.x * b.y - a.y * b.x;
}

int Dist2(Point a, Point b) {
    int x = a.x - b.x, y = a.y - b.y;
    return x * x + y * y;
}
int ConvexHull(Point *p, int n, Point *ch) {
    sort(p, p + n);
    int m = 0;
    for (int i = 0; i < n; i++) {
        while (m > 1 && Cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2]) <= 0) m--;
        ch[m++] = p[i];
    }
    int k = m;
    for (int i = n - 2; i >= 0; i--) {
        while (m > k && Cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2]) <= 0) m--;
        ch[m++] = p[i];
    }
    if (n > 1) m--;
    return m;
}

template<class edge> struct Graph {
    vector<vector<edge> > adj;
    Graph(int n) { adj.clear(); adj.resize(n + 5); }
    Graph() { adj.clear(); }
    void resize(int n) { adj.resize(n + 5); }
    void add(int s, edge e){ adj[s].push_back(e); }
    void del(int s, edge e) { adj[s].erase(find(iter(adj[s]), e)); }
    void clear() { adj.clear(); }
    vector<edge>& operator [](int t) { return adj[t]; }
};

template<class T> struct TreeArray {
    vector<T> c;
    int maxn;
    TreeArray(int n) { c.resize(n + 5); maxn = n; }
    TreeArray() { c.clear(); maxn = 0; }
    void clear() { memset(&c[0], 0, sizeof(T) * maxn); }
    void resize(int n) { c.resize(n + 5); maxn = n; }
    void add(int p, T x) { while (p < maxn) { c[p] += x; p += lowbit(p); } }
    T get(int p) { T res = 0; while (p) { res += c[p]; p -= lowbit(p); } return res; }
    T range(int a, int b) { return get(b) - get(a - 1); }
};

int n, W, H, a[160000];
LL sum[160000], step, maxh;
TreeArray<LL> ta(50001), ta0(50001);
void Check(int h, int r) {
    if (sum[n + 2 * W - 1] < (LL)h * W) return ;
    LL sum1 = ta0.get(h + 1), sumall = sum[r] - sum[r - W], c = ta.get(h + 1);
    LL newsum1 = h * c - sum1, newsum2 = sumall - h * W + newsum1;
    LL res = max(newsum1, newsum2);
    if (res < step || res == step && h > maxh) {
        step = res;
        maxh = h;
    }
}
int main() {
    //freopen("in.txt", "r", stdin);
    while (cin >> n >> W >> H) {
        mem0(a);
        for (int i = 0; i < n; i++) {
            scanf("%d", a + i + W);
        }
        int total = n + 2 * W;
        for (int i = 1; i < total; i++) sum[i] = sum[i - 1] + a[i];

        if (sum[total - 1] < (LL)H * W) {
            puts("-1");
            continue;
        }

        ta.clear();
        ta0.clear();
        step = H * W;
        maxh = H;
        ta.add(1, W );
        ta0.add(1, 0);

        for (int i = W; i < total; i++) {
            int num = sum[i] - sum[i - W], ave = num / W;
            if (ave < H) ave = H;
            ta.add(a[i - W] + 1, -1);
            ta0.add(a[i - W] + 1, -a[i - W]);
            ta.add(a[i] + 1, 1);
            ta0.add(a[i] + 1, a[i]);
            Check(ave, i);
            Check(ave + 1, i);
        }
        cout << maxh << " " << step << endl;
    }
    return 0;
}