SUSE暑假集训第三次作业

一：和腾讯2018春招技术类编程题第三题一样

二： i want to be the first （不能用sort函数）

思路

• 快排的每一趟，数轴的左边都会是 <= x 的， 右边都是 >= x 的。
  左边元素的个数是 s1 = j - l + 1, 如果k <= s1 的话，那么下次递归的区间就是左边，否则右边。
• 直到 l == r 时返回a[l]。

代码

#include<iostream>

using namespace std;

const int N = 1e5 + 10;

int n, k, a[N];

int quick_choose(int *a, int l, int r, int k)
{
    if(l == r) return a[l];
    
    int x = a[l];
    int i = l - 1, j = r + 1;
    while(i < j)
    {
        while(a[++i] < x);
        while(a[--j] > x);
        if(i < j) swap(a[i], a[j]);
    }
    
    int sl = j - l + 1;
    
    if(sl >= k) quick_choose(a, l, j, k);
    else quick_choose(a, j + 1, r, k - sl);
    
}

int main()
{
    scanf("%d%d", &n, &k);    
    for(int i = 1; i <= n; i++) scanf("%d", a + i);
    
    cout << quick_choose(a, 1, n, k) << endl;
    
    return 0;
}

三： get the number

思路： 归并排序求逆序对

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

首先我们给出逆序对的定义：

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

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

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

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

计算逆序对的数量（序列）：

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 = 1e5 + 10;
int a[N], t[N], n;

ll meger_sort(int l, int r)
{
    if(l >= r) return 0;
    int mid = (l + r) >> 1;
    int i = l, j = mid + 1, k = 0;
    ll ans = meger_sort(l, mid) + meger_sort(mid + 1, r);
    while(i <= mid && j <= r)
	{
        if(a[i] <= a[j]) 
			t[k++] = a[i++];
        else
		{
            t[k++] = a[j++];
            ans += (mid - i + 1);
        }
    }
    while(i <= mid) t[k++] = a[i++];
    while(j <= r) t[k++] = a[j++];
    for(int i = l, k = 0; i <= r; i++, k++) a[i] = t[k];
    return ans;
}
int main()
{
    cin >> n;
    for(int i = 1; i <= n; i++) scanf("%d", a + i);
    cout << meger_sort(1, n) << endl;
    return 0;
}

四：
把奇数和偶数分开， 奇数从小打到排序， 偶数从小到大排序， 分别输出就行了

#include <iostream>
#include <algorithm>

using namespace std;

int n;
int a[1010], b[1010];

bool cmp(int a, int b)
{
	return a > b;
}

int main()
{
    cin >> n;
    int c1 = 0, c2 = 0;
    for(int i = 0; i < n; i++)
    {
    	int t;
    	cin >> t;
    	if(t & 1)
    		a[c1++] = t;
    	else 
    		b[c2++] = t;
	}
	sort(a, a + c1, cmp);
	sort(b, b + c2);
	for(int i = 0; i < c1; i++)
		cout << a[i] << " ";
	for(int i = 0; i < c2; i++)
		cout << b[i] << " ";
    return 0;
}

五：
将序列排序， 然后从第一个往后遍历， i每次加4， 如果出现4个不相等的情况， 就输出a[i]终止循环

#include <iostream>
#include <algorithm>

using namespace std;

long long a[100010];

int main()
{
	int n;
	cin >> n;
	for(int i = 0; i < n; i++)
		scanf("%lld", a + i);
	sort(a, a + n);
	for(int i = 0; i < n; i += 4)
	{
		if(a[i] == a[i + 1] && a[i] == a[i + 2] && a[i] == a[i + 3])
			continue;
		else
		{
			printf("%lld\n", a[i]);
			break;
		}
	}
    return 0;
}