蓝桥杯带刷题

Posted 2023-04-03 左手的月光

A::::::::::::::::::小数第n位

题目描述

我们知道，整数做除法时，有时得到有限小数，有时得到无限循环小数。

如果我们把有限小数的末尾加上无限多个 0，它们就有了统一的形式。

本题的任务是：在上面的约定下，求整数除法小数点后的第 n 位开始的 3 位数。

输入描述

输入一行三个整数：a b n，用空格分开。a 是被除数，b 是除数，n是所求的小数后位置（0<a,b,n<109）

输出描述

输出一行 3 位数字，表示：a 除以 b，小数后第 n 位开始的 3 位数字。

输入输出样例

示例

输入

1 8 1

输出

125

#include <iostream>
using namespace std;
long long a,b,c;
int main()
    cin>>a>>b>>c;
    a=a%b;      //求小数所以不影响,现在a<b,a*10/b就是第一个小数位 
  while(c-10>0)
    a=a*1e10;   //每次移动10位，一位乘以10,10位乘以1e10。
    a=a%b;
    c-=10;
  
    for(int i=1;i<=c+2;i++)
        if(i>=c)
            cout<<a*10/b;   //这一位的小数值 
         
        a=a*10%b;           //剩下的 
     
    return 0;

 B::::::::::::::::::卡片换位（BFS）

题目描述

你玩过华容道的游戏吗？

这是个类似的，但更简单的游戏。

看下面 3 x 2 的格子

+---+---+---+

| A | * | * |

+---+---+---+

| B | | * |

+---+---+---+

在其中放 5 张牌，其中 A 代表关羽，B 代表张飞，* 代表士兵。

还有个格子是空着的。

你可以把一张牌移动到相邻的空格中去(对角不算相邻)。

游戏的目标是：关羽和张飞交换位置，其它的牌随便在哪里都可以。

输入描述

输入两行 6 个字符表示当前的局面

输出描述

一个整数，表示最少多少步，才能把 A B 换位（其它牌位置随意）

输入输出样例

示例

输入

* A
**B

输出

17

运行限制

• 最大运行时间：1s
• 最大运行内存: 256M

#include <iostream>
#include <queue>
#include <map>
using namespace std;
string chushi[2];
int x,y,ax,ay,bx,by;
struct node
	int x,y;
	int ax,ay;
	int bx,by;
	int ans;
	string lu[2];
;
node one;
queue<node> q;
int g[4][2]=-1,0,1,0,0,-1,0,1;
bool check(int x,int y)
	return x>=0&&x<2&&y>=0&&y<3;

map<string,bool> pan;
int main()
	getline(cin,chushi[0]);
	getline(cin,chushi[1]);
	
	for(int i=0;i<2;i++)
		for(int j=0;j<3;j++)
			if(chushi[i][j]==' ')
				x=i,y=j;
			
			if(chushi[i][j]=='A')
				ax=i,ay=j;
			
			if(chushi[i][j]=='B')
				bx=i,by=j;
			
		
	
	one.x=x,one.y=y,one.ax=ax,one.ay=ay,one.bx=bx,one.ans=0;
	one.by=by,one.lu[0]=chushi[0],one.lu[1]=chushi[1];
	string mm=chushi[0]+chushi[1];
	pan[mm]=1;

	q.push(one);
	while(!q.empty())
		node f=q.front();
		q.pop();
		if(f.ax==bx && f.ay==by && f.bx==ax && f.by==ay)
			cout<<f.ans;
			break;
		
		

		for(int i=0;i<4;i++)
			int tx=f.x+g[i][0];
			int ty=f.y+g[i][1];
		
			if(check(tx,ty))
				
				string h[2];
				h[0]=f.lu[0];
				h[1]=f.lu[1];
				h[tx][ty]=' ';
				h[f.x][f.y]=f.lu[tx][ty];
			
				string mm=h[0]+h[1];
				
				if(!pan[mm])
					pan[mm]=1;
					int xx,yy,axx,ayy,bxx,byy;
					for(int i=0;i<2;i++)
						for(int j=0;j<3;j++)
							if(h[i][j]==' ')
								xx=i,yy=j;
							
							if(h[i][j]=='A')
								axx=i,ayy=j;
							
							if(h[i][j]=='B')
								bxx=i,byy=j;
							
						
					
					node two;
					two.x=xx,two.y=yy,two.ax=axx,two.ay=ayy,two.bx=bxx,two.ans=f.ans+1;
					two.by=byy,two.lu[0]=h[0],two.lu[1]=h[1];
					q.push(two);	
						
			
			
			
		
	
	return 0;

  C::::::::::::::::::左移右移（双向链表，双指针）

问题描述

小蓝有一个长度为 N 的数组, 初始时从左到右依次是1,2,3,…N 。

之后小蓝对这个数组进行了 M 次操作, 每次操作可能是以下 2 种之一:

1. 左移 x, 即把 x 移动到最左边。

2. 右移 x, 即把 x 移动到最右边。

请你回答经过 M 次操作之后, 数组从左到右每个数是多少?

输入格式

第一行包含 2 个整数, N 和 M 。

以下 M 行每行一个操作, 其中 “L x "表示左移 x, R   x  "表示右移 x 。

输出格式

输出 NN 个数, 代表操作后的数组。

样例输入

5 3
L 3
L 2
R 1

样例输出

2 3 4 5 1

样例说明

样例中的数组变化如下:

[1,2,3,4,5]→[3,1,2,4,5]→[2,3,1,4,5]→[2,3,4,5,1]

评测用例规模与约定

对于 50% 的评测用例1≤N,M≤10000.

对于 100% 的评测用例, 1≤N,M≤200000,1≤x≤N.

运行限制

• 最大运行时间：3s
• 最大运行内存: 512M

双向链表：

#include <iostream>
#include <list>
using namespace std;
list<int> l; 
int n,m;
int main()
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		l.push_back(i);
	
	for(int i=0;i<m;i++)
		char a;
		int v;
		cin>>a>>v;
		if(a=='L')
			l.remove(v);
			l.push_front(v);
		
		if(a=='R')
			l.remove(v);
			l.push_back(v);
		
	
	for(list<int>::iterator it=l.begin();it!=l.end();it++)
		cout<<*it<<' ';
	
	return 0;

 能过50%

双指针：

#include <iostream>
#include <algorithm>
using namespace std;
int n,m;
int a[200005];
struct node
	long long zuobiao;
	int zhi;
	bool operator<(const node &rhs)const
		return zuobiao<rhs.zuobiao;
	
;
node b[1000000];
int main()
	cin>>n>>m;
	long long l=-100;
	long long r=1e6;
	for(int i=1;i<=n;i++)
		b[i].zhi=i;
		b[i].zuobiao=i;
	
	for(int i=0;i<m;i++)
		char a;
		int v;
		cin>>a>>v;
		if(a=='L')
			b[v].zuobiao=l;
			l--;
		else
			b[v].zuobiao=r;
			r++;
		
	
	sort(b+1,b+n+1);
	for(int i=1;i<=n;i++)
		cout<<b[i].zhi<<' ';
	
	return 0;
 

  D::::::::::::::::::数数（思维）

问题描述

任何一个大于 1 的正整数都能被分解为若干个质数相乘, 比如 28=2×2×7 被分解为了三个质数相乘。请问在区间 [2333333, 23333333] 中有多少个正整数 可以被分解为 12 个质数相乘?

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数, 在提交答案时只填写这个整数, 填写多余的内容将无法得分。

运行限制

• 最大运行时间：1s
• 最大运行内存: 512M

 上千万的数据量，不可能12个循环吧

#include <iostream>
#include <vector>
using namespace std;
int ans;
bool sushu(int x)
	if(x==1)
		return false;
	
	if(x==2)
		return true;
	
	for(int i=2;i*i<=x;i++)
		if(x%i==0)
			return false;
		
	
	return true;

int su[23333339];
vector<int> p;
int main()
	long long a=2333333;
	long long b=23333333;
	for(int i=2;i<=b;i++)
		if(!su[i]&&sushu(i))
			su[i]=1;             //su[i]=1，代表i由一个数的值 
			p.push_back(i);      //素数压入动态数组 
		

		if(i>=a&&su[i]==12)   //判断是否是12个数的乘积 
			ans++;
		                     //当i==a时,p中是2到a的所有素数 

		for(vector<int>::iterator it=p.begin();it!=p.end();it++)
			if(i* *it>b)
				break;
			else
				su[i* *it]=su[i]+1;   //i* *it两个乘积，再i的基础上乘以*it，所以值加一； 
			
		
	
	cout<<ans;
	return 0;

 半分钟出答案，还是慢点，填空题无所谓了

  E::::::::::::::::::约瑟夫杯（队列，循环列表）

题目描述

设有 nn 个人围坐在圆桌周围，现从某个位置 kk 上的人开始报数，报数到 m 的人就站出来。下一个人，即原来的第 m+1 个位置上的人，又从 11 开始报数，再报数到 m 的人站出来。依次重复下去，直到全部的人都站出来为止。试设计一个程序求出这 n 个人的出列顺序。

要求一：采用循环链表解决。

要求二：可以使用模拟法，模拟循环链表。

要求三：可以不使用循环链表类的定义使用方式。

输入描述

输入只有一行且为用空格隔开的三个正整数 n,k,m，其含义如上所述。

输出描述

共 n 行，表示这 n 个人的出列顺序。

输入输出样例

示例 1

输入

3 5 8

输出

3
2
1

队列方法：

#include <iostream>
#include <queue>
using namespace std;
queue<int> q;
int n,k,m;     //n个人，k开始，m出 
int main()
	cin>>n>>k>>m;
	k=k%n; 
	for(int i=k;i<=n;i++)
		q.push(i);
	
	for(int i=1;i<k;i++)
		q.push(i);
	
	while(!q.empty())
		for(int i=1;i<m;i++)
			int c=q.front();
			q.pop();
			q.push(c); 
		
		int c=q.front();
		cout<<c<<endl;
		q.pop();
	
	return 0;
 

 循环链表方法：

#include <iostream>
using namespace std;


typedef struct node

  int data;
  struct node* next;
LNode, *Linklist;


void initlink(Linklist &head, int n)

  head = new LNode;
  LNode * p = head;
  p->data = 1;
  for (int i = 2; i <= n; i++)
  
    p->next = new LNode;
    p = p->next;
    p->data = i;
    
  p->next = head;       



void baoshu(Linklist &head, int k, int m)

  LNode *p = head;
  for (int i = 1; i < k; i++)
      p = p->next;
  while (p->next != p)
  
    for (int j = 1; j < m - 1; j++)  p = p->next;
    cout << p->next->data << endl;
    p->next = p->next->next;
    p = p->next;
  
  cout << p->data;


int main()

    int n, k, m;
    cin >> n >> k >> m;
    Linklist head;
    initlink(head, n);
    baoshu(head, k, m);

  F::::::::::::::::::移动字母（DFS,BFS）

题目描述

2x3=6 个方格中放入 ABCDE 五个字母，右下角的那个格空着。如下图所示。

和空格子相邻的格子中的字母可以移动到空格中，比如，图中的 C 和 E 就可以移动，移动后的局面分别是：

A B

D E C

A B C

D E

为了表示方便，我们把 6 个格子中字母配置用一个串表示出来，比如上边的两种局面分别表示为：

AB*DEC

ABCD*E

题目的要求是：请编写程序，由用户输入若干表示局面的串，程序通过计算，输出是否能通过对初始状态经过若干次移动到达该状态。可以实现输出 1,否则输出 0。初始状态为：ABCDE*。

输入描述

先是一个整数 nn，表示接下来有 nn 行状态。

输出描述

程序输出 nn 行 1 或 0。

输入输出样例

示例

输入

7 BCDEA* DAECB* ECABD* BCDAE* DAEBC* ECADB* EDCAB*

输出

1 1 1 0 0 0 0

#include <iostream>
#include <map>
using namespace std;
int n;
string a[2];
string b[2];
int bb[4][2]=1,0,-1,0,0,1,0,-1;
bool res;
map<string,bool> vis;
bool check1()
	for(int i=0;i<2;i++)
		for(int j=0;j<3;j++)
			if(a[i][j]!=b[i][j])
				return false;
			
		
	
	return true;

bool check2(int x,int y)
	return x>=0&&x<2&&y>=0&&y<3;

void dfs(int x,int y)

	if(res)
		return;
	
	if(check1())
		res=true;
		return;
	
	for(int i=0;i<4;i++)
		int tx=x+bb[i][0];
		int ty=y+bb[i][1];
		if(check2(tx,ty) )
			char c=a[x][y];
			a[x][y]=a[tx][ty];
			a[tx][ty]=c;
			
			if(!vis[a[0]+a[1]]) 
				vis[a[0]+a[1]]=1;
				dfs(tx,ty);

			
			c=a[x][y];
			a[x][y]=a[tx][ty];
			a[tx][ty]=c;
	
		
	

int main()
	cin>>n;
	
	for(int i=0;i<n;i++)
		a[0]="ABC";
		a[1]="DE*";
		for(int i=0;i<2;i++)
			for(int j=0;j<3;j++)
				cin>>b[i][j];
			
		
		res=false;
		vis.clear();
		dfs(1,2);
		if(res)
			cout<<1<<endl;
		else
			cout<<0<<endl;
		
	
	return 0;

  G::::::::::::::::::路径之迷（DFS）

题目描述

小明冒充 XX 星球的骑士，进入了一个奇怪的城堡。

城堡里边什么都没有，只有方形石头铺成的地面。

假设城堡地面是 n×n 个方格。如下图所示。

按习俗，骑士要从西北角走到东南角。可以横向或纵向移动，但不能斜着走，也不能跳跃。每走到一个新方格，就要向正北方和正西方各射一箭。（城堡的西墙和北墙内各有 n 个靶子）同一个方格只允许经过一次。但不必走完所有的方格。如果只给出靶子上箭的数目，你能推断出骑士的行走路线吗？有时是可以的，比如上图中的例子。

本题的要求就是已知箭靶数字，求骑士的行走路径（测试数据保证路径唯一）

输入描述

第一行一个整数 N (0≤N≤20)，表示地面有N×N 个方格。

第二行 N 个整数，空格分开，表示北边的箭靶上的数字（自西向东）

第三行 N 个整数，空格分开，表示西边的箭靶上的数字（自北向南）

输出描述

输出一行若干个整数，表示骑士路径。

为了方便表示，我们约定每个小格子用一个数字代表，从西北角开始编号: 0,1,2,3 ⋯

比如，上图中的方块编号为：

0 1 2 3

4 5 6 7

8 9 10 11

12 13 14 15

输入输出样例

示例

输入

4
2 4 3 4
4 3 3 3

输出

0 4 5 1 2 3 7 11 10 9 13 14 15

#include <iostream>
using namespace std;
int n;
int g[4][2]=1,0,-1,0,0,1,0,-1;
int shang[25];
int zuo[25];
int shang1[25];
int zuo1[25];
bool falge;
struct node
    int x,y;
;
node lu[405];
bool vis[25][25];
int m=1;
bool check1()
    for(int i=0;i<n;i++)
        if(shang[i]!=shang1[i] || zuo[i]!=zuo1[i])
            return false;
        
    
    return true;

bool check2(int x,int y)
    return x>=0&&y>=0&&x<n&&y<n;

bool check3()
    for(int i=0;i<n;i++)
        if(shang1[i]>shang[i] || zuo1[i]>zuo[i])
            return false;
        
    
    return true;

void dfs(int x,int y)
    if(!check3()|| falge)     //剪枝
        return;
    
    if(x==n-1&&y==n-1 && check1())
        for(int i=0;i<m;i++)
            cout<<lu[i].x*n+lu[i].y<<' ';
        
        falge=1;
        return;
    

    for(int i=0;i<4;i++)
        int tx=x+g[i][0];
        int ty=y+g[i][1];
        if(check2(tx,ty) && !vis[tx][ty])
            vis[tx][ty]=1;
            lu[m].x=tx;
            lu[m].y=ty;
            shang1[ty]+=1;
            zuo1[tx]+=1;
            m++;
            dfs(tx,ty);
            lu[m].x=0;
            lu[m].y=0;
            shang1[ty]-=1;
            zuo1[tx]-=1;
            m--;
            vis[tx][ty]=0;
        
    
    

int main()
    zuo1[0]=1;
    shang1[0]=1;
    lu[0].x=0;
    lu[0].y=0;
    vis[0][0]=1;
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>shang[i];
     
    for(int i=0;i<n;i++)
        cin>>zuo[i];
    
    dfs(0,0);
    return 0;

  H::::::::::::::::::分考场(DFS)

题目描述

n 个人参加某项特殊考试。

为了公平，要求任何两个认识的人不能分在同一个考场。

求最少需要分几个考场才能满足条件。

输入描述

输入格式：

第一行，一个整数 n (1≤n≤100)，表示参加考试的人数。

第二行，一个整数 m，表示接下来有 m 行数据。

以下 m 行每行的格式为：两个整数 a,b，用空格分开 ( 1≤a,b≤n )表示第 a 个人与第 b 个人认识。

输出描述

输出一行一个整数，表示最少分几个考场。

输入输出样例

示例

输入

5
8
1 2
1 3
1 4
2 3
2 4
2 5
3 4
4 5

输出

4

#include <iostream>
using namespace std;
int n,m;
bool xi[105][105];
int ans=1e8;
int cher[105][105];
void dfs(int p,int room)

	if(room>=ans)
		return;
	
	if(p>n)
		ans=min(ans,room); 
		return;
	
	for(int i=1;i<=room;i++)
		int j=0;
		while(cher[i][j] && !xi[cher[i][j]][p]) j++;
		if(!cher[i][j])
			cher[i][j]=p;
			dfs(p+1,room);
			cher[i][j]=0;
		
	
	
	cher[room+1][0]=p;
	dfs(p+1,room+1);
	cher[room+1][0]=0;
 
int main()
	cin>>n>>m;
	for(int i=1;i<=m;i++)
		int a,b;
		cin>>a>>b;
		xi[a][b]=xi[b][a]=1;
	
	dfs(1,1);   //第一个人，1个教室； 
	cout<<ans;  
	return 0;

  I::::::::::::::::::质数拆分(DP,01背包)

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

将 2019 拆分为若干个两两不同的质数之和，一共有多少种不同的方法？

注意交换顺序视为同一种方法，例如 2+2017=2019 与 2017+2=2019 视为同一种方法。

运行限制

• 最大运行时间：1s
• 最大运行内存: 128M

#include <iostream>
using namespace std;
long long f[2020][2020];    //前i个数组成j的方案数 

bool check(int x)
	if(x==1)
		return false;
	
	if(x==2)
		return true;
	
	for(int i=2;i*i<=x;i++)
		if(x%i==0)
			return false;
		
	
	return true;

int zhi[2020];
int main()
	int len=1;
	for(int i=1;i<2019;i++)
		if(check(i))
			zhi[len++]=i;
		
	
	f[0][0]=1;
	for(int i=1;i<len;i++)
		for(int j=0;j<=2019;j++)
			f[i][j]=f[i-1][j];
			if(j>=zhi[i])
				f[i][j]+=f[i-1][j-zhi[i]];
			
		
	
	cout<<f[len-1][2019];
	return 0;

 for(int i=1;i<len;i++)
        for(int j=0;j<=2019;j++)
            f[i][j]=f[i-1][j];
            if(j>=zhi[i])
                f[i][j]+=f[i-1][j-zhi[i]];
            
        
    

状态1：目标:值小于该质数时  f[i][j]=f[i-1][j];

状态2：目标:值不小于该质数时 要加上前i-1质数构成该指数的方案数f[i][j]+=f[i-1][j-zhi[i]];

    

J::::::::::::::::::修改数组（并查集）

题目描述

给定一个长度为 N 的数组 A=[A1​,A2​,⋅⋅⋅,AN​]，数组中有可能有重复出现的整数。

现在小明要按以下方法将其修改为没有重复整数的数组。小明会依次修改A2​,A3​,⋅⋅⋅,AN​。

当修改 Ai​ 时，小明会检查 Ai​ 是否在 A1​ ∼ Ai​−1 中出现过。如果出现过，则小明会给 Ai​ 加上 1 ；如果新的 Ai​ 仍在之前出现过，小明会持续给 Ai​ 加 1 ，直 到 Ai​ 没有在 A1​ ∼ Ai​−1 中出现过。

当 AN​ 也经过上述修改之后，显然 A 数组中就没有重复的整数了。

现在给定初始的 A 数组，请你计算出最终的 A 数组。

输入描述

第一行包含一个整数 N。

第二行包含 N 个整数 A1​,A2​,⋅⋅⋅,AN​。

其中，1≤N≤105，1≤Ai​≤106。

输出描述

输出 N 个整数，依次是最终的 A1​,A2​,⋅⋅⋅,AN​。

输入输出样例

示例

输入

5
2 1 1 3 4

输出

2 1 3 4 5

 建立一个并查集，初始化根节点都是自己，当第一次出现时，返回根节点也就是自己，然后根节点加一，下次再次查找该数时，发现自己不是大boss，然后找boss，若是下一个boss也不是大boss，就继续找，直到找到大boss。

#include <iostream>
using namespace std;
int a[10000005];
int find(int x)
	if(a[x]!=x) a[x]=find(a[x]);
	return a[x];  //不是大boss去找大boss 

void jiaru(int x,int y)
	int tx=find(x);
	int ty=find(y);
	if(tx!=ty)             //不是一个大boss建立新的树 
		a[x]=y;
	
 
int n; 
int main()
	cin>>n;
	for(int i=1;i<=10000005;i++)
		a[i]=i;                 //初始化根节点都是自己 
	
	for(int i=1;i<=n;i++)
		int x;
		cin>>x;
		x=find(x);
		cout<<x<<' ';
		a[x]=x+1;
	 
	return 0;

蓝桥杯带刷，带刷！！！

A:::::::::::::::::::::::::::::::::::m计划（双指针，滑动窗口，倍增）

题目描述

小明是个鹅卵石收藏者，从小到大他一共收藏了 nn 块鹅卵石，编号分别为 1∼n，价值分别为 a1​，a2​，⋯,an​。

这天他乘船准备去往蓝桥王国，然而天有不测风云，小明所在的海域下起了暴雨。

很快小明船上的积水越来越多，为了防止沉船，小明不得不选择若干块他收藏的鹅卵石丢弃。

小明制定了一套名为m计划的选择方案，其内容如下：

• 对于任意区间 [i,i + m - 1]丢弃价值最小的鹅卵石i∈[1,n−m+1]。
• 对于一块鹅卵石，它在 m 计划中是可以被丢弃多次的。

请你输出将被小明丢弃的鹅卵石的价值。

输入描述

输入第 1 行包含两个正整数 n,m。

接下来一行包含 n 个正整 a1​,a2​,⋯,an​，表示鹅卵石的价值。

1≤m≤n≤5×10的5次方，0≤ai​≤10的9次方。

输出描述

输出共 n−m+1 行，每行输出一个整数，第 i 行输出整数的含义为 ai​,ai+1​,⋯,ai+m−1​ 的最小值。

输入输出样例

示例 1

输入

5 3
5 3 2 4 1

输出

2
2
1

#include <iostream>
using namespace std;
int n,m;
int a[500005];
struct node
	int xiabiao;
	int min1;
;
node check1(int x,int y)
	node ans1;
	ans1.xiabiao=0;
	ans1.min1=1000000;
	for(int i=x;i<=y;i++)
		if(a[i]<=ans1.min1)
			ans1.min1=a[i];
			ans1.xiabiao=i;
		
	
	return ans1;


bool check2(int l,int r,int x)
	return x>=l&&x<=r;



int main()
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		cin>>a[i];
	
	node mm=check1(1,m);
	int l=2,r=m+1;
	cout<<mm.min1<<endl;
	while(r<=n)
		if(check2(l,r,mm.xiabiao))
			if(mm.min1>=a[r])
				mm.min1=a[r];
				mm.xiabiao=r;
			
		else
			mm=check1(l,r);
		
		cout<<mm.min1<<endl;
		r++;
		l++;
	
	
	return 0;

B:::::::::::::::::::::::::::::::::::长草（BFS）

题目描述

小明有一块空地，他将这块空地划分为 n 行 m 列的小块，每行和每列的长度都为 1。

小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。

这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，

这四小块空地都将变为有草的小块。请告诉小明，k 个月后空地上哪些地方有草。

输入描述

输入的第一行包含两个整数 n,m。

接下来 n 行，每行包含 m 个字母，表示初始的空地状态，字母之间没有空格。如果为小数点，表示为空地，如果字母为 g，表示种了草。

接下来包含一个整数 k。 其中，2≤n,m≤1000，1≤k≤1000。

输出描述

输出 n 行，每行包含 mm 个字母，表示 k 个月后空地的状态。如果为小数点，表示为空地，如果字母为 g，表示长了草。

输入输出样例

示例

输入

4 5
.g...
.....
..g..
.....
2

输出

gggg.
gggg.
ggggg
.ggg.

运行限制

• 最大运行时间：1s
• 最大运行内存: 256M

#include <iostream>
#include <queue>
using namespace std;
int n,m,k;
char a[1005][1005];
struct node
	int x,y;
	int su;
	node(int xx,int yy,int suu)
		x=xx;
		y=yy;
		su=suu;
	
;
queue<node> h;
bool check(int x,int y)
	return x>=1&&x<=n&&y>=1&&y<=m; 
 
int f[4][2]=1,0,-1,0,0,-1,0,1;
int main()
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			cin>>a[i][j];
			if(a[i][j]=='g')
				h.push(node(i,j,0));
			
		 
	
	cin>>k;
	while(!h.empty())
		node j=h.front();
		h.pop();
		for(int i=0;i<4;i++)
			int tx=j.x+f[i][0];
			int ty=j.y+f[i][1];
			if(check(tx,ty) && a[tx][ty]=='.' && j.su+1<=k)
				a[tx][ty]='g';
				h.push(node(tx,ty,j.su+1));
			
		
	
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			cout<<a[i][j];
		
		cout<<endl;
	
	return 0;

C:::::::::::::::::::::::::::::::::::带分数（全排列）

题目描述

100 可以表示为带分数的形式：100 = 3 + 69258 / 714

还可以表示为：100 = 82 + 3546 / 197

注意特征：带分数中，数字 1~9 分别出现且只出现一次（不包含 0 ）。

类似这样的带分数，100 有 11 种表示法。

输入描述

从标准输入读入一个正整数  (N<1000×1000)。

输出描述

程序输出该数字用数码 1~9 不重复不遗漏地组成带分数表示的全部种数。

注意：不要求输出每个表示，只统计有多少表示法！

输入输出样例

示例

输入

100

输出

11

运行限制

• 最大运行时间：3s
• 最大运行内存: 64M

#include <iostream>
#include <algorithm>
using namespace std;
int n;
long long ans;
int a[9]=1,2,3,4,5,6,7,8,9;
int he(int l,int r)
	int ans1=0;
	for(int i=l;i<=r;i++)
		ans1=ans1*10+a[i];
	
	return ans1;

int main()
	cin>>n;
	while(next_permutation(a,a+9))
		for(int i=0;i<7;i++)
			for(int j=i+1;j<8;j++)
				int a=he(0,i);
				int b=he(i+1,j);
				int c=he(j+1,8);
				if(a*c+b==n*c)
					ans++;
				
			
		
	
	cout<<ans; 
	return 0;

 D:::::::::::::::::::::::::::::::::::合根植物（并查集）

题目描述

w 星球的一个种植园，被分成 m×n 个小格子（东西方向 m 行，南北方向 n 列）。每个格子里种了一株合根植物。

这种植物有个特点，它的根可能会沿着南北或东西方向伸展，从而与另一个格子的植物合成为一体。

如果我们告诉你哪些小格子间出现了连根现象，你能说出这个园中一共有多少株合根植物吗？

输入描述

第一行，两个整数 m,n，用空格分开，表示格子的行数、列数（1≤m,n≤1000）。

接下来一行，一个整数 k (0≤k≤105 )，表示下面还有 k 行数据。

接下来 k 行，每行两个整数 a，b，表示编号为 a 的小格子和编号为 b 的小格子合根了。

格子的编号一行一行，从上到下，从左到右编号。

比如：5×4 的小格子，编号：

1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
17 18 19 20

输出描述

输出植物数量。

输入输出样例

示例

输入

5 4
16
2 3
1 5
5 9
4 8
7 8
9 10
10 11
11 12
10 14
12 16
14 18
17 18
15 19
19 20
9 13
13 17

输出

5

样例说明

其合根情况参考下图：

运行限制

• 最大运行时间：2s
• 最大运行内存: 256M

#include <iostream>
#include <algorithm>
using namespace std;
int m,n,k;
int vis[1000005];
int fa[1000005];
int find(int x)
	if(fa[x]==x) return x;
	return fa[x]=find(fa[x]);

int ans;
void jiaru(int x,int y)
	int tx=find(x);
	int ty=find(y);
	if(tx!=ty)
		fa[tx]=ty;
	

int main()
	cin>>m>>n>>k;
	for(int i=0;i<=n*m;i++)
		fa[i]=i;
	
	for(int i=0;i<k;i++)
		int a,b;
		cin>>a>>b;
		jiaru(a,b);
	
	for(int i=1;i<=n*m;i++)
		vis[find(i)]=1;
	
	for(int i=1;i<=n*m;i++)
		if(vis[i])
			ans+=1;
		
	
	cout<<ans; 
	return 0;

 E:::::::::::::::::::::::::::::::::::修建公路(最小生成树，并查集)

题目描述

LL 城一共有 N 个小区。

小明是城市建设的规划者，他计划在城市修 M 条路，每修建一条路都要支付工人们相应的工钱（需要支付的工钱 = 路的长度）。

然而小明所拿到的经费并不够支付修建 M 条路的工钱，于是迫于无奈，他只能将计划改变为修建若干条路，使得 N 个小区之间两两联通。

小明希望尽量剩下更多的经费投入到别的项目中，因此请你通过程序帮他计算出完成计划所需的最低开销。

输入描述

输入第一行包含三个正整数N,M。

第 2 到 M+1 行每行包含三个正整数 u,v,w，表示 u↔v 之间存在一条距离为 w 的路。

输出描述

输出占一行，包含一个整数，表示完成计划所需的最低开销。

若无法完成计划，则输出 -1−1。

输入输出样例

示例 1

输入

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

输出

8

运行限制

• 最大运行时间：3s
• 最大运行内存: 256M、

#include <iostream>
#include <algorithm>
using namespace std;
int n,m;
int fa[100005];
int find(int x)
	if(fa[x]==x) return x;
	return fa[x]=find(fa[x]);

struct node
	int qi,zhong;
	int juli;
;
bool cmp(node x,node y)
	return x.juli<y.juli;


long long ans;
node g[300005];
int main()
	cin>>n>>m;   //n个城市，m个规划
	for(int i=1;i<=n;i++)
		fa[i]=i;
	
	for(int i=1;i<=m;i++)
		cin>>g[i].qi>>g[i].zhong>>g[i].juli;
	
	sort(g+1,g+m+1,cmp);
	for(int i=1;i<=m;i++)
		int tx=find(g[i].qi);
		int ty=find(g[i].zhong);
		if(tx!=ty)
			ans+=g[i].juli;
			fa[tx]=ty;
		
	
	int w=find(1);
	for(int i=1;i<=n;i++)
		if(w!=find(i))
			cout<<-1;
			return 0;
		
	
	cout<<ans;
	return 0;

 F:::::::::::::::::::::::::::::::::::小明的背包2（完全背包）

题目描述

小明有一个容量为 V 的背包。

这天他去商场购物，商场一共有 N 种物品，第 ii 种物品的体积为 wi​，价值为 vi​，每种物品都有无限多个。

小明想知道在购买的物品总体积不超过 V 的情况下所能获得的最大价值为多少，请你帮他算算。

输入描述

输入第 1 行包含两个正整数 N,V，表示商场物品的数量和小明的背包容量。

第 2∼N+1 行包含 2 个正整数w,v，表示物品的体积和价值。

输出描述

输出一行整数表示小明所能获得的最大价值。

输入输出样例

示例 1

输入

5 20
1 6
2 5
3 8
5 15
3 3 

输出

120

#include <iostream>
#include <cmath>
using namespace std;
int n,v;
int wi[1005];
int vi[1005];
int dp[1005][1005];
int main()
	cin>>n>>v;
	for(int i=1;i<=n;i++)
		cin>>wi[i]>>vi[i];  //体积和价值 
	
	for(int i=1;i<=n;i++)
		for(int j=1;j<=v;j++)
			dp[i][j]=dp[i-1][j];
			if(j>=wi[i])
				dp[i][j]=max(dp[i-1][j],dp[i][j-wi[i]]+vi[i]);
			
		
	
	cout<<dp[n][v];
	return 0;

 G:::::::::::::::::::::::::::::::::::作物杂交（搜索）

题目描述

作物杂交是作物栽培中重要的一步。已知有 N 种作物 (编号 1 至 N)，第 i 种作物从播种到成熟的时间为 Ti​。作物之间两两可以进行杂交，杂交时间取两种中时间较长的一方。如作物 A 种植时间为 5 天，作物 B 种植时间为 7 天，则 AB 杂交花费的时间为 7 天。作物杂交会产生固定的作物，新产生的作物仍然属于 N 种作物中的一种。

初始时，拥有其中 M 种作物的种子 (数量无限，可以支持多次杂交)。同时可以进行多个杂交过程。求问对于给定的目标种子，最少需要多少天能够得到。

如存在 4 种作物 ABCD，各自的成熟时间为 5 天、7 天、3 天、8 天。初始拥有 AB 两种作物的种子，目标种子为 D，已知杂交情况为 A × B → C，A × C → D。则最短的杂交过程为：

第 1 天到第 7 天 (作物 B 的时间)，A × B → C。

第 8 天到第 12 天 (作物 A 的时间)，A × C → D。

花费 12 天得到作物 D 的种子。

输入描述

输入的第 1 行包含 4 个整数 N,M,K,T，NN 表示作物种类总数 (编号 1 至 N)，MM 表示初始拥有的作物种子类型数量，KK 表示可以杂交的方案数，TT 表示目标种子的编号。

第 2 行包含 N 个整数，其中第 ii 个整数表示第 ii 种作物的种植时间 Ti​ (1≤Ti​≤100)。

第 3 行包含 M 个整数，分别表示已拥有的种子类型 (1≤Kj​≤M)，Kj​ 两两不同。

第 4 至 K + 3 行，每行包含 3 个整数 A,B,C，表示第 A 类作物和第 B 类作物杂交可以获得第 C 类作物的种子。

其中，1≤N≤2000,2≤M≤N,1≤K≤105,1≤T≤N, 保证目标种子一定可以通过杂交得到。

输出描述

输出一个整数，表示得到目标种子的最短杂交时间。

输入输出样例

示例

输入

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

输出

16

样例说明

第 1 天至第 5 天，将编号 1 与编号 2 的作物杂交，得到编号 3 的作物种子。

第 6 天至第 10 天，将编号 1 与编号 3 的作物杂交，得到编号 4 的作物种子。

第 6 天至第 9 天，将编号 2 与编号 3 的作物杂交，得到编号 5 的作物种子。

第 11 天至第 16 天，将编号 4 与编号 5 的作物杂交，得到编号 6 的作物种子。

总共花费 16 天。

运行限制

语言	最大运行时间	最大运行内存
C++	2s	256M
C	2s	256M
Java	3s	256M
Python3	10s	256M

#include <iostream>
#include <vector>
using namespace std;
const int maxn=0x3f3f3f3f;
int tim[2010];
int dp[2010]; 
vector<pair<int, int> > zajiao[2010]; 
int f(int n)
	if (dp[n]!=maxn) return dp[n];
	for (int i=0;i<zajiao[n].size();++i)
		int a=zajiao[n][i].first,b=zajiao[n][i].second;
		int tmp = max(f(a), f(b))+max(tim[a],tim[b]);
		dp[n]=min(dp[n],tmp);
	 
	return dp[n];

int main()
	for (int i=0;i<2010;i++)
		dp[i]=maxn;
	
	int n,m,k,t;
	cin>>n>>m>>k>>t;
	for (int i=1;i<=n;++i)
		cin>>tim[i];
	
	for (int i=1;i<=m;++i)
		int j;
		cin>>j;
		dp[j]=0;
	
	for (int i=1;i<=k;++i)
		int a,b,c;
		cin>>a>>b>>c;
		zajiao[c].push_back(make_pair(a, b));
	
	f(t);
	cout<<dp[t]<<endl;
	return 0; 

 H:::::::::::::::::::::::::::::::::::序列求和(DFS，唯一分解定理)

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

学习了约数后，小明对于约数很好奇，他发现，给定一个正整数 tt，总是可以找到含有 tt 个约数的整数。小明对于含有 tt 个约数的最小数非常感兴趣，并把它定义为 S_tSt​ 。

例如S1​=1,S2​=2,S3​=4,S4​=6，⋅⋅⋅ 。

现在小明想知道，前 60 个 Si​ 的和是多少？即 S1​+S2​+⋅⋅⋅+S60​ 是多少？

运行限制

• 最大运行时间：1s
• 最大运行内存: 128M

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
vector<long long> m;
int su[100000];
bool check(long long x)
	if(x==1)
		return false;
	
	if(x==2)
		return true;
	
	for(int i=2;i*i<=x;i++)
		if(x%i==0)
			return false;
		
	
	return  true;

long long pow1(long long a,long long b)
	long long ans=1;
	while(b)
		if(b&1) ans=ans*a;
		b/=2;
		a*=a;
	
	return ans;

long long ans;
long long res1=1e18;
long long dfs(long long x,vector<long long>g) 

	if(check(x)||x==1)return pow1(2,x-1); 
	for(long long i=2;i*i<=x;i++)
	
		if(x%i==0)
		
			long long t=x/i;
			g.push_back(i);
			

			vector<long long>tmp=g;
			tmp.push_back(t); 
			sort(tmp.begin(),tmp.end(),greater<long long>());
			long long s=1;
			for(int j=0;j<tmp.size();j++)
				s*=pow1(su[j],tmp[j]-1);	
			res1=min(res1,s);
			
			dfs(t,g);
			g.pop_back();
		
	
	return res1;

int main()
	int cc=0;
	for(int i=2;i<=100000;i++)
		if(check(i))
			su[cc]=i;
			cc++;
		
	
	ans=1+2+4+6;
	for(int i=5;i<=60;i++)
		res1=1e18;
		m.clear();
		long long ans1=dfs(i,m);
		ans+=ans1;
	
	cout<<ans;
	return 0;

  I:::::::::::::::::::::::::::::::::::青蛙跳杯子（BFS）

题目描述

XX 星球的流行宠物是青蛙，一般有两种颜色：白色和黑色。

XX 星球的居民喜欢把它们放在一排茶杯里，这样可以观察它们跳来跳去。

如下图，有一排杯子，左边的一个是空着的，右边的杯子，每个里边有一只青蛙。

∗WWWBBB

其中，W 字母表示白色青蛙，B 表示黑色青蛙，*∗ 表示空杯子。

X 星的青蛙很有些癖好，它们只做 3 个动作之一：

1. 跳到相邻的空杯子里。

2. 隔着 1 只其它的青蛙（随便什么颜色）跳到空杯子里。

3. 隔着 2 只其它的青蛙（随便什么颜色）跳到空杯子里。

对于上图的局面，只要 1 步，就可跳成下图局面：

WWW∗BBB

本题的任务就是已知初始局面，询问至少需要几步，才能跳成另一个目标局面。

输入描述

输入为 2 行，2 个串，表示初始局面和目标局面。我们约定，输入的串的长度不超过 15。

输出描述

输出要求为一个整数，表示至少需要多少步的青蛙跳。

输入输出样例

示例

输入

*WWBB
WWBB*

输出

2

运行限制

• 最大运行时间：1s
• 最大运行内存: 256M

#include <iostream>
#include <queue>
#include <string>
#include <map>
using namespace std;
string a,b;
struct node
	string a;
	int bu;
	int x;
	node(string aa,int buu,int xu)
		a=aa;
		bu=buu;
		x=xu;
	
;
string jiaohuan(string a,int x,int y)
	char m=a[x];
	a[x]=a[y];
	a[y]=m;
	return a;

map<string,bool> kk;
queue<node> q;
bool check(int x)
	return x>=0 && x<a.size();

int f[6]=1,-1,2,-2,3,-3;
int main()
	cin>>a>>b;
	int c=0;
	for(int i=0;i<a.size();i++)
		if(a[i]=='*')
			c=i;
		
	
	kk[a]=1;
	q.push(node(a,0,c)); 
	while(!q.empty())
		node t=q.front();
		q.pop();

		if(t.a==b)
			cout<<t.bu;
			break;
		

		for(int i=0;i<6;i++)
			int tx=t.x+f[i];
			string xx=jiaohuan(t.a,t.x,tx);
			if(check(tx) && !kk[xx])
				kk[xx]=1;
				q.push(node(xx,t.bu+1,tx));
			
		
	
	return 0;

   J:::::::::::::::::::::::::::::::::::剪格子（DFS）

题目描述

如下图所示，3 x 3 的格子中填写了一些整数。

我们沿着图中的红色线剪开，得到两个部分，每个部分的数字和都是 60。

本题的要求就是请你编程判定：对给定的 m×n 的格子中的整数，是否可以分割为两个部分，使得这两个区域的数字和相等。

如果存在多种解答，请输出包含左上角格子的那个区域包含的格子的最小数目。

如果无法分割，则输出 0。

输入描述

输入描述

程序先读入两个整数 m,n 用空格分割 (m,n<10)，表示表格的宽度和高度。

接下来是 n 行，每行 m 个正整数，用空格分开。每个整数不大于 104。

输出描述

在所有解中，包含左上角的分割区可能包含的最小的格子数目。

输入输出样例

示例

输入

3 3
10 1 52
20 30 1
1 2 3

输出

3

运行限制

• 最大运行时间：5s
• 最大运行内存: 64M

#include <iostream>
using namespace std;
int a[15][15];
int n,m;
int sum;
int he;
int ans=1e9;
bool vis[15][15];
int aa[4][2]=1,0,-1,0,0,-1,0,1;
bool check(int x,int y)
	return x>=0&&x<=n&&y>=0&&y<=m;

void dfs(int x,int y,int g)
	if(g>=ans)
		return;
	
	if(he==sum/2)
		ans=min(ans,g);
	
	for(int i=0;i<4;i++)
		int tx=x+aa[i][0];
		int ty=y+aa[i][1];
		if(check(tx,ty) && !vis[tx][ty])
			vis[tx][ty]=1;
			he+=a[tx][ty];
			dfs(tx,ty,g+1);
			he-=a[tx][ty];
			vis[tx][ty]=0;
		
	

int main()
	cin>>m>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			int x=0;
			cin>>x;
			a[i][j]=x;
			sum+=x;
		
	
	if(sum%2==1)
		cout<<0;
		return 0;
	
	vis[1][1]=1;
	he=a[1][1];
	dfs(1,1,1);
	cout<<ans;
	return 0;