文章展示了多个使用C++编程解决的算法问题，包括基于BFS的三维地牢搜索，完全二叉树的权值计算，离散数学中的交换瓶子问题，以及通过因子优化和特定处理技术解决的货物摆放和乘积尾零计算。此外，还涉及了字符串处理和矩阵翻转的问题。
1.地牢大师（一道三维的bfs）
#include<bits/stdc++.h>
using namespace std;
const int N=110;
bool st[N][N][N];
int dis[N][N][N];
char room[N][N][N];
int l,r,c;
struct point{
int x,y,z;
};
point s,End;
int dx[6]={1,-1,0,0,0,0},dy[6]={0,0,1,-1,0,0},dz[6]={0,0,0,0,1,-1};
void bfs(point start,point end)
{
queue<point>q;
q.push(start);
dis[start.x][start.y][start.z]=0;
while(q.size())
{
int x=q.front().x;
int y=q.front().y;
int z=q.front().z;
q.pop();
for(int i=0;i<6;i++)
{
int nex=x+dx[i];
//printf("nex=%d",nex);
int ney=y+dy[i];
int nez=z+dz[i];
if(nex>=0&&nex<l&&ney>=0&&ney<r&&nez>=0&&nez<c&&(room[nex][ney][nez]=='.'
||room[nex][ney][nez]=='E')&&!st[nex][ney][nez])
{
st[nex][ney][nez]=true;
dis[nex][ney][nez]=dis[x][y][z]+1;
q.push({nex,ney,nez});
//printf("1=%d,2=%d,3=%d\n",nex,ney,nez);
if(nex==end.x&&ney==end.y&&nez==end.z)
{
printf("Escaped in %d minute(s).\n",dis[nex][ney][nez]);
return;
}
}
}
}
printf("Trapped!\n");
return;
}
int main()
{
while(cin >> l >> r >> c && (l||r||c))
{
memset(st,0,sizeof st);
for(int i=0;i<l;i++)
{
for(int j=0;j<r;j++)
{
for(int k=0;k<c;k++)
{
cin >> room[i][j][k];
if(room[i][j][k]=='S')
{
s.x=i;
s.y=j;
s.z=k;
}
if(room[i][j][k]=='E')
{
End.x=i;
End.y=j;
End.z=k;
}
}
}
}
bfs(s,End);
}
return 0;
}直接使用二维的bfs进行扩展就可以，三维存在六个d步数组。使用一个结构体来保存三维坐标，基本上一遍过，有点小bug在打for（6）对于步的循环的时候不小心从1开始了。前面的错误主要有1.st没有memset。 2.在进行准入判断的时候没有将==‘E’加入导致读不到出口。
2.完全二叉树的权值（类似于双指针找规律）
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
typedef long long LL;
int arr[N];
int main()
{
LL n,keep,max=-1e18;//数据范围，理论上来说最小值是所有1e5个-1e5加和就是-1e10；
cin >> n;
for(int i=1;i<=n;i++)
{
scanf("%d",&arr[i]);
}
for(int k=1,d=1;k<=n;k*=2,d++)
{
LL cnt=0;
for(int j=k;j<k+(1<<(d-1))&&j<=n;j++)//因为是二叉树，所以最底层可能会数组越界要么数组开大一点要么就设置j《=n
{
cnt+=arr[j];
//cout << cnt <<" " << d << " ";
}
if(cnt>max)
{
max=cnt;
//cout << max << " ";
keep=d;
}
}
cout << keep;
return 0;
}基本上是模拟的感觉，没有用到什么算法，但是还是需要有个基本的印象比较容易写出来。需要注意的是数据范围，对于1e5最底层是1e5级别的数据可能造成和爆int，同时数组会因为最底层遍历爆栈。
3.交换瓶子（离散数学）
#include<bits/stdc++.h>
using namespace std;
int n;
const int N=1e5+10;
int arr[N];
bool st[N];
int main()
{
cin >> n;
int j=0,cnt=0;
for(int i=1;i<=n;i++)
{
cin >> arr[i];
}
for(int i=1;i<=n;i++)
{
if(!st[i])
{
cnt++;
for(int j=i;!st[j];j=arr[j])
{
st[j]=true;
}
}
}
cout << n-cnt;
return 0;
}暴力也可以做，主要是对于离散知识的考查，但是我感觉y总讲的并不是很清楚，推导过程感觉有点问题。但是将当前位置和正确位置使用图论的方式存储起来，并且有入度出度都为1只存在环的特性是想不到的。存在环内换边（将一个环拆成两个环)，和环间元素换边（将两个环合成一个环）两种操作，这个题需要将所有变成自己连自己的环，所以需要先判断有多少个环再将n-环的数量，就是需要换边的最少操作数。
对于环的判断，采用了判除数组，感觉有点类似于并查集的检测方法,如果没有遍历过，就从该元素开始，向指向的元素遍历，直到遍历到判除过的数组。
4.货物摆放（因子优化枚举）
蓝桥杯的一道填空题，数组量给到了16位的被除数，如果采用常规的暴力做法需要干到1e32的时间复杂程度不止。使用了一种因子优化的思路，遍历的时候遍历到i*i*i<=n，这样就压缩到了1e6左右的时间复杂程度，在遍历第二层的时候只考虑（n%i==0）只考虑i作为因子的数，后续中采用了i*j*j<=n的方式枚举，再次减少了时间复杂程度，非常巧妙，将第三位压住到大数上，但是第三位可以采用前两位和被除数算出来。如果（n/i%j==0）那么在有两个因子的情况下算出来k，这样子就算出来了所有的可能组合，因为大小不固定，而i，j，k没有对应的大小要求关系，所以还需要考虑这些组合可以形成多少种答案。首先是如果三个都相同，那么只有一种，其中两个相同，那么有c32=3种情况，最多三种都不同，有3*2*1=6种情况可以。
#include <iostream>
using namespace std;
int main()
{
// 请在此输入您的代码
unsigned long long N=2021041820210418;
long long i,j,k,sum=0;
for(i=1;i*i*i<=N;i++) //注意每个for循环的终止条件！！
if(N%i==0)
for(j=i;i*j*j<=N;j++) //j=i+1就不对了，必须是j=i
if(N/i%j==0){
k=N/i/j;
if(i==j||i==k||j==k)sum+=3;
else if(i==j&&i==k)sum++;//3个相同
else sum+=6;}
cout<<sum;
return 0;
}这样子优化在devc上可以跑出1.14s，做填空题还是ok的。
5.乘积尾零（因子处理）
又是一道蓝桥杯填空题，感觉我蓝桥杯要被干烂了，一轮游一波了。很多个数相乘看看最后有多少个末尾0。对于乘积考虑有多少个2和5因子凑出来的，如果有就为末尾0.考虑5的因子数远远大于2，那么这个题目就转变成为了计算所有乘数数中一共有多少个5为因子。
#include<bits/stdc++.h>
using namespace std;
int main()
{
int c,cnt=0;
while(cin >> c)
{
while(c%5==0)
{
cnt++;
c/=5;
}
}
cout << cnt;
return 0;
}6.double strings
暴力使用三重循环枚举的话会超时，所以使用拆分字符串的方式再在其中找有没有这个字符串。因为字符串最长为8的原因，本来n*n*n的时间复杂程度变成了n*n*8的时间复杂度。
#include<bits/stdc++.h>
using namespace std;
const int N=100010;
string st[N];
set<string>q;
int main()
{
int n;
cin >> n;
while(n--)
{
q.clear();
int num;
cin >> num;
for(int i=0;i<num;i++)
{
cin >> st[i];
q.insert(st[i]);
}
for(int i=0;i<num;i++)
{
bool flag=false;
for(int j=1;j<st[i].size();j++)
{
string l=st[i].substr(0,j);
string r=st[i].substr(j,st[i].size());
if(q.count(l)==1&&q.count(r)==1)
{
flag=true;
break;
}
}
if(flag==true) printf("1");
else printf("0");
}
cout << endl;
}
return 0;
}7.mirror gold
主要是矩阵翻转的坐标变换的数学知识。0(x,y)->90(t,n-x+1)->180(n-y+1,x)->270(n-x+1,n-y+1)。统计翻转的所有矩阵中是变0需要的次数多还是变1需要的次数多（即是翻转矩阵是1多还是0多）。
#include<bits/stdc++.h>
using namespace std;
const int N=110;
char room[N][N];
bool st[N][N];
int main()
{
int n;
cin >> n;
while(n--)
{
int cnt=0;
int sz;
cin >> sz;
//cout << sz << endl;
for(int i=1;i<=sz;i++)
{
for(int j=1;j<=sz;j++)
{
cin >> room[i][j];
st[i][j]=false;
//cout << room[i][j];
}
//cout << endl;
}
for(int i=1;i<=sz;i++)
{
for(int j=1;j<=sz;j++)
{
int cnt0=0;
int cnt1=0;
if(!st[i][j])
{
if(room[i][j]=='0') cnt0++;
else cnt1++;
st[i][j]=true;
st[j][sz-i+1]=true;
st[sz-j+1][i]=true;
st[sz-i+1][sz-j+1]=true;
// printf("i=%d j=%d",i,j);
// printf("room1=%d",room[j][sz-i+1]);
// printf("room2=%d",room[sz-j+1][i]);
// printf("room3=%d",room[sz-i+1][sz-j+1]);
if(room[j][sz-i+1]=='0') cnt0++;
else cnt1++;
if(room[sz-j+1][i]=='0') cnt0++;
else cnt1++;
if(room[sz-i+1][sz-j+1]=='0') cnt0++;
else cnt1++;
// printf("cnt0=%d cnt1=%d\n",cnt0,cnt1);
cnt+=min(cnt0,cnt1);
}
}
}
printf("%d\n",cnt);
}
return 0;
}8.Yet Another Problem About Pairs Satisfying an Inequality
给一个数组，要求输出所有ai<i<aj<j。首先归纳规律满足后面必须满足ai<i，那么先使用了一个b【N】存储所有n及n以前满足ai<i的数量。巧妙的是后面使用了sum+=b[arr[i]-1]的操作，完美实现了不等式，b里面的下标都是i，而arr【i】-1是该下标最大的值，相当巧妙。
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
const int manx = 2e6 + 10;
long long a[manx];
long long b[manx];
int main()
{
int t;
cin >> t;
while (t--)
{
int n;
cin >> n;
long long ans = 0;
for (int i = 1; i <= n; i++)
{
cin >> a[i];
b[i] = b[i - 1] + (a[i] < i);
if (a[i] < i && a[i] - 1 >= 1)
{
ans += b[a[i] - 1];
}
}
cout << ans << endl;
}
}
扫一扫
469
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
