关于『一月の集训』

$\tt A \ B \ O \ U \ T \quad J \ A\ N\ U\ A\ R \ Y$

关于一月的集训，在这里做一个了结总结。

很乱是吧，同感。

1.分治

$\tt \ \ \ D \ I \ V \ I \ D \ E \quad \ A \ N \ D \quad C \ O \ N \ Q \ U \ E \ R$

综上，分治的基本思想为：

分治的步骤：

例题:

快速排序 ( $\tt Quickly\_sort$ )

二路归并排序 ( $\tt Merge\_sort$ )

求逆序对数 ( $\tt Reverse\_order\_pair$ )

寻找伪币 ( $\tt Counterfeit\_currency$ )

查找最接近的元素

一元三次方程求解

网线主管

膨胀的木棍 ( $\tt Stick$ )

快速排序 & 二路归并排序

快速排序	二路归并排序
不稳定排序	稳定排序
双指针 & 二分	二分

快速排序：

void quickly_sort(int s, int e) {
	if(s > e) {
		return;
	}
	int tmp = a[s];
	int i = s;
	int j = e;
	while(i != j) {
		while(a[j] <= tmp && i < j) {
			j --;
		}
		while(a[i] >= tmp && i < j) {
			i ++;
		}
		if(i < j) {
			swap(a[i], a[j]);
		}
	}
	swap(a[i], a[s]);
	quickly_sort(s, i - 1);
	quivkly_sort(i + 1, e);
	return;
}

二路归并：

void merge_sort(int s, int e) {
	if(s == e) {
		return;
	}
	int mid = (s + e) / 2;
	merge_sort(s, mid);
	merge_sort(mid + 1, e);
	int i = s;
	int k = s;
	int j = mid + 1;
	while(i <= mid && j <= e) {
		if(a[i] <= a[j]) {
			r[k] = a[i];
			k ++;
			i ++;
		}
		else {
			r[k] = a[j];
			k ++;
			j ++;
		}
	}
	while(i <= mid) {
		r[k] = a[i];
		i ++;
		k ++;
	}
	while(j <= e) {
		r[k] = a[j];
		j ++;
		k ++;
	}
	for(int i = s; i <= e; i ++) {
		a[i] = r[i];
	}
	return;
}

时间复杂度为 $\tt O(n\log n)$ 。

求逆序对

看起来求逆序对又是大费周章，但其实在二路归并排序时，有一段代码：

else {
	r[k] = a[j];
	k ++;
	j ++;
}

先看 $\tt else$ 否定的是前面的 $\tt a[i] <= a[j]$ , 则：

if(a[i] > a[j]) {
	r[k] = a[j];
	k ++;
	j ++;
}

再看 $\tt while$ 里写的是 $\tt i <= mid \ \&\& \ j <= e$ , 又因为 $\tt mid = \frac {s + e}{2}$ ， $\tt s < e$ , 则 $\tt mid < e$ , 则 $\tt i < j$ 。

满足逆序对的定义。

又想，既然 $\tt a[i] > a[j]$ , 则 $\tt a[j]$ 后的所有数均可和其互为逆序对。

则有：

else {
	r[k] = a[j];
	k ++;
	j ++;
	ans += mid - i + 1;//求逆序对
}

但不能用快速排序求逆序对。

快速排序为不稳定排序，会导致相等元素下标交换。

寻找伪币

二分裸题。

想象一把天平，称重时伪币一定在轻的那一边。

则确定二分左指针 $\tt l = 1$ , 右指针 $\tt r = 16$ 。

令 $\tt mid = \frac {s + e}{2}$ 。

则当 $\tt \sum_{i = l}^{mid}a_i < \sum_{i = mid + 1}^{r}a_i$ 时，伪币在 $\tt [l, mid]$ 中。

反之，伪币在 $\tt [mid + 1, r]$ 中。

为了降低时间复杂度，故采用前缀和 $\tt (Preafix \ sum)$ 数组。

int main() {
	for(int i = 1; i <= 16; i ++) {
		scanf("%d", &a[i]);
		prev[i] = prev[i - 1] + a[i];
	}
	int l = 1;
	int r = 16;
	while(l < r) {
		int mid = (l + r)  /2;
		int suml = prev[mid] - prev[l - 1];
		int sumr = prev[r] - prev[mid];
		if(suml < sumr) {
			r = mid;
		}
		else {
			l = mid + 1;
		}
	}
	printf("%d %d", l, a[l]);
	return 0;
}

查找最接近的元素

普通的二分查找。

值得注意的是：

所以在 $\tt while$ 循环后，还要进行一次判断：

if(x - a[l] <= a[r] - x) {//x是询问的数(查找对象)
	printf("%d\n", a[l]);
}

什么意思？

当 $\tt | a[l] - x | < | a[r] - x |$ 时，输出 $\tt a[l]$ 。

否则输出 $\tt a[r]$ 。

一元三次方程求解

$\tt NOIP \ 2001$ 提高组。

这种二分非直接分出答案，而是通过某些运算间接分出答案。

而我们往往将这某种运算写成函数，取名为 $\tt check$ 。

int check(int x)

回到这道题。

首先导入一个概念：

零点定理

这就好办了。

double check(double x) {
	return x * x * x * a + b * x * x + c * x + d;
}
int main() {
	scanf("%lf %lf %lf %lf", &a, &b, &c, &d);
	for(double x = -100; x < 100; x += 1.0) {
		l = x;
		r = x + 1;
		if(check(l) == 0) {
			printf("%.2lf ", l);
		}
		else if(check(l) * check(r) < 0) {
			while(r - l > 0.0001) {
				mid = (r + l) / 2;
				if((check(l) * check(mid)) < 0) {
					r = mid;
				}
				else l = mid;
			}
			printf("%.2lf ", l);
		}
	}
	return 0;
}

网线主管

题目很长，简单说就是：

仍然是间接二分。

则首先确定 $\tt check$ 函数的内容。

二分分出来的是单位长度，而要与线段数量相比，很明显，用一层 $\tt for$ 循环累加每条线段按单位长度分得的线段数量。

int check(int x) {
	int ans = 0;
	for(int i = 1; i <= n; i ++) {
		ans += a[i] / x;
	} 
	return ans;
}

注意:为避免精度问题，将 $\tt double$ 转化为 $\tt int$ 后处理，输出时将 $\tt int$ 还原回 $\tt double$ 即可。

膨胀的木棍

热力学 & 三角学 & 高等数学联袂出演。

前方高能。

先热个身：

线性膨胀系数

∵ $\tt l_t = l_0( 1 + \alpha t)$

又∵ $\tt ∠\alpha = \arcsin(\frac{l}{r})$

∴ $\tt (1 + \alpha t)l = 2r \times \arcsin(\frac{l}{2r})$

∵ $\tt r = \sqrt{k^2 + l^2}$

又∵ $\tt d = r - k$

∴ $\tt d = \sqrt{k^2 + l^2} - k$

$\dots$

最终得

$\tt r = \frac{h}{2} + \frac{l^2}{8h}$

设弧长 $\tt x$ 。

则

$\tt x = (2h + \frac{l^2}{2h}) \times \arcsin(\frac{2h}{4h^2+l^2})$

对上式求导得

$\tt x\prime = ((2h + \frac{l^2}{2h}) \times \arcsin(\frac{2h}{4h^2+l^2}))\prime$

由求导四则运算法则与性质得

$\tt (u(x) \times v(x))\prime = u\prime(x) \times v(x) + u(x) \times v\prime(x)$

$\tt (u(x)±v(x))\prime = u\prime(x) + v\prime(x)$

$\tt (\frac{u(x)}{v(x)})\prime = \frac{u\prime(x)v(x) - u(x)v\prime(x)}{v^2(x)}$
则

$\tt ((2h + \frac{l^2}{2h}) \times \arcsin(\frac{2h}{4h^2+l^2}))\prime = (2h + \frac{l^2}{2h})\prime \times \arcsin(\frac{2h}{4h^2+l^2}) + (2h + \frac{l^2}{2h})\times \arcsin(\frac{2h}{4h^2+l^2})\prime$

化简得

$\tt x\prime = \frac{4h + 2hl + l^2}{2h} \times \arcsin(\frac{2h}{4h^2 + l^2}) + \frac{4h^2+l^2}{2h\sqrt{1 - 16h^4 - 8h^2l^2 - l^4}}$

∴ $\tt x$ 单调递增。

注意：二分时精度需开大。

int main() {  
    double len, n, c;    
    while(scanf("%lf%lf%lf", &len, &n, &c)) {  
        if (len == -1 && n == -1 && c == -1) {
            return 0;  
        }
        double l = 0.0;  
        double r = 0.5 * len;  
        double mid;  
        double l1 = (1 + n * c) * len;  
        while(r - l > 0.00001) {  
            mid = (l + r) / 2;  
            r = (4 * mid * mid + len * len) / (8 * mid);  
            if (2 * r * asin(len / (2 * r)) < l1) {
                l = mid;  
            }
            else {
                r = mid;  
            }
        }  
        printf("%.3lf\n", mid);
    }  
}

2.STL之队列

$\tt \ \ \ Q \ U \ E\ U \ E$

长这样☟

队列满足FIFO。[1]

用数组模拟队列

双指针法。

定义两个指针： $\tt front$ 和 $\tt rear$ 。

int front;
int rear;

$\tt push()$

把元素装进队列。

把队列想成自动铅笔， $\tt push()$ 就是往笔里塞笔芯。

只需要将 $\tt rear$ ++ 即可。

void push(int x) {
	rear ++;
	a[rear] = x;
	return;
}

$\tt empty()$

队列是否为空。

通俗的说就是铅笔里还有没有笔芯。

当 $\tt rear = front$ 时，队列为空。

bool empty() {
	return rear == front;
}

$\tt front()$

获取队头元素值(不删除)。

输出 $\tt a[front + 1]$ 即可。

注意：队列为空时无法获取队头元素值。

void front() {
	if(empty()) {
		printf("error");
		return;
	}
	printf("%d" a[front + 1]);
	return;
}

$\tt pop()$

删除队头元素。

$\tt front$ ++ 即可。

注意：队列为空时无法删除。

void pop() {
	if(empty()) {
		printf("error");
		return;
	}
	front ++;
	return;
}

$\tt clean()$

清空队列。

将 $\tt rear = front$ 即可。

void clean() {
	rear = front;
	return;
}

STL里的队列

#include <cstdio>
#include <queue>
using namespace std;
queue<int> q;
int main() {
	q.clean();
	q.push(1);
	printf("%d", q.front());
	q.pop();
	printf("%d", q.empty());
	return 0;
}

输出：

1 1

周末舞会

创建两个队列，一个装男士，一个装女士。

int main() {
	queue<int> q1;
	queue<int> q2;
	int n, m, k;
	scanf("%d%d%d", &n, &m, &k);
	for(int i = 1; i <= n; i ++) {
		q1.push(i);
	}
	for(int i = 1; i <= m; i ++) {
		q2.push(i);
	}
	for(int i = 1; i <= k; i ++) {
		printf("%d %d\n", q1.front(), q2.front());
		q1.push(q1.front());
		q1.pop();
		q2.push(q2.front());
		q2.pop();
	}
}

Blah数集

现在小高斯想知道如果将集合 Blah 中元素按照升序排列，第 n 个元素会是多少？注意：集合中没有重复的元素。

开两个队列。

int main() {
	queue<int> q1;
	queue<int> q2;
	int ans, n;
	scanf("%d%d", &ans, &n);
	int tot = 1;
	while(tot != n) {
		q1.push(2 * ans + 1);
		q2.push(3 * ans + 1);
		if(q1.front() < q2.front()) {
			ans = q1.front();
			q1.pop();
		}
		else if(q1.front() > q2.front()) {
			ans = q2.front();
			q2.pop();
		}
		else {
			ans = q1.front();
			q1.pop();
			q2.pop();
		}
		tot ++;
	}
	printf("%d", ans);
	return 0;
}

3.STL之栈

$\tt \ \ \ S \ T \ A \ C \ K$

长这样☟

就像这摞书，如果你想要拿到最底下那本，你一定需要从上往下一本本拿出来才行。~~(技术好的也可以釜底抽薪)(大雾)~~

用数组模拟栈

单指针法。

定义一个指针 $\tt rear$ 。

int rear;

$\tt push()$

将元素放进栈。

将 $\tt rear$ ++ 并将 $\tt x$ 赋值给 $\tt a[rear]$ 即可。

void push(int x) {
	rear ++;
	a[rear] = x;
	return;
}

$\tt empty()$

栈是否为空。

判断 $\tt rear$ 是否为 $\tt 0$ 即可。

bool empty() {
	return rear == 0;
}

$\tt top()$

获取栈顶元素值(不删除)。

输出 $\tt a[rear]$ 即可。

注意：栈为空时无法获取栈顶元素值。

void top() {
	if(empty()) {
		printf("error");
		return;
	}
	printf("%d", a[rear]);
	return;
}

$\tt pop()$

删除栈顶元素。

将 $\tt rear$ - - 即可。

void pop() {
	rear --;
	return;
}

$\tt clean()$

将栈置空。

将 $\tt rear$ 置为 $\tt 0$ 即可。

void clean() {
	rear = 0;
	return;
}

STL中的栈

#include <cstdio>
#include <stack>
using namespace std;
stack<int> s;
int main() {
	s.clean();
	s.push(1);
	printf("%d", q.top());
	printf("%d", q.empty());
	q.pop();
	printf("%d", q.empty());
	return 0;
}