排序(集合)

归并排序

分治算法：将一个大规模问题分解为若干个规模较小的相同子问题，分而治之。

分治算法解题：

 1.分解：
    将要解决的问题分解为若干个规模较小、相互独立、与原问题形式相同的子问题。

    2.治理：
    求解各个子问题。由于各个子问题与原问题形式相同，只是规模较小而已，而当子问题划分得足够小时，就可以用简单的方法解决。

    3.合并
    按原问题的要求，将子问题的解逐层合并构成原问题的解。

归并排序

时间复杂度 O=(nlogn)--趟数logn、排序O（n)

1.问题分析
    归并排序是比较稳定的排序方法。它的基本思想是把待排序的元素分解成两个规模大致相等的子序列。如果不易分解，将得到的子序列继续分解，直到子序列中包含的元素个数为1。因为单个元素的序列本身就是有序的，此时便可以进行合并，从而得到一个完整的有序序列。

2.算法设计
    （1）分解：
    将待排序的元素分成大小大致一样的两个子序列。

    （2）治理：
    对两个子序列进行个并排序。

    （3）合并：
    将排好序的有序子序列进行合并，得到最终的有序序列。

3.算法分析
    首先我们先给定一个无序的数列（42，15，20，6，8，38，50，12），我们进行合并排序数列，如下图流程图所示：

 步骤一：首先将待排序的元素分成大小大致相同的两个序列。

步骤二：再把子序列分成大小大致相同的两个子序列。

步骤三：如此下去，直到分解成一个元素停止，这时含有一个元素的子序列都是有序的。

步骤四：进行合并操作，将两个有序的子序列合并为一个有序序列，如此下去，直到所有的元素都合并为一个有序序列。

题：

给定你一个长度为 n 的整数数列。

请你使用归并排序对这个数列按照从小到大进行排序。

并将排好序的数列按顺序输出。

输入格式

输入共两行，第一行包含整数 n。

第二行包含 n 个整数（所有整数均在 1∼1091∼109 范围内），表示整个数列。

输出格式

输出共一行，包含 n 个整数，表示排好序的数列。

数据范围

1≤n≤100000

输入样例：

5
3 1 2 4 5

输出样例：

1 2 3 4 5

#include<iostream>
#include<algorithm>
using namespace std;
const int N=1e6+10;
int q[N],a[N];
int n;
void merge(int q[],int l,int r)
{
    int mid=(l+r)/2;
    int i=l,j=mid+1;
    int k=0;
    while(i<=mid&&j<=r)
    {
        if(q[i]<=q[j]) a[k++]=q[i++];
        else  a[k++]=q[j++];
    }
    while(i<=mid)
    {
        a[k++]=q[i++];
    }
    while(j<=r)
    {
        a[k++]=q[j++];
    }
    k=0;
    for(i=l;i<=r;i++)
    {
        q[i]=a[k++];
    }
}
void merge_sort(int q[],int l,int r)
{
    if(l>=r) return ;
    int mid=(l+r)/2;
    merge_sort(q,l,mid);
    merge_sort(q,mid+1,r);
    merge(q,l,r);
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&q[i]);
    }
    merge_sort(q,1,n);
    for(int i=1;i<=n;i++)
    {
        printf("%d ",q[i]);
    }
    return 0;
}

 逆序对的数量  

给定一个长度为 n 的整数数列，请你计算数列中的逆序对的数量。

逆序对的定义如下：对于数列的第 i 个和第 j 个元素，如果满足 i<j 且 a[i]>a[j]，则其为一个逆序对；否则不是。

输入格式

第一行包含整数 n，表示数列的长度。

第二行包含 n 个整数，表示整个数列。

输出格式

输出一个整数，表示逆序对的个数。

数据范围

1≤n≤100000
数列中的元素的取值范围 [1,10^9]。

输入样例：

6
2 3 4 5 6 1

输出样例：

5

#include<iostream>
#include<algorithm>
using namespace std;
#define int long long 
const int N=1e6+10;
int q[N],a[N];
int n;
int merge_sort(int q[],int l,int r)
{
    if(l>=r) return 0;
    int mid=(l+r)/2;
    int ans=merge_sort(q,l,mid)+merge_sort(q,mid+1,r);
    int k=0,i=l,j=mid+1;
    
    while(i<=mid&&j<=r)
    {
        if(q[i]<=q[j])
        {
            a[k++]=q[i++];
        }
        else
        {
            a[k++]=q[j++];
            ans+=mid-i+1;
        }
    }
    while(i<=mid) a[k++]=q[i++];
    while(j<=r) a[k++]=q[j++];
    k=0;
    for(i=l;i<=r;i++) q[i]=a[k++];
    return ans;
}
signed main()
{
    int n;scanf("%lld",&n);
    for(int i=1;i<=n;i++) scanf("%lld",&q[i]);
    cout<<merge_sort(q,1,n)<<endl;
    return 0;
}

Greetings (cf)

F. Greetings

 

输入数据： 

5
2
2 3
1 4
6
2 6
3 9
4 5
1 8
7 10
-2 100
4
-10 10
-5 5
-12 12
-13 13
5
-4 9
-2 5
3 4
6 7
8 10
4
1 2
3 4
5 6
7 8 

   思路：将所有人的起点按照从小到大进行排序，这样就满足了后面的人不会撞到前面的人（只存在后面的人已经到达终点了，然后被前面的人撞）。然后再考虑能够撞多少个人：对于排完序以后的第个人而言，他能撞到的人是以后的，终点小于等于的人。因此也就是的个数，也就是按照起点排完序之后的数组的逆序对数量，然后套一遍逆序对的板子即可。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<vector>
#define int long long 
using namespace std;
const int N=2e5+10;
struct s
{
	int a,b;
}stu[N];
bool cmp(s x,s y)
{
	return x.a<y.a;
}
int p[N],c[N];
int merge_sort(int q[],int l,int r)
{
	if(l>=r) return 0;
	int mid=(l+r)/2;
	int res=merge_sort(q,l,mid)+merge_sort(q,mid+1,r);
	int i=l,j=mid+1;
	int k=0;
	while(i<=mid&&j<=r)
	{
		if(q[i]<q[j])
		{
			c[k++]=q[i++];
		}
		else
		{
			c[k++]=q[j++];
			res+=mid-i+1;
		}
	}
	while(i<=mid) c[k++]=q[i++];
	while(j<=r) c[k++]=q[j++];
	k=0;
	for(int i=l;i<=r;i++) 	q[i]=c[k++];
	return res;
}
signed main()
{
	int t;cin>>t;
	while(t--)
	{
		int n;
		cin>>n;
		for(int i=1;i<=n;i++) cin>>stu[i].a>>stu[i].b;
		sort(stu+1,stu+1+n,cmp);
		memset(p,0,sizeof p);
		memset(c,0,sizeof c);
		int res=0;
		for(int i=1;i<=n;i++)
		{
			p[i]=stu[i].b;
		}
		cout<<merge_sort(p,1,n)<<endl;
		
	}
	return 0;
}