HDU-6601 三角形 主席树 斐波那契数列

给n个边的长度，询问q次，每次询问回答能构成的三角形的最大周长。

n和q都是$1e5$的范围。

---

先想想如果就给一个数组求最大周长三角形的做法。

容易想到就是排个序，从大到小枚举N-2次，每次检查三条边能不能构成三角形，如果不行，那么最大的那条边就没有其他边可以跟他组了，（其他边都更小）。如果遇到了第一个可行的，那么就是最大周长的三角形的三边了。

上面这种算法是$O(NlogN)$的，还要排序，直接用来解多次询问的题目里显然不行，复杂度有$O(QNlogN)$。

对于从大到小枚举，容易想到用主席树来维护每次$O(logN)$得到第k大的值，复杂度还是有$O(QNlogN)$。

但其实我们不需要枚举N次才知道结果。

这里我们需要引入一个insight

假设有一个很长的数组，任取三条边都不能组成三角形，有一个结论就是，斐波那契数列（每项等于前两项的和）。但是斐波那契数列增长地很快，在第45位的时候已经超过了$1e9$。

所以，给一组范围在$1e9$的数字，如果个数超过44，那么就必定会有一个数打破斐波那契数列的情形，等价于必定存在三边能构成一个三角形。

在这题里，降序枚举区间最大的44个数，检查能否构成三角形，必定能找到最大的。并且复杂度就降低到了$o(44QlogN)$。

这样就能过了，主席树常数大一点也不怕。（喜欢更快一点也可以手写线段树维护最大的44个数···）

#define _debug(x) cerr<<#x<<" = "<

#include 

using namespace std;

typedef long long ll;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
//const int MAXN = 3000 + 59;
const ll MOD = 998244353;
const int MAXN = 100015;

const int M = MAXN * 30;
int n, q, m, tot;
int a[MAXN], t[MAXN];
int T[MAXN], lson[M], rson[M], c[M];

void Init_hush() {
    for (int i = 1; i <= n; i++)
        t[i] = a[i];
    sort(t + 1, t + 1 + n);
    m = unique(t + 1, t + 1 + n) - t - 1;
}

int build(int l, int r) {
    int root = tot++;
    c[root] = 0;
    if (l != r) {
        int mid = (l + r) >> 1;
        lson[root] = build(l, mid);
        rson[root] = build(mid + 1, r);
    }
    return root;
}

int hush(int x) {
    return lower_bound(t + 1, t + 1 + m, x) - t;
}

int update(int root, int pos, int val) {
    int newroot = tot++, tmp = newroot;
    c[newroot] = c[root] + val;
    int l = 1, r = m;
    while (l < r) {
        int mid = (l + r) >> 1;
        if (pos <= mid) {
            lson[newroot] = tot++;
            rson[newroot] = rson[root];
            newroot = lson[newroot];
            root = lson[root];
            r = mid;
        } else {
            rson[newroot] = tot++;
            lson[newroot] = lson[root];
            newroot = rson[newroot];
            root = rson[root];

            l = mid + 1;
        }
        c[newroot] = c[root] + val;
    }
    return tmp;
}

int query(int left_root, int right_root, int k) {
    int l = 1, r = m;
    while (l < r) {
        int mid = (l + r) >> 1;
        if (c[lson[left_root]] - c[lson[right_root]] >= k) {
            r = mid;
            left_root = lson[left_root];
            right_root = lson[right_root];
        } else {
            l = mid + 1;
            k -= c[lson[left_root]] - c[lson[right_root]];
            left_root = rson[left_root];
            right_root = rson[right_root];
        }
    }
    return l;
}


ll Seg_k(int l, int r, int k) {
    return 1ll * t[query(T[l], T[r + 1], k)];
}

ll chek(int mid, int AskL, int AskR) {
    ll e1 = Seg_k(AskL, AskR, mid);
    ll e2 = Seg_k(AskL, AskR, mid - 1);
    ll e3 = Seg_k(AskL, AskR, mid - 2);

    if (e2 + e3 > e1) {
        return e1 + e2 + e3;
    } else {
        return -1;
    };
}



int main() {

    int tmp = 0;
    ll ans = 0;

    while (scanf("%d%d", &n, &q) == 2) {
        tot = 0;
        for (int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        Init_hush();
        T[n + 1] = build(1, m);
        for (int i = n; i; i--) {
            int pos = hush(a[i]);
            T[i] = update(T[i + 1], pos, 1);
        }
        while (q--) {
            int askl, askr;
            scanf("%d%d", &askl, &askr);
            int r = askr - askl + 1;
            int l = max(3, r - 48);
            ans = -1;

            for (int i = r; i >= l; i--) {
                ans = chek(i, askl, askr);
                if (ans > 0)break;
            }

            printf("%lld\n", ans);

        }
    }
    return 0;
}

/*




 */