B.数列求值
题目内容
解题思路
1.题目难度不大，就是简单的斐波那契数列；
2.但是在遍历过程中，因为项数太多，无法完全存储；所以我们应该%10000，这样可以节约空间；
代码展示
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e5;
/*
4659
*/
int main(){
// int n;
// cin>>n;
// int a=1,b=1,c=1;
// for(int i=4;i<=n;i++){
// int temp=c;
// c=a+b+c;
// c=c%10000;
// a=b;
// b=b%10000;
// b=temp;
// }
cout<<4659<<endl;
return 0;
}
C.最大降雨量
题目内容
解题思路
1.这题计算量很小，不需要代码；
2.因为要求中位数，根据中位数的性质我们可以知道，必须要保证前面的数尽可能的小；
3.所以应该先填充左半部分，这样就能保证每行的中位数都尽可能大；
4.当每行的中位数，也就是第四列都尽可能大时，第四列的中位数也就最大了；
5.答案是'34'；
图片展示
D.迷宫
题目内容
输入文件
01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000
解题思路
题目是非常典型的广搜，但在处理路径方向时有不同的方法；
1.记录路径状态
1.因为要求字典序最小的最短路，且根据广搜的特性，先到达的就是最短路，所以我们应把每次节点的下个访问点的方向改为DLRU;
2.用结构体存储节点的下标以及从起点(1,1)出发到该节点(x,y)的路径信息；
代码展示
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e5;
/*
DLRU
010000
000100
001001
110000
为什么不能用下标~~
*/
struct node{
int x,y;
string step;
};
int dx[]={1,0,0,-1};
int dy[]={0,-1,1,0};
char s[1000];
char w[]={'D','L','R','U'};
bool vis[1000][1000];
char G[1000][1000];
int main(){
int n,m;
cin>>n>>m;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
cin>>G[i][j];
node ftemp;
queue<node>q;
ftemp.x=0,ftemp.y=0,ftemp.step="";
q.push(ftemp);
while(!q.empty()){
node temp=q.front();
q.pop();
vis[temp.x][temp.y]=1;
if(temp.x==n-1&&temp.y==m-1){
cout<<temp.step<<endl;
break;
}
for(int i=0;i<4;i++){
int fx=temp.x+dx[i];
int fy=temp.y+dy[i];
if(fx<0||fx>=n||fy<0||fy>=m||G[fx][fy]=='1'||vis[fx][fy])continue;
ftemp.x=fx,ftemp.y=fy,ftemp.step=temp.step+w[i];
q.push(ftemp);
}
}
return 0;
}
2.标记到达每个节点的上个节点的移动方向
1。基本思想跟(1)一样，只是存储路径的方法不一样；
2.这里标记了到达每个节点的方向，因为是求最短路，所以第一次到达节点时走的方向就是最短路的一部分(因为递归的层次性)；
3.在遍历完之后，从(n,m)开始访问，直到(0,0);
代码展示
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e5;
/*
DLRU
010000
000100
001001
110000
为什么不能用下标~~
*/
struct node{
int x,y;
};
int dx[]={1,0,0,-1};
int dy[]={0,-1,1,0};
char s[1000];
char w[]={'D','L','R','U'};
bool vis[1000][1000];
int way[1000][1000];
char G[1000][1000];
int main(){
int n,m;
cin>>n>>m;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
cin>>G[i][j];
node ftemp;
queue<node>q;
ftemp.x=0,ftemp.y=0;
q.push(ftemp);
string ans="";
vis[0][0]=1;
while(!q.empty()){
node temp=q.front();
q.pop();
if(temp.x==n-1&&temp.y==m-1){
break;
}
for(int i=0;i<4;i++){
int fx=temp.x+dx[i];
int fy=temp.y+dy[i];
if(fx<0||fx>=n||fy<0||fy>=m||G[fx][fy]=='1'||vis[fx][fy])continue;
ftemp.x=fx,ftemp.y=fy,way[fx][fy]=i;
vis[ftemp.x][ftemp.y]=1;
q.push(ftemp);
}
}
int ex=n-1,ey=m-1;
while(ex!=0||ey!=0){
cout<<ex<<" "<<ey<<endl;
ans+=w[way[ex][ey]];
ex-=dx[way[ex][ey]];
ey-=dy[way[ex][ey]];
}
reverse(ans.begin(),ans.end());
cout<<ans<<endl;
return 0;
}
E.RSA解密
题目内容
解题思路
代码展示
F.完全二叉树的权值
题目内容
解题思路
1.根据二叉树的性质，可以用数组进行存储；
2.每一层的节点下标为[2^lev,2^(lev+1)-1];
3.遍历判断即可；
代码展示
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=4e5+10;
/*
7
1 6 5 4 3 2 1
*/
ll Tree[maxn];
int main(){
int n;
cin>>n;
for(int i=1;i<=n;i++)
cin>>Tree[i];
int k=1;int lev=1;
ll ans=0,anslev=0;
while(k<=n){
int maxlev=pow(2,lev);
ll num=0;
while(k<maxlev&&k<=n)num+=Tree[k],k++;
if(ans<num){
ans=num;
anslev=lev;
}
lev+=1;
// cout<<maxlev<<endl;
}
cout<<anslev<<endl;
return 0;
}
G.外卖店优先级
题目内容
解题思路
1.考虑外卖店之间相互独立，故可以单独处理所有的店铺
2.对于每一个店铺，求出他在每次接单后的lev；
3.判断t时刻该店铺是否在队列中：
lev>5 一定在
lev=5 当该店铺接最后一个订单的时间<=t-1时(因为这样才能保证该店铺之前>5)
lev==4时 当该店铺接最后一个订单的时间<=t-2时(因为这样才能保证该店铺之前>5)
lev<=3 不在
代码展示
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e5+10;
/*
1.每一个时间单位，没有订单就-1，有订单就+2
max(0,num);
2.优先级>5 加入
优先级<=3 删除
思路：
以外卖店为~来查找订单
2 6 4
1 1
1 2
1 1
1 2
1 1
1 2
*/
vector<int>Re[maxn];
int lev[maxn];
int main(){
int n,m,t;
cin>>n>>m>>t;
while(m--){
int a,b;
cin>>a>>b;
Re[b].push_back(a);
}
for(int i=1;i<=n;i++)
sort(Re[i].begin(),Re[i].end());
int ans=0;
for(int i=1;i<=n;i++){
int pre=0;int l=Re[i].size();
for(int j=0;j<l;j++){
int temptime=Re[i][j];
if(temptime-pre>1){
lev[i]=max(0,lev[i]-(temptime-pre-1));
}
lev[i]+=2;
pre=temptime;
}
if(t!=pre)
lev[i]=max(0,lev[i]-(t-pre));
if(lev[i]>3&&((lev[i]==5&&pre<=t-1)||(lev[i]==4&&pre<=t-2)||lev[i]>5))
ans+=1;
}
cout<<ans<<endl;
return 0;
}
H.修改数组
题目内容
解题思路
1.暴力搜
1.暴力搜只能过80%(在考试的时候也是美滋滋~~~)
代码展示
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e5;
/*
*/
bool vis[1000005];
int num[maxn+10];
int main(){
int n;
cin>>n;
for(int i=0;i<n;i++)
cin>>num[i];
for(int i=0;i<n;i++){
while(vis[num[i]])num[i]++;
vis[num[i]]=1;
}
for(int i=0;i<n;i++){
if(i!=0)cout<<" ";
cout<<num[i];
}
return 0;
}
2.并查集
1.初始时令fa[i]=i；
2.对于一个数而言，有两种状态：
'fa[i]未被占用'
那么它就直接是fa[i]，然后+1，是为了下次出现时不会重复；
'fa[i]被占用'
上一次出现的时候，已经+1了，也可以直接输出；
代码展示
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e6+10;
/*
并查集求法
5
2 1 1 3 4
*/
int fa[maxn];
bool vis[maxn];
int Find(int x){
if(x==fa[x])return x;
return fa[x]=Find(fa[x]);
}
int main(){
for(int i=1;i<=maxn;i++)
fa[i]=i;
int n;
cin>>n;
for(int i=0;i<n;i++){
int x;
cin>>x;
x=Find(x);
cout<<x<<" ";
fa[x]=x+1;
}
return 0;
}
I.糖果
题目描述
解题思路
1.暴力搜
1.DFS(x,num)表示从第x个开始搜，已经选了num包；
2.当所有糖果都有时，return;
3.值得注意的时，要先判断所有包的糖果中是否包含所有种类的糖，如果不包含，就是-1；
~~~当然，这样只能过40%~~~~~~·
代码展示
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e5;
/*
1.-1的情况
遍历所有糖果时没有m种
2.
*/
int sug[105][25];
int n,m,k;
int ans;
int vis[25];
bool Judge(){
for(int i=1;i<=m;i++)
if(vis[i]==0)return false;
return true;
}
void DFS(int x,int num){//搜索第x包糖，已经拿了num包
if(Judge()){
// for(int i=1;i<=m;i++)
// cout<<vis[i]<<" ";
// cout<<endl<<"num = "<<num<<endl;
// cout<<"ans"
ans=min(ans,num);
return;
}
if(x>n)return;
for(int i=x;i<=n;i++){
for(int j=1;j<=k;j++)
vis[sug[i][j]]+=1;
DFS(i+1,num+1);
for(int j=1;j<=k;j++)
vis[sug[i][j]]-=1;
}
}
int main(){
cin>>n>>m>>k;
ans=n+1;
for(int i=1;i<=n;i++){
for(int j=1;j<=k;j++){
cin>>sug[i][j];
vis[sug[i][j]]++;
}
}
if(Judge()==false){
cout<<"-1"<<endl;
return 0;
}
memset(vis,0,sizeof(vis));
DFS(1,0);
cout<<ans<<endl;
return 0;
}
2.DP
1.难点好像就在于位运算！？
在这里插入代码片
J.组合数问题
题目描述
454
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
