算法竞赛--基础复习（二）

这部分主要是和一些基础数据结构以及搜索相关的内容。

单调栈

单调栈用来寻第一个左边比自己小的数。假如ai>=aj并且i<j，那么ai不会再作为一个较小的输出，因为aj更小，倘若能输出ai，那么一定能输出aj。可以使用一个栈行使上述的思想，栈中元素永远都是单调递增的。

#include<iostream>
using namespace std;
const int N = 100010;
int stk[N], tt;
int n;
int main()
{
	cin >> n;
	int x;
	for (int i = 0; i < n; i++)
	{
		cin >> x;
		while (tt && stk[tt] >= x) tt--;
		if (tt) cout << stk[tt]<< " ";
		else cout << -1 << " ";
		stk[++tt] = x;
	}
	return 0;
}

 滑动窗口

找出一个固定窗口内的最小值。朴素做法遍历窗口的每一个值，找到最小数，这是纯暴力的做法。可以使用滑动窗口实现，主要使用的是单调队列。单调队列里面存储的数字的下标，每次遍历到一个新数，都要先判断队首元素有没有超出滑动窗口。然后将新的元素和队尾元素进行比较，如果小于等于队尾元素，就将队尾元素出队。

#include<iostream>
using namespace std;
const int N = 100010;
int a[N],q[N], hh,tt=-1;
int n,k;

int main()
{
	cin >> n >> k;
	for (int i = 0; i < n; i++)
	{
		cin >> a[i];
	}
	for (int i = 0; i < n; i++)
	{
		//判断队头是否滑出窗口
		if (hh <= tt && i - k + 1 > q[hh]) hh++;
		while (hh <= tt && a[i] <= a[q[tt]]) tt--;
		q[++tt] = i;
		if (i >= k - 1) cout << a[q[hh]]<<" ";
	}
	return 0;
}

并查集

1、将两个集合合并

2、判断两个点是否在同一个集合内

最重要的是find函数，除此之外并查集还可以维护一些东西。shengdu

#include<iostream>
using namespace std;
const int N = 1e6 + 10;
int p[N];
int find(int x)
{
	if(p[x] != x) p[x] = find(p[x]);
	return p[x];
}

void Union(int a,int b)
{
	if (find(a) != find(b))
	{
		p[find(a)] = find(b);
	}
}

int main()
{
	int n;
	cin >> n;
	//初始化
	for (int i = 0; i < n; i++)
	{
		p[i] = i;
	}
	return 0;
}

深度优先搜索(全排列）

#include<iostream>
using namespace std;
int n;
const int N = 100;
bool st[N];
int path[N];
void dfs(int u)
{
	if (u == n)
	{
		for (int i = 0; i < n; i++)
		{
			cout << path[i] << " ";
		}
		cout << endl;
		return;
	}
	else
	{
		for (int i = 1; i <= n; i++)
		{
			if (!st[i])
			{
				st[i] = true;
				path[u] = i;
				dfs(u + 1);
				st[i] = false;
				path[u] = 0;
			}
		}
	}
}

int main()
{
	cin >> n;
	dfs(0);
	return 0;
}

 (树的重心)

去掉树的重心可以使得，剩下得各连通块的结点个数的最大值最小。本体采用dfs做，同时注意存树的方式，要熟练掌握。

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int n;
const int N = 10010, M = 2 * N;
bool st[N];
int ans = N;
int h[N], e[M], ne[M], idx;
void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

int dfs(int u)
{
	st[u] = true;

	int sum = 1, res = 0;
	for (int i = h[u]; i != -1; i = ne[i])
	{
		int j = ne[i];
		if (!st[j])
		{
			int s = dfs(j);
			res = max(res, s);
			sum += s;
		}
	}
	res = max(res, n - sum);
	ans = min(ans, res);
	return sum;
}

int main()
{
	memset(h, -1, sizeof h);
	cin >> n;
	for (int i = 0; i < n - 1; i++)
	{
		int a, b;
		cin >> a >> b;
		add(a, b), add(b, a);
	}

	dfs(1);
	cout << ans;
	return 0;
}

拓扑排序

先把入度为0的点加入队列。把每个加入队列的点所连的点的入度减1，若有点入度为0则加入队列，重复此操作，直到遍历结束。队列中的序列就是拓扑序列。

#include<iostream>
#include<cstring>
using namespace std;
const int N = 1e6,M = 2*N;
int h[N], ne[M], e[M], idx;
int n, m;
int q[N], d[N]; //d[]用来存储某个点的入度

void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

bool topsort()
{
	int hh = 0, tt = -1;
	for (int i = 1; i <= n; i++)
	{
		if (!d[i])
		{
			q[++tt] = i;
		}
	}
	while (hh <= tt)
	{
		int t = q[hh++];
		for (int i = h[t]; i != -1; i = ne[i])
		{
			int j = e[i];
			d[j]--;
			if (!d[j]) q[++tt] = j;
		}
	}
	return tt == n - 1;
}

int main()
{
	memset(h, -1,sizeof h);
	cin >> n >> m;
	for (int i = 0; i < m; i++)
	{
		int a, b;
		cin >> a >> b;
		add(a, b);
		d[b]++;
	}
	if (topsort())
	{
		for (int i = 0; i < n; i++)
		{
			cout << q[i] << " ";
		}
	}
	else cout << -1;
	return 0;
}