#include <stdio.h>
#include <stdlib.h>

typedef struct _CHILD
{
    int height;
    int unhappiness;
    int increment;
} CHILD;

int main(void)
{
    int n, i, j, count;
    CHILD *children;
    CHILD child;
    scanf("%d", &n);
    children = (CHILD *)malloc(n * sizeof(CHILD));
    for (i = 0; i < n; i++)
    {
        scanf("%d", &children[i].height);
        children[i].unhappiness = 0;
        children[i].increment = 1;
    }
    for (i = 0; i < n - 1; i++)
    {
        for (j = 0; j < n - 1 - i; j++)
        {
            if (children[j].height > children[j + 1].height)
            {
                children[j].unhappiness += children[j].increment;
                children[j].increment++;
                children[j + 1].unhappiness += children[j + 1].increment;
                children[j + 1].increment++;
                child = children[j];
                children[j] = children[j + 1];
                children[j + 1] = child;
            }
        }
    }
    count = 0;
    for (i = 0; i < n; i++)
    {
        count += children[i].unhappiness;
    }
    printf("%d\n", count);
    free(children);
    return 0;
}

楼上的代码是直接采用的冒泡排序法。
但是只能过30%的数据：

得分为30分（总比零分好）

如果要完全正确，必须要用到线性代数里面的逆序的知识。

也就是说，C语言课程里所学的所有的排序算法都不能用

不过可以直接用冒泡排序法，先得30分走人，总比0分好

n级排列中的最小逆序数。。。。

把int改long long后，得分增加了20：

【代码】
#include <stdio.h>
#include <stdlib.h>

typedef struct _CHILD
{
    int height;
    long long unhappiness;
    long long increment;
} CHILD;

int main(void)
{
    int n, i, j;
    long long count;
    CHILD *children;
    CHILD child;
    scanf("%d", &n);
    children = (CHILD *)malloc(n * sizeof(CHILD));
    for (i = 0; i < n; i++)
    {
        scanf("%d", &children[i].height);
        children[i].unhappiness = 0;
        children[i].increment = 1;
    }
    for (i = 0; i < n - 1; i++)
    {
        for (j = 0; j < n - 1 - i; j++)
        {
            if (children[j].height > children[j + 1].height)
            {
                children[j].unhappiness += children[j].increment;
                children[j].increment++;
                children[j + 1].unhappiness += children[j + 1].increment;
                children[j + 1].increment++;
                child = children[j];
                children[j] = children[j + 1];
                children[j + 1] = child;
            }
        }
    }
    count = 0;
    for (i = 0; i < n; i++)
    {
        count += children[i].unhappiness;
    }
    printf("%I64d\n", count);
    free(children);
    return 0;
}

也就是说，用64位整型变量+上学期学的冒泡排序法，就能搞定一半的分数。

由于每次只能交换位置相邻的两个小朋友，所以不能使用选择排序法和插入排序法。