題意

給定一個長度為n的數組A，將它變為一顆k叉樹（1 <= k <= n - 1)（堆的形式編號）。
問對於每一個k，有多少個節點小於它的父節點。

解題

顯然，最初的想法是暴力。因為樹的層數到後來好像挺小的。但是仔細看復雜度，好像穩穩的O(n^2)。
那就尷尬了。考慮用數據結構優化。

看其他dalao切此題，用的都是主席樹、函數式線段樹之類的，但juruo我都沒學過怎麽辦qwq
於是只能好生考慮一番.
我們發現：1、一個節點的兒子在原序列中一定是連續的；2、能對某個節點造成貢獻的兒子節點的值一定小於該節點。
於是我們就有如下做法：把節點按值排序，從小到大枚舉每個節點。對於k叉數，它兒子中被處理過的節點數，就是這個點對答案中k叉樹情況的貢獻。
由於2，我們不難得到該做法的正確性。我們再來考慮這個做法的時間復雜度。對於每個點，我們僅考慮它不是樹葉的情況。所以實際上對於每個k，我們只考慮了n/k個點。這是O(nlogn)的。然後查詢由於結論1，我們可以由樹狀數組維護，復雜度O(logn)。所以總復雜度O(nlogn^2)。並不會超時。

代碼實現

我們將編號從0開始，這樣更方便。
我們每次處理好一個節點後就在它原數組的位置上標上1，這樣就可一直接用樹狀數組求和。

#include<bits/stdc++.h>
using namespace std;
struct Node{
    int x, id;
    Node(int x_ = 0, int id_ = 0) {x = x_; id = id_;}
};
const int MAXN = 200010;
int n, x, ans[MAXN], tree[MAXN];
Node a[MAXN];

bool cmp(Node x, Node y){
    return x.x < y.x || x.x == y.x && x.id < y.id;
}

int lowbit(int x){ return x & (-x); }

int ask(int x){
    int t = 0;
    while(x){
        t += tree[x];
        x -= lowbit(x);
    }
    return t;
}

void add(int x){
    if(x == 0) return;
    while(x < n){
        tree[x]++;
        x += lowbit(x);
    }
    return;
}

int main(){
    scanf("%d", &n);
    for(int i = 0; i < n; i++){
        scanf("%d", &x);
        a[i] = Node(x, i);
    }
    sort(a, a + n, cmp);
    memset(ans, 0, sizeof(ans));
    for(int i = 0; i < n; i++){
        for(int k = 1; k * a[i].id + 1 < n && k < n; k++){
            ans[k] += ask(min(k * a[i].id + k, n - 1)) - ask(k * a[i].id);
        }
        add(a[i].id);
    }
    for(int i = 1; i < n; i++) printf("%d ", ans[i]); printf("\n");
    return 0;
}
 

CodeForces 538F A Heap of Heaps