暑期留校——6月19日算法学习

因为高数期中考的不好，然后Java高数线代离散各种期末考试来了，所以算法停了一个多月没学了，现在终于解放了，可以好好学算法了，从今天开始要全力开冲了，基础很差，所以以后一定要更加努力啊！！！

学习的平台就在Acwing了，先把算法基础的模板题完全搞通刷完，然后再去看提高的课，写配套的题目，然后比赛也打着，补题也要每次都补着。

今天第一题是求逆序对，用到了归并排序的知识

void merge_sort(int q[], int l, int r)
{
    if (l >= r) return;

    int mid = l + r >> 1;
    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]) tmp[k ++ ] = q[i ++ ];
        else tmp[k ++ ] = q[j ++ ];

    while (i <= mid) tmp[k ++ ] = q[i ++ ];
    while (j <= r) tmp[k ++ ] = q[j ++ ];

    for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];
}

 

决一个问题的第一步是定义清楚问题。

首先我们给出逆序对的定义：
对于数列的第 i 个和第 j 个元素，如果满足 i < j 且 a[i] > a[j]，则其为一个逆序对。
重要的地方在于，一个元素可以不只是在一个逆序对中存在。如果 k > j > i 且 a[i] > a[j] > a[k]，那么这里
有两个含 a[i] 的逆序对，分别是 (a[i], a[j]) 和 (a[i], a[k]), a[i]是可以使用多次的。

那么第二步是分析问题，这里我们可以使用分治法解决问题。

我们将序列从中间分开，将逆序对分成三类：

两个元素都在左边；
两个元素都在右边；
两个元素一个在左一个在右；
因此这就是我们算法的大致框架：

计算逆序对的数量（序列）：
1. 递归算左边的；
2. 递归算右边的；
3. 算一个左一个右的；
4. 把他们加到到一起。

这个时候我们注意到一个很重要的性质，左右半边的元素在各自任意调换顺序，是不影响第三步计数的，因此我们可以数完就给它排序。这么做的好处在于，如果序列是有序的，会让第三步计数很容易。
如果无序暴力数的话这一步是O(n^2)的。

比如序列是这样的

4 5 6 | 1 2 3
当你发现 4 比 3 大的时候，也就是说右边最大的元素都小于左边最小的元素，那么左边剩下的5和6都必然比右边的所有元素大，因此就可以不用数5和6的情形了，直接分别加上右半边的元素个数就可以了，这一步就降低到了
O(n), 我们知道递归式 T(n) = 2T(n/2)+O(n) = O(nlogn)的，所以排序的成本是可以接受的，并且这一问题下，
可以很自然地使用归并排序。

#include<iostream>

using namespace std;

typedef long long LL;

const int N = 100010;

int n;
int q[N],tmp[N];

LL merge_sort(int l,int r)
{
	if(l >= r)return 0;
	
	int mid = l+r >> 1;
	LL res = merge_sort(l,mid)+merge_sort(mid+1,r);
	
	//归并的过程
	int k = 0,i = l,j = mid + 1; 
	while(i <= mid && j<= r)
	   if(q[i] <= q[j]) tmp[k++] = q[i++];
	   else
	   {
	 	  tmp[k ++ ] = q[j ++];
	 	  res+=mid - i + 1;
	   }
	//扫尾
	while(i <= mid)tmp[k ++] = q[i ++ ];
	while(j <= r)tmp[k ++] = q[j ++ ];
	
	//物归原主
	 for(int i =l,j = 0;i <= r;i ++,j ++ ) q[i] = tmp[j];
	 
	 return res;
}
int main()
{
	cin >> n;
	for(int i = 0;i < n; i ++)cin >> q[i];
	
	cout << merge_sort(0,n - 1)<<endl;
	
	return 0;
}

 然后做了一下二分

给定一个按照升序排列的长度为 nn 的整数数组，以及 qq 个查询。

对于每个查询，返回一个元素 kk 的起始位置和终止位置（位置从 00 开始计数）。

如果数组中不存在该元素，则返回 -1 -1。

输入格式

第一行包含整数 nn 和 qq，表示数组长度和询问个数。

第二行包含 nn 个整数（均在 1∼100001∼10000 范围内），表示完整数组。

接下来 qq 行，每行包含一个整数 kk，表示一个询问元素。

输出格式

共 qq 行，每行包含两个整数，表示所求元素的起始位置和终止位置。

如果数组中不存在该元素，则返回 -1 -1。

数据范围

1≤n≤1000001≤n≤100000
1≤q≤10000

这是我用stl的写法

#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
	int n,q;
	int a[200000];
	int i,j,m;
	cin>>n>>q;
	for(i=0;i<n;i++)
	  cin>>a[i];
	for(i=1;i<=q;i++)
	  {
	  	 cin>>m;
	  	// int *ans1=lower_bound(a,a+n,m);
	  	// int *ans2=upper_bound(a,a+n,m);
	  	 if(binary_search(a,a+n,m))
	  	   cout<<lower_bound(a,a+n,m)-a<<" "<<upper_bound(a,a+n,m)-a-1<<endl;
	  	 else
	  	   cout<<"-1 -1"<<endl;
	  }
	  return 0;
}

然后这个是整数二分的模板

bool check(int x) {/* ... */} // 检查x是否满足某种性质

// 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用：
int bsearch_1(int l, int r)
{
    while (l < r)
    {
        int mid = l + r >> 1;
        if (check(mid)) r = mid;    // check()判断mid是否满足性质
        else l = mid + 1;
    }
    return l;
}
// 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：
int bsearch_2(int l, int r)
{
    while (l < r)
    {
        int mid = l + r + 1 >> 1;
        if (check(mid)) l = mid;
        else r = mid - 1;
    }
    return l;
}

好好背吧加油加油！！！！