Trie字符串统计
#include <iostream>
using namespace std;
const int N = 100010;
int son[N][26], cnt[N], idx;//下标是0的点，既是根节点，又是空节点
char str[N];
void insert(char str[])
{
int p = 0;//从根结点开始遍历
for (int i = 0; str[i]; i++)
{
int u = str[i] - 'a';
if (!son[p][u]) son[p][u] = ++idx;//没有该子结点就创建一个
p = son[p][u];//走到p的子结点
}
cnt[p]++;
}
int query(char str[])
{
int p = 0;
for (int i = 0; str[i]; i++)
{
int u = str[i] - 'a';
if (!son[p][u]) return 0;//没有就直接返回0
p = son[p][u];
}
return cnt[p];
}
int main()
{
int n;
cin >> n;
while (n--)
{
char op[2];
cin >> op >> str;
if (op[0] == 'I') insert(str);
else cout << query(str) << endl;
}
return 0;
}
最大异或对
这道题目很难想到是字典树,如果不是放在字典树单元的话.
其实来说,一个整数,是可以转化成为一个32位的二进制数,而也就可以变成长度为32位的二进制字符串.
既然如此话,那么我们可以这么做,每一次检索的时候,我们都走与当前AiAi这一位相反的位置走,也就是让Xor值最大,如果说没有路可以走的话,那么就走相同的路.
这道题的启示是：字典树不单单可以高效存储和查找字符串集合,还可以存储二进制数字，而计算机所有的存储方式都是二进制的，所以这给了我们很大的操作空间。
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010, M = 31 * N;
int son[M][2], a[N], n, idx;//M代表一个数字串二进制可以到多长
void insert(int x)
{
int p = 0;
for (int i = 30; i >= 0; i--)
{
int u = x >> i & 1;//取X的第i位的二进制数是什么 x>>k&1(前面位运算的模板)
if (!son[p][u]) son[p][u] = ++idx;//如果插入中发现没有该子节点,开出这条路
p = son[p][u];//指针指向下一层
}
}
int query(int x)
{
int p = 0, res = 0;
for (int i = 30; i >= 0; i--) //从最大位开始找
{
int u = x >> i & 1;
if (son[p][!u])//如果当前层有对应的不相同的数
{
p = son[p][!u];
res = res * 2 + 1; //左移一位然后加上对应的不同的位
}
else
{
p = son[p][u];
res = res * 2 + 0;
}
}
return res;
}
int main()
{
scanf("%d", &n);
for (int i = 0; i < n; i++)
{
scanf("%d", &a[i]);
insert(a[i]);
}
int res = 0;
for (int i = 0; i < n; i++) res = max(res, query(a[i]));
printf("%d\n", res);
return 0;
}
合并集合
并查集的核心代码：一个非常优美的递归，只有两行：
int find(int x)//返回x的祖宗节点 + 路径压缩
{
if (p[x] != x) p[x] = find(p[x]);// 根据通项公式，假设p[a]的祖先节点已知，主要思想是递归
return p[x];
}
#include <iostream>
using namespace std;
const int N = 100010;
int n, m, p[N];
// 该函数的含义：查找a所在集合的祖先节点下标，从1开始, 并内部更新p[a]为a节点的祖先节点。
int find(int x)//返回x的祖宗节点 + 路径压缩
{
if (p[x] != x) p[x] = find(p[x]);// 根据通项公式，假设p[a]的祖先节点已知。
return p[x];
}
int main()
{
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) p[i] = i;// 初始化每个集合
while (m--)
{
char op[2];
int a, b;
scanf("%s%d%d", op, &a, &b);
if (op[0] == 'M') p[find(a)] = find(b);
else
{
if (find(a) == find(b)) puts("Yes");
else puts("No");
}
}
return 0;
}
连通块中点的数量
#include <iostream>
using namespace std;
const int N = 100010;
int n, m, p[N];
// 该函数的含义：查找a所在集合的祖先节点下标，从1开始, 并内部更新p[a]为a节点的祖先节点。
int find(int x)//返回x的祖宗节点 + 路径压缩
{
if (p[x] != x) p[x] = find(p[x]);// 根据通项公式，假设p[a]的祖先节点已知，主要思想是递归
return p[x];
}
int main()
{
scanf("%d%d", &n, &m);
int size[N];
for (int i = 1; i <= n; i++)
{
p[i] = i;// 初始化每个集合
size[i] = 1;
}
while (m--)
{
string op;
int a, b;
cin >> op;
if (op == "C")
{
scanf("%d%d", &a, &b);
if (find(a) == find(b)) continue;
size[find(b)] += size[find(a)];
p[find(a)] = find(b);
}
else if (op == "Q1")
{
scanf("%d%d", &a, &b);
if (find(a) == find(b)) puts("Yes");
else puts("No");
}
else
{
scanf("%d", &a);
printf("%d\n", size[find(a)]);
}
}
return 0;
}
食物链
堆排序
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010;
int n, m, cnt;
int h[N];
void down(int u)
{
int t = u;
if (u * 2 <= cnt && h[u * 2] < h[t]) t = u * 2;
if (u * 2 + 1 <= cnt && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
if (u != t)
{
swap(h[u], h[t]);
down(t);
}
}
int main()
{
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &h[i]);
cnt = n;
for (int i = n / 2; i; i--) down(i);
while (m--)
{
printf("%d ", h[1]);
h[1] = h[cnt];
cnt--;
down(1);
}
return 0;
}
up操作：
void up(int u)
{
while (u / 2 && h[u / 2] > h[u])
{
swap(h[u / 2], h[u]);
u /= 2;
}
}
模拟堆
难点在于交换时也要处理好映射关系，需要维护交换关系。
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1e5 + 10;
int h[N]; //堆
int ph[N]; //存放第k个插入点的下标
int hp[N]; //存放堆中点的插入次序
int cnt; //size 记录的是堆当前的数据多少
//这个交换过程其实有那么些绕 但关键是理解 如果hp[u]=k 则ph[k]=u 的映射关系
//之所以要进行这样的操作是因为 经过一系列操作 堆中的元素并不会保持原有的插入顺序
//从而我们需要对应到原先第K个堆中元素
//如果理解这个原理 那么就能明白其实三步交换的顺序是可以互换
//h,hp,ph之间两两存在映射关系 所以交换顺序的不同对结果并不会产生影响
void heap_swap(int u, int v)
{
swap(h[u], h[v]);
swap(hp[u], hp[v]);
swap(ph[hp[u]], ph[hp[v]]);
}
void down(int u)
{
int t = u;
if (u * 2 <= cnt && h[t] > h[u * 2]) t = u * 2;
if (u * 2 + 1 <= cnt && h[t] > h[u * 2 + 1]) t = u * 2 + 1;
if (u != t)
{
heap_swap(u, t);
down(t);
}
}
void up(int u)
{
if (u / 2 > 0 && h[u] < h[u / 2])
{
heap_swap(u, u / 2);
up(u >> 1);
}
}
int main()
{
int n;
cin >> n;
int m = 0; //m用来记录插入的数的个数
//注意m的意义与cnt是不同的 cnt是记录堆中当前数据的多少
//对应上文 m即是hp中应该存的值
while (n--)
{
string op;
int k, x;
cin >> op;
if (op == "I")
{
cin >> x;
m++;
h[++cnt] = x;
ph[m] = cnt;
hp[cnt] = m;
up(cnt);
}
else if (op == "PM") cout << h[1] << endl;
else if (op == "DM")
{
heap_swap(1, cnt);
cnt--;
down(1);
}
else if (op == "D")
{
cin >> k;
int u = ph[k]; //这里一定要用u=ph[k]保存第k个插入点的下标
heap_swap(u, cnt); //因为在此处heap_swap操作后ph[k]的值已经发生
cnt--; //如果在up,down操作中仍然使用ph[k]作为参数就会发生错误
up(u);
down(u);
}
else if (op == "C")
{
cin >> k >> x;
h[ph[k]] = x; //此处由于未涉及heap_swap操作且下面的up、down操作只会发生一个所以
down(ph[k]); //所以可直接传入ph[k]作为参数
up(ph[k]);
}
}
return 0;
}
377
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
