学了点碎碎的小知识

感觉学了不少东西，预知后续，请往下看。

找出数据结构

SJJG把SJ一起看，SJ乘J乘G

数据结构（SJJG）是算法最好的朋友，有一天他们两个进行捉迷藏，数据结构（SJJG）躲进了一堆大写的英文字母当中，当然聪明的数据结构（SJJG）不会一整个的傻傻的站在字母中被找，它可以将自己的字母进行分散，但是顺序不会变化。请你在一大堆字母中找出可能拼成算法的好朋友数据结构（SJJG）的个数。

例如ABSDJJGJFG中有四个“SJJG”，其中

第一个SJJG由第三位（S）、第五位（J）、第六位（J）、第七位（G）组成

第二个SJJG由第三位（S）、第五位（J）、第六位（J）、第十位（G）组成

第三个SJJG由第三位（S）、第五位（J）、第七位（J）、第十位（G）组成

第四个SJJG由第三位（S）、第六位（J）、第七位（J）、第十位（G）组成

输入格式:
输入一大堆不为空的大写字母，长度不超过10
​5
​​ 。

输出格式:
输出在这一大堆字母中可能拼成算法的好朋友数据结构（SJJG）的个数。

由于结果可能比较大，因此只输出对100001取余的结果。

输入样例:
ABSDJJGJFG

输出样例:
4

#include <bits/stdc++.h>

using namespace std;

char a[100010];
long long sj=0,s=0,g=0;
long long sum=0;

int main(){
    scanf("%s",a);
    for(int i=0;i<strlen(a);i++) {
        if(a[i]=='G')
            g++;
    }
    for(int i=0;i<strlen(a);i++){
        if(a[i]=='G')
            g--;
        if(a[i]=='S')
            s++;
        if(a[i]=='J'){
            sum=(sum+sj*g)%100001;
            sj+=s;
        }
    }
    cout<<sum<<endl;
    return 0;
}

简单的计算题

模拟除法

计算⌊
​B
​
​A
​​ ⌋ % C，其中 A 是不超过 1000位的正整数，B 和 C 为小于 10
​9
​​ 的正整数，你需要计算⌊
​B
​
​A
​​ ⌋ % C的结果并将其输出。

注：⌊x⌋ 为取不超过 x 的最大整数，即 x−1<⌊x⌋≤x。
输入格式:
在一行中依次给出 A、 B 和 C 的值，中间以空格分隔。

输出格式:
输出⌊
​B
​
​A
​​ ⌋ % C 的结果。

输入样例:
100000 9 10

输出样例:
1

#include <bits/stdc++.h>

using namespace std;

char s[1010];
int ans=0;
struct node{
    int shu[1010];
    int len;
    node(){
        memset(shu,0, sizeof(shu));
        len=0;
    }
};
node change(char s[]){
    node t;
    t.len=strlen(s);
    for(int i=0;i<strlen(s);i++){
        t.shu[i]=s[i]-'0';
    }
    return t;
}

node divide(node a,int n){
    ans=0;
    node t;
    t.len=a.len;
    for(int i=0;i<a.len;i++){
        ans=a.shu[i]+ans*10;
        t.shu[i]=ans/n;
        ans=ans%n;
    }
    if(t.len>1&&t.shu[0]==0){
        for(int i=0;i<t.len-1;i++)
            t.shu[i]=t.shu[i+1];
        t.len--;
    }
    return t;
}


int main(){
    //freopen("in","r",stdin);
    int b,c;
    scanf("%s %d %d",s,&b,&c);
    node a=change(s);
    a=divide(a,b);
    a=divide(a,c);
    printf("%d",ans);

    return 0;
}

模拟炸弹人

广度优先搜索，bfs

接下来我们就对《炸弹人》进行一次简化模拟：

首先我们需要一个 N×M 大小的矩阵来存放地图，矩阵中 ‘*’ 代表没有点燃的炸弹，‘0’代表空地，玩家可以自定义炸弹的威力为 p （由于我们是简化模拟，所以 p 只会取 1 或者 2 ）；像《炸弹人》一样，炸弹可以引发自己上、下、左、右（斜角不算）各 p 格范围内产生爆炸，并且爆炸可以产生连锁反应，问至少需要进行几次引爆才可以让所有的炸弹都爆炸。

例如： 在 5×7 的矩阵

0 0 * * 0 0 0
0 0 * 0 0 0 0
0 0 0 0 0 * 0
0 * * 0 0 0 0
0 0 0 * 0 0 0

中，当玩家把炸弹的威力 p 设为 1 时至少需要进行 4 次引爆，

而当玩家把炸弹的威力 p 设为 2 时至少需要进行 3 次引爆。

输入格式:
在第一行定义矩阵的大小 n,m,1≤n,m≤10
​3
​​ 和炸弹的威力 p,p∈{1,2}，数字之间用空格隔开

随后 n 行是由‘0’和‘*’两种字符组成的 n×m 矩阵，字符之间用空格隔开。

输出格式:
在一行中输出至少需要进行几次引爆可以让所有的炸弹都爆炸。

输入样例1:
5 7 1
0 0 * * 0 0 0
0 0 * 0 0 0 0
0 0 0 0 0 * 0
0 * * 0 0 0 0
0 0 0 * 0 0 0

输出样例1:
4

输入样例2:
5 7 2
0 0 * * 0 0 0
0 0 * 0 0 0 0
0 0 0 0 0 * 0
0 * * 0 0 0 0
0 0 0 * 0 0 0

输出样例2:
3

#include <bits/stdc++.h>

using namespace std;
char s;
int a[1010][1010];
int n,m,p;
void bfs(int x,int y,int id){
    queue<pair<int,int>>Q;
    Q.push({x,y});
    a[x][y]=id;
    while(Q.size()){
        int X=Q.front().first;
        int Y=Q.front().second;
        Q.pop();
        for(int i=max(X-p,1);i<=min(X+p,n);i++){
            for(int j=max(Y-p,1);j<=min(Y+p,m);j++){
                if(i>=1&&i<=n&&j>=1&&j<=m&&a[i][j]==-1&&(i==X||j==Y)){
                    a[i][j]=id;
                    Q.push({i,j});
                }
            }
        }
    }


}
int main(){

    cin>>n>>m>>p;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            cin>>s;
            a[i][j]=(s =='0'?0:-1);
        }
        getchar();
    }
    int ans=1;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(a[i][j]==-1) {
                bfs(i, j, ans);
                ans++;
            }
        }
    }
    ans=ans-1;
    cout<<ans<<endl;
    return 0;
}