CF1541

CF1541

A 求一个排列，使得没有p[i] = i且最小化Σ(|p[i] - i|)

显然如果是偶数就相邻的交换，奇数就只有一组是三个轮换，剩下的两个换

B n个不同的数构成一个数组，问你有多少对i,j满足a[i] * a[j] == i + j，1e5

一开始没看到不同结果不会做。

枚举a[i]是多少，那么a[j]不会超过2 * n / a[i]，取值个数是调和级数nlogn的，再枚举a[j]，看有没有这样的i和j满足条件即可。

C 构造一个有向图，使得从1到每个点的最短路是给定的数组d，求所有边权的和的最小值。可以有负值，不能有负环重边

先把点排序，按顺序连起来，够成一条单向链。

然后每两个点之间再连一条负权反向边，够成0环。这样就是最小值。

D 给你一棵树，每次可以等概率选择一个根，然后从已选的点相邻点中等概率选下一个，构成一个序列，求这个序列逆序对的期望。n <= 200

考虑每个点对。如果开始的根在某个点的子树内，那一定先到那个点。如果开始的根在这两点的路径上，或者路径上某一点的子树上，那么先到哪个点是有个概率的。

设左边有l个点，右边有r个点，先到r的概率是g[l][r]，左边已经到了l个点，右边已经到了r个点的概率是f[l][r]，那么f可以很简单的* 1/2求出来，g可以用f的前缀和求出来。

然后考虑选择的那点对上的路径，中间每个点乘根在子树内概率乘先到大的点的概率 就行了。

#include <bits/stdc++.h>

typedef long long LL;

const int N = 210;
const LL MO = 1e9 + 7, inv2 = 5e8 + 4;

struct Edge {
    int nex, v;
}edge[N * 2]; int tp;

int n, e[N], siz[N], d[N], fa[N];
LL f[N][N], g[N][N];
LL ans;

LL qpow(LL a, LL b) {
    a %= MO;
    LL ans = 1;
    while(b) {
        if(b & 1) {
            ans = ans * a % MO;
        }
        a = a * a % MO;
        b = b >> 1;
    }
    return ans;
}

inline void add(int x, int y) {
    ++tp;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

void DFS1(int x, int f) {
    siz[x] = 1;
    d[x] = d[f] + 1;
    fa[x] = f;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == f) {
            continue;
        }
        DFS1(y, x);
        siz[x] += siz[y];
    }
    return;
}

void DFS2(int x, int r) {
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == fa[x]) {
            continue;
        }
        DFS2(y, r);
    }
    if(x > r) {
        int p = x;
        while(fa[p] != r) {
            // cal fa[p]
            ans += 1ll * (siz[fa[p]] - siz[p]) * g[d[fa[p]]][d[x] - d[fa[p]]] % MO;
            ans %= MO;
            // printf("ans += %d * %lld 
", siz[fa[p]] - siz[p], g[d[fa[p]]][d[x] - d[fa[p]]]);
            p = fa[p];
        }
        ans = (ans + siz[x]) % MO;
        // printf("ans += %d 
", siz[x]);
    }
    return;
}

int main() {
    scanf("%d", &n);
    for(int i = 1, x, y; i < n; i++) {
        scanf("%d%d", &x, &y);
        add(x, y);
        add(y, x);
    }
    
    // prework
    f[0][0] = 1;
    for(int i = 1; i <= n; i++) {
        f[i][0] = f[0][i] = f[0][i - 1] * inv2 % MO;
    }
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            f[i][j] = f[i][j - 1] * inv2 + f[i - 1][j] * inv2;
            f[i][j] %= MO;
        }
    }
    for(int i = 0; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            // cal g[i][j]
            for(int k = 0; k < i; k++) {
                g[i][j] = (g[i][j] + f[k][j - 1] * inv2 % MO) % MO;
            }
        }
    }

    // printf("%lld 
", g[2][1]);

    // solve
    d[0] = -1;
    for(int x = 1; x <= n; x++) {
        // x is smaller one
        DFS1(x, 0);
        DFS2(x, x);
        // puts("");
    }
    // printf("ans = %lld
", ans);
    printf("%lld
", ans * qpow(n, MO - 2) % MO);
    return 0;
}

E