Java实现 蓝桥杯 历届试题 小朋友排队

问题描述

　　n 个小朋友站成一排。现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。

每个小朋友都有一个不高兴的程度。开始的时候，所有小朋友的不高兴程度都是0。

如果某个小朋友第一次被要求交换，则他的不高兴程度增加1，如果第二次要求他交换，则他的不高兴程度增加2（即不高兴程度为3），依次类推。当要求某个小朋友第k次交换时，他的不高兴程度增加k。

请问，要让所有小朋友按从低到高排队，他们的不高兴程度之和最小是多少。

如果有两个小朋友身高一样，则他们谁站在谁前面是没有关系的。

输入格式

　　输入的第一行包含一个整数n，表示小朋友的个数。

　　第二行包含 n 个整数 H1 H2 … Hn，分别表示每个小朋友的身高。

输出格式

　　输出一行，包含一个整数，表示小朋友的不高兴程度和的最小值。

样例输入

3

3 2 1

样例输出

9

样例说明

　　首先交换身高为3和2的小朋友，再交换身高为3和1的小朋友，再交换身高为2和1的小朋友，每个小朋友的不高兴程度都是3，总和为9。

数据规模和约定

　　对于10%的数据， 1<=n<=10；

　　对于30%的数据， 1<=n<=1000；

　　对于50%的数据， 1<=n<=10000；

　　对于100%的数据，1<=n<=100000，0<=Hi<=1000000。

import java.util.Scanner;

public class Main {
    public static int n;
    public static person[] Child;
    public static long result = 0;

    static class person {
        public int high;  //身高
        public long count;  //调换次数

        public person(int high) {
            this.high = high;
            this.count = 0;
        }
    }

    public void mergeSort(person[] A) {
        if(A.length > 1) {
            person[] leftA = getHalf(A, 0);
            person[] rightA = getHalf(A, 1);
            mergeSort(leftA);
            mergeSort(rightA);
            Merge(A, leftA, rightA);
        }
    }

    public person[] getHalf(person[] A, int judge) {
        int len = A.length;
        person[] half;
        if(judge == 0) {
            half = new person[len / 2];
            for(int i = 0;i < half.length;i++)
                half[i] = A[i];
        } else {
            half = new person[len - len / 2];
            for(int i = 0;i < half.length;i++)
                half[i] = A[len / 2 + i];
        }
        return half;
    }

    public void Merge(person[] A, person[] leftA, person[] rightA) {
        int i = 0, j = 0;
        int lenL = leftA.length, lenR = rightA.length;
        while(i < lenL && j < lenR) {   //计算leftA中大于rightA[j]的元素个数
            if(leftA[i].high > rightA[j].high) {
                rightA[j].count += (lenL - i);
                j++;
            } else {
                i++;
            }
        }
        i = lenL - 1;
        j = lenR - 1;
        while(i >= 0 && j >= 0) {    //计算rightA中小于leftA[i]的元素个数
            if(leftA[i].high > rightA[j].high) {
                leftA[i].count += (j + 1);
                i--;
            } else {
                j--;
            }
        }
        //进行归并排序，从小到大排序
        i = 0;
        j = 0;
        int t = 0;
        while(i < lenL && j < lenR) {
            if(leftA[i].high < rightA[j].high)
                A[t++] = leftA[i++];
            else
                A[t++] = rightA[j++];
        }
        while(i < lenL)
            A[t++] = leftA[i++];
        while(j < lenR)
            A[t++] = rightA[j++];
    }

    public static void main(String[] args) {
        Main test = new Main();
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        Child = new person[n];
        for(int i = 0;i < n;i++) {
            int high = in.nextInt();
            Child[i] = new person(high);
        }
        test.mergeSort(Child);
        for(int i = 0;i < n;i++) {
            long count = Child[i].count;
            result += count * (count + 1) / 2;
        }
        System.out.println(result);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main{
	static int N = 100010;
	static int MAX = 1000100;

	static int[] C = new int[MAX];
	static int[] S = new int[MAX];
	static int[] b = new int[N];
	static long[] total = new long[N];
	static long ans;
	static int[] num = new int[N];
	static int T, s, t, i, j;

	static int Lowbit(int x) {
		return x & (-x);
	}

	static void add(int pos, int num, int[] P) {
		while (pos <= MAX) {
			P[pos] += num;
			pos += Lowbit(pos);
		}
	}

	static int Sum(int end, int[] P) {
		int cnt = 0;
		while (end > 0) {
			cnt += P[end];
			end -= Lowbit(end);
		}
		return cnt;
	}

	static void init() {
		total[0] = 0;
		for (int i = 1; i < N; ++i) {
			total[i] = total[i - 1] + i;
		}
	}

	public static void main(String[] args) throws IOException {
		init();
		BufferedReader buf = new BufferedReader(
				new InputStreamReader(System.in));
		T = Integer.parseInt(buf.readLine());
		String[] str = buf.readLine().split(" ");
		for (int j = 0; j < T; j++) {
			num[j] = Integer.parseInt(str[j]);
			add(num[j] + 1, 1, C);
			b[j] = j - Sum(num[j], C);

			b[j] -= Sum(num[j] + 1, C) - Sum(num[j], C) - 1;

		}

		ans = 0;
		for (int j = T - 1; j > -1; --j) {
			add(num[j] + 1, 1, S);
			b[j] += Sum(num[j], S);

			ans += total[b[j]];
		}

		System.out.println(ans);

	}

}