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<<" = "<<x<<endl

#include <bits/stdc++.h>

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;
}

/*




 */