1.29学习总结

并查集
1.并查集
2.亲戚
3.朋友(STL+并查集)
4.集合(质数筛+并查集)
5.修复公路(并查集+结构体排序)
搜索
1.机器人搬重物(BFS)
树状数组
1.树状数组1(单点修改,区间查询)
2.树状数组 2(区间修改,单点查询)

并查集

并查集的效率很高,复杂度在O(logn),操作简短,主要是初始化,寻找函数find,合并函数union

并查集https://www.luogu.com.cn/problem/P3367

题目描述

如题,现在有一个并查集,你需要完成合并和查询操作。

输入格式

第一行包含两个整数 �,�N,M ,表示共有 �N 个元素和 �M 个操作。

接下来 �M 行,每行包含三个整数 ��,��,��Zi​,Xi​,Yi​ 。

当 ��=1Zi​=1 时,将 ��Xi​ 与 ��Yi​ 所在的集合合并。

当 ��=2Zi​=2 时,输出 ��Xi​ 与 ��Yi​ 是否在同一集合内,是的输出 Y ;否则输出 N 。

输出格式

对于每一个 ��=2Zi​=2 的操作,都有一行输出,每行包含一个大写字母,为 Y 或者 N 。

输入输出样例

输入 #1复制

4 7
2 1 2
1 1 2
2 1 2
1 3 4
2 1 4
1 2 3
2 1 4

输出 #1复制

N
Y
N
Y

说明/提示

对于 30%30% 的数据,�≤10N≤10,�≤20M≤20。

对于 70%70% 的数据,�≤100N≤100,�≤103M≤103。

对于 100%100% 的数据,1≤�≤1041≤N≤104,1≤�≤2×1051≤M≤2×105,1≤��,��≤�1≤Xi​,Yi​≤N,��∈{1,2}Zi​∈{1,2}。

思路:函数写出来,关系带进去就可以了

#include 
using namespace std;
int f[200005];
int n,m;
void init(int n)
{
	for (int i=1;i<=n;++i)f[i]=i;
}
int find(int x)
{
	if (f[x]==x)return x;
	else 
	{
		f[x]=find(f[x]);
		return f[x];
	}
}
void unions(int i,int j)
{
	int f_i=find(i);
	int f_j=find(j);
	f[f_i]=f_j;
}
int main()
{
	cin>>n>>m;
	init(n);
	for (int i=0;i>a>>b>>c;
		if (a==1)
		{
			unions(b,c);
		}
		else if (a==2)
		{
			if (find(b)==find(c))cout<<"Y"<
亲戚https://www.luogu.com.cn/problem/P1551

题目背景

若某个家族人员过于庞大,要判断两个是否是亲戚,确实还很不容易,现在给出某个亲戚关系图,求任意给出的两个人是否具有亲戚关系。

题目描述

规定:�x 和 �y 是亲戚,�y 和 �z 是亲戚,那么 �x 和 �z 也是亲戚。如果 �x,�y 是亲戚,那么 �x 的亲戚都是 �y 的亲戚,�y 的亲戚也都是 �x 的亲戚。

输入格式

第一行:三个整数 �,�,�n,m,p,(�,�,�≤5000n,m,p≤5000),分别表示有 �n 个人,�m 个亲戚关系,询问 �p 对亲戚关系。

以下 �m 行:每行两个数 ��Mi​,��Mj​,1≤��, ��≤�1≤Mi​, Mj​≤n,表示 ��Mi​ 和 ��Mj​ 具有亲戚关系。

接下来 �p 行:每行两个数 ��,��Pi​,Pj​,询问 ��Pi​ 和 ��Pj​ 是否具有亲戚关系。

输出格式

�p 行,每行一个 Yes 或 No。表示第 �i 个询问的答案为“具有”或“不具有”亲戚关系。

输入输出样例

输入 #1复制

6 5 3
1 2
1 5
3 4
5 2
1 3
1 4
2 3
5 6

输出 #1复制

Yes
Yes
No

思路:同样的模版题

#include 
using namespace std;
int f[200005];
int n,m,q;
void init(int n)
{
	for (int i=1;i<=n;++i)f[i]=i;
}
int find(int x)
{
	if (f[x]==x)return x;
	else 
	{
		f[x]=find(f[x]);
		return f[x];
	}
}
void unions(int i,int j)
{
	int f_i=find(i);
	int f_j=find(j);
	f[f_i]=f_j;
}
int main()
{
	cin>>n>>m>>q;
	init(n);
	for (int i=0;i>a>>b;
		unions(a,b);
	}
	for (int i=0;i>a>>b;
		if (find(a)==find(b))cout<<"Yes"<
朋友https://www.luogu.com.cn/problem/P2078

题目背景

小明在 A 公司工作,小红在 B 公司工作。

题目描述

这两个公司的员工有一个特点:一个公司的员工都是同性。

A 公司有 �N 名员工,其中有 �P 对朋友关系。B 公司有 �M 名员工,其中有 �Q 对朋友关系。朋友的朋友一定还是朋友。

每对朋友关系用两个整数 (��,��)(Xi​,Yi​) 组成,表示朋友的编号分别为 ��,��Xi​,Yi​。男人的编号是正数,女人的编号是负数。小明的编号是 11,小红的编号是 −1−1。

大家都知道,小明和小红是朋友,那么,请你写一个程序求出两公司之间,通过小明和小红认识的人最多一共能配成多少对情侣(包括他们自己)。

输入格式

输入的第一行,包含 44 个空格隔开的正整数 �,�,�,�N,M,P,Q。

之后 �P 行,每行两个正整数 ��,��Xi​,Yi​。

之后 �Q 行,每行两个负整数 ��,��Xi​,Yi​。

输出格式

输出一行一个正整数,表示通过小明和小红认识的人最多一共能配成多少对情侣(包括他们自己)。

输入输出样例

输入 #1复制

4 3 4 2
1 1
1 2
2 3
1 3
-1 -2
-3 -3

输出 #1复制

2

说明/提示

对于 30%30% 的数据,�,�≤100N,M≤100,�,�≤200P,Q≤200;

对于 80%80% 的数据,�,�≤4×103N,M≤4×103,�,�≤104P,Q≤104;

对于 100%100% 的数据,�,�≤104N,M≤104,�,�≤2×104P,Q≤2×104。

思路:用map容器,把他们放到一个并查集里面,然后寻找两个公司里面最少的关系,因为1和-1是有关系的,所以就看两个公司那个公司关系的人更少了

#include 
using namespace std;
mapf;
int find(int x)
{
	if (f[x]==x)return x;
	else 
	{
		f[x]=find(f[x]);
		return f[x];
	}
}
void unionn(int i,int j)
{
	int s_i=find(i);
	int s_j=find(j);
	f[s_i]=s_j;
}
int main()
{
	int n,m,p,q;
	cin>>n>>m>>p>>q;
	for (int i=-m;i<=n;++i)
	{
		if (i==0)continue;
		f[i]=i;
	}
	for (int i=0;i>a>>b;
		unionn(a,b);
	}
	int cnt1=0,cnt2=0;
	for (int i=1;i<=n;++i)
	{
		if (find(i)==find(1))cnt1++;
	}
	for (int i=-m;i<=-1;++i)
	{
		if (find(i)==find(-1))cnt2++;
	}
	cout<

集合https://www.luogu.com.cn/problem/P1621

题目描述

Caima 给你了所有 [�,�][a,b] 范围内的整数。一开始每个整数都属于各自的集合。每次你需要选择两个属于不同集合的整数,如果这两个整数拥有大于等于 �p 的公共质因数,那么把它们所在的集合合并。

重复如上操作,直到没有可以合并的集合为止。

现在 Caima 想知道,最后有多少个集合。

输入格式

一行,共三个整数 �,�,�a,b,p,用空格隔开。

输出格式

一个数,表示最终集合的个数。

输入输出样例

输入 #1复制

10 20 3

输出 #1复制

7

说明/提示

样例 1 解释

对于样例给定的数据,最后有 {10,20,12,15,18},{13},{14},{16},{17},{19},{11}{10,20,12,15,18},{13},{14},{16},{17},{19},{11} 共 77 个集合,所以输出应该为 77。

数据规模与约定
  • 对于 80%80% 的数据,1≤�≤�≤1031≤a≤b≤103。
  • 对于 100100 的数据,1≤�≤�≤105,2≤�≤�1≤a≤b≤105,2≤p≤b。

思路:主要用了质数筛法和并查集,

#include 
using namespace std;
const int N=1e5+5;
int a,b,p;
int f[N];
int flag[N];
int vis[N],minprime[N];
void is_prime(int a)
{
	memset(vis,1,sizeof(vis));
	vis[0]=0,vis[1]=0;
	for (int i=2;i*i<=a;++i)
	{
		if (vis[i])
		{
			for (int j=i*i;j>a>>b>>p;
	int l=max(a,b);
	is_prime(l);
	//初始化
	for (int i=a;i<=b;++i)f[i]=i;
	for (int i = p; i <= b; ++i) {
        if (vis[i]) {
            int firstMultiple = ((a + i - 1) / i) * i; // 第一个大于等于a的i的倍数
            for (int j = firstMultiple; j <= b; j += i) {
                unionn(firstMultiple, j);
            }
        }
    }
	int cnt=0;
	for (int i=a;i<=b;++i)
	{
		if (flag[find(i)]==0)
		{
			flag[find(i)]++;
			cnt++;
		}
		else flag[find(i)]++;
	}
	cout<
修复公路https://www.luogu.com.cn/problem/P1111

题目背景

A 地区在地震过后,连接所有村庄的公路都造成了损坏而无法通车。政府派人修复这些公路。

题目描述

给出 A 地区的村庄数 �N,和公路数 �M,公路是双向的。并告诉你每条公路的连着哪两个村庄,并告诉你什么时候能修完这条公路。问最早什么时候任意两个村庄能够通车,即最早什么时候任意两条村庄都存在至少一条修复完成的道路(可以由多条公路连成一条道路)。

输入格式

第 11 行两个正整数 �,�N,M。

下面 �M 行,每行 33 个正整数 �,�,�x,y,t,告诉你这条公路连着 �,�x,y 两个村庄,在时间t时能修复完成这条公路。

输出格式

如果全部公路修复完毕仍然存在两个村庄无法通车,则输出 −1−1,否则输出最早什么时候任意两个村庄能够通车。

输入输出样例

输入 #1复制

4 4
1 2 6
1 3 4
1 4 5
4 2 3

输出 #1复制

5

说明/提示

1≤�,�≤�≤1031≤x,y≤N≤103,1≤�,�≤1051≤M,t≤105。

思路:用了并查集和结构体排序,把数据按照时间的顺序排,然后一个一个进并查集里面,直到可以连接所有的村庄

#include 
using namespace std;
struct node{
	int x;
	int y;
	int t;
}p[100005];
int f[100005];
bool cmp(node& a,node& b)
{
	return a.t>n>>m;
	for (int i=1;i<=n;++i)f[i]=i;
	for (int i=0;i>p[i].x>>p[i].y>>p[i].t;
	}
	sort(p,p+m,cmp);
	int tot=0;
	for (int i=0;i

树状数组

主要解决的是区间查询,单点查询,区间修改,单点修改的问题

相比前缀和而言更加的高效:

在前缀和中查询一个区间和的复杂度是O(1),计算所有前缀和需要n次,所以总共的复杂度是O(n),但是前缀和只能解决静态数组的区间和问题,而树状数组可以解决动态的数组区间和问题,由于是基于的树的思想,所以在创建前缀和时的复杂度是O(nlongn),计算前缀和的复杂度是O(logn),修改一次数据的复杂度也是O(logn),查询一次的复杂度也是O(logn),所以总复杂度是O(nlogn)

树状数组主要有lowbit(),update(),sum()三个函数组成简短高效

1.29学习总结_第1张图片

1.29学习总结_第2张图片

树状数组 1https://www.luogu.com.cn/problem/P3374

题目描述

如题,已知一个数列,你需要进行下面两种操作:

  • 将某一个数加上 �x

  • 求出某区间每一个数的和

输入格式

第一行包含两个正整数 �,�n,m,分别表示该数列数字的个数和操作的总个数。

第二行包含 �n 个用空格分隔的整数,其中第 �i 个数字表示数列第 �i 项的初始值。

接下来 �m 行每行包含 33 个整数,表示一个操作,具体如下:

  • 1 x k 含义:将第 �x 个数加上 �k

  • 2 x y 含义:输出区间 [�,�][x,y] 内每个数的和

输出格式

输出包含若干行整数,即为所有操作 22 的结果。

输入输出样例

输入 #1复制

5 5
1 5 4 2 3
1 1 3
2 2 5
1 3 -1
1 4 2
2 1 4

输出 #1复制

14
16

说明/提示

【数据范围】

对于 30%30% 的数据,1≤�≤81≤n≤8,1≤�≤101≤m≤10;
对于 70%70% 的数据,1≤�,�≤1041≤n,m≤104;
对于 100%100% 的数据,1≤�,�≤5×1051≤n,m≤5×105。

思路:是一道典型的单点修改,和区间查询的题

关于单点修改:

每个子节点的修改都需要把它的父节点,和父节点的父节点.....都修改了而子节点和父节点的规律也很好找,父节点就等于子节点x+lowbit(x),树状数组就相当于是前缀和,其中有一个树加了k那么后面的数也需要加k

void update(int x,int k)
{
	while(x<=n)
	{
		tree[x]+=k;
		x+=lowbit(x);//子节点+k,父节点都要+k 
	}
}

区间查询:

就相当于在前缀和和里面求L---R,想法就很简单是R的前缀和减去L-1的前缀和

int sum(int x)
{
	int res=0;
	while (x>0)
	{
		res+=tree[x];
		x-=lowbit(x);//求的是1---x的区间和 
	}
	return res;
}

以下是AC码

#include 
using namespace std;
#define int long long 
const int N=5e5+5;
#define lowbit(x) (x& (-x))
int tree[N],a[N];
int n;
void update(int x,int k)
{
	while(x<=n)
	{
		tree[x]+=k;
		x+=lowbit(x);//子节点+k,父节点都要+k 
	}
}
int sum(int x)
{
	int res=0;
	while (x>0)
	{
		res+=tree[x];
		x-=lowbit(x);//求的是1---x的区间和 
	}
	return res;
}
signed main()
{
	int q;
	cin>>n>>q;
	for (int i=1;i<=n;++i)
	{
		cin>>a[i];
		update(i,a[i]);
	}
	for (int i=0;i>a>>b>>c;
		if (a==1)
		{
			update(b,c);
		}
		else if (a==2)
		{
			int ans=0;
			ans=sum(c)-sum(b-1);
			cout<
树状数组 2https://www.luogu.com.cn/problem/P3368

题目描述

如题,已知一个数列,你需要进行下面两种操作:

  1. 将某区间每一个数加上 �x;

  2. 求出某一个数的值。

输入格式

第一行包含两个整数 �N、�M,分别表示该数列数字的个数和操作的总个数。

第二行包含 �N 个用空格分隔的整数,其中第 �i 个数字表示数列第 �i 项的初始值。

接下来 �M 行每行包含 22 或 44个整数,表示一个操作,具体如下:

操作 11: 格式:1 x y k 含义:将区间 [�,�][x,y] 内每个数加上 �k;

操作 22: 格式:2 x 含义:输出第 �x 个数的值。

输出格式

输出包含若干行整数,即为所有操作 22 的结果。

输入输出样例

输入 #1复制

5 5
1 5 4 2 3
1 2 4 2
2 3
1 1 5 -1
1 3 5 7
2 4

输出 #1复制

6
10

思路:这道题是典型的区间修改,和单点搜索

那么可以利用差分数组的性质,引入一个差分数组,在树状数组里面放差分数组的元素,那么树状数组就相当于存了原数组

初始化:

for (int i=1;i<=n;++i)
	{
		cin>>a[i];
		d[i]=a[i]-a[i-1];
		update(i,d[i]);//放的是差分数组的值,这样树状数组保存的就是差分数组的前缀和 
	}

如果要进行区间L---R修改,那就相当于在差分数组L处+c,在R+1处-c,然后更新数组,单点查询就是对差分数组求前缀和

#include 
using namespace std;
#define int long long 
const int N=5e5+5;
#define lowbit(x) (x& (-x))
int tree[N],a[N],d[N];
int n,q;
void update(int x,int k)
{
	while (x<=n)
	{
		tree[x]+=k;
		x+=lowbit(x);
	}
}
int sum(int x)
{
	int res=0;
	while (x>0)
	{
		res+=tree[x];
		x-=lowbit(x);
	}
	return res;
}
signed main()
{
	cin>>n>>q;
	for (int i=1;i<=n;++i)
	{
		cin>>a[i];
		d[i]=a[i]-a[i-1];
		update(i,d[i]);//放的是差分数组的值,这样树状数组保存的就是差分数组的前缀和 
	}
	for (int i=0;i>op;
		if (op==1)
		{
			int a,b,c;
			cin>>a>>b>>c;
			update(a,c);
			update(b+1,-c);
		}
		if (op==2)
		{
			int a;
			cin>>a;
			int res=sum(a);
			cout<

搜索:BFS

机器人搬重物https://www.luogu.com.cn/problem/P1126

题目描述

机器人移动学会(RMI)现在正尝试用机器人搬运物品。机器人的形状是一个直径 1.61.6 米的球。在试验阶段,机器人被用于在一个储藏室中搬运货物。储藏室是一个 �×�N×M 的网格,有些格子为不可移动的障碍。机器人的中心总是在格点上,当然,机器人必须在最短的时间内把物品搬运到指定的地方。机器人接受的指令有:

  • 向前移动 11 步(Creep);
  • 向前移动 22 步(Walk);
  • 向前移动 33 步(Run);
  • 向左转(Left);
  • 向右转(Right)。

每个指令所需要的时间为 11 秒。请你计算一下机器人完成任务所需的最少时间。

输入格式

第一行为两个正整数 �,� (1≤�,�≤50)N,M (1≤N,M≤50),下面 �N 行是储藏室的构造,00 表示无障碍,11 表示有障碍,数字之间用一个空格隔开。接着一行有 44 个整数和 11 个大写字母,分别为起始点和目标点左上角网格的行与列,起始时的面对方向(东 �E,南 �S,西 �W,北 �N),数与数,数与字母之间均用一个空格隔开。终点的面向方向是任意的。

输出格式

一个整数,表示机器人完成任务所需的最少时间。如果无法到达,输出 −1−1。

1.29学习总结_第3张图片

输入输出样例

输入 #1复制

9 10
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 1 0
0 0 0 1 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 1 0 0 0 0
0 0 0 1 1 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 1 0
7 2 2 7 S

输出 #1复制

12

思路:这道题细节很多,由于我们在坐标系中是一个点,然而他的障碍物是一个格子,所以这是一个易错点,我们需要排除,其次我们的指令是可以一步,两步,三步,换方向,所以我们的标记数组需要时三维的,最后需要记录当前的方向,其次在搜索的时候,我们不能把标记数组和越界放在一起,如果越界或者遇到障碍物,那就可以直接退出,因为后面的路也走不了,如果是走过的还可以继续扩展

#include 
using namespace std;

struct node {
    int x, y, d, t;
};

int check(char c) {
    if (c == 'S') return 1;
    else if (c == 'N') return 3;
    else if (c == 'E') return 0;
    else if (c == 'W') return 2;
}

int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
queue q;
int a[55][55], vis[55][55][4];
int main() {
    int m, n;
    cin >> m >> n;
    for (int i = 1; i <= m; ++i) {
        for (int j = 1; j <= n; ++j)
		{
			int b;
            cin>>b;
            if (b) 
			{
				a[i][j] = 1;
                a[i-1][j-1]=1;
                a[i-1][j]=1;
                a[i][j-1]=1;
       		}
    	}
	}
    int ex, ey, sx, sy;
    char fd;
    cin >> sx >> sy >> ex >> ey >> fd;
    if (ex == sx && ey == sy) {
        cout << 0;
        return 0;
    }
    int op = check(fd);
    q.push(node{sx, sy, op, 0});
    vis[sx][sy][op] = 1;

    while (!q.empty()) {
        node news = q.front();
        q.pop();
        if (news.x == ex && news.y == ey) {
            cout << news.t;
            return 0;
        }
        int x = news.x, y = news.y, t = news.t, d = news.d;
        for (int i = 1; i <= 3; ++i) 
		{
            int tx = x + i * dx[d], ty = y + i * dy[d];
            if (tx<1 || ty<1 || tx>=m || ty>=n ||a[tx][ty]==1)break;
            if (vis[tx][ty][d]) continue;
            q.push(node{tx, ty, d, t + 1});
            vis[tx][ty][d] = 1;
        }
        for (int i = -1; i <= 1; i += 2) {
            op = (d + 4 + i) % 4;
            if (!vis[x][y][op])
            {
            	q.push(node{x, y, op, t + 1});
            	vis[x][y][op] = 1;
			}
        }
    }
    cout << -1;
    return 0;
}

你可能感兴趣的:(学习)