CSP2014-09

　　CSP201409-1 相邻数对

 

 

 

水题yyds ，要不是今天卡死在了201403-03题上我怎么会来拿水题出气，害

//
//  main.cpp
//  CSP201409-1 相邻数对
//
//  Created by sylvia on 2021/10/15.
//  Copyright © 2021 apple. All rights reserved.
//

#include <algorithm>
#include <iostream>
using namespace std;
int main(){
    int n,i,ans=0;
    cin>>n;
    int a[n];
    for (i=0;i<n;++i){
        cin>>a[i];
    }
    sort(a,a+n);
    for(i=0;i<n-1;++i){
        if(a[i+1]-a[i]==1) ans++;
    }
    cout<<ans<<endl;
    return 0;
}

 

　　CSP201409-2画图

 

 

 

 

 

 

出气题第二题，2014-03明日再战

//
//  main.cpp
//  CSP201409-2画图
//
//  Created by sylvia on 2021/10/15.
//  Copyright © 2021 apple. All rights reserved.
//

#include <iostream>
#include <string.h>
using namespace std;
#define MAX 100+2

int main(){
    int n,x,y,a,b,ans[MAX][MAX],res=0;;
    cin>>n;
    memset(ans,0,sizeof(ans));
    
    for (int i=0;i<n;i++){
        cin>>x>>y>>a>>b;
        for (int j=x+1;j<=a;j++){
            for (int k=y+1;k<=b;k++){
                ans[j][k]=1;
            }
        }
    }
    for (int i=1;i<=100;i++){
        for (int j=1;j<=100;j++){
            res+=ans[i][j];
        }
    }
    cout<<res<<endl;
    return 0;
}

 

　　CSP201409-3 字符串匹配

 

 

 

 

 

 　　仍然水题，但是我被字符串搞怕了qwq，每次遇到字符串，读入上我就败了orzzzz

　　使用strlwr转换为小写，使用strstr查找子串

　　列一下相关函数：

1.strstr()：检索子串在字符串中首次出现的位置

　　原型：char *strstr( char *str, char * substr );

　　如未出现返回NULL

　　头文件：#include<string.h>

 

2.strlwr()：将字符串str中的大写字母转换为小写

　　原型：char *strlwr(char *str);

　　直接改变str串

　　头文件：#include <string.h>

 

3.strupr()：将字符串s转换为大写形式

原型：char *strupr(char *str);

头文件：#include <string.h>

 

4.tolower()：把给定的字母转换为小写字母

　　原型：int tolower(int c) 

　　只能转换单个字符，返回小写字母

　　头文件：#include <ctype.h>

 

4.toupper()：把给定的字母转换为大写字母

　　原型：int tolupper(int c) 

　　只能转换单个字符，返回大写字母

　　头文件：#include <ctype.h>

另外一些查找函数：https://www.cnblogs.com/kmist/p/10099867.html

//
//  main.cpp
//  CSP201409-3 字符串匹配
//
//  Created by sylvia on 2021/10/16.
//  Copyright © 2021 apple. All rights reserved.
//

#include <iostream>
#include <string.h>

using namespace std;
#define N 100+2
char str[N],line[N],line2[N];

int main(){
    int a,n;
    cin>>str;
    cin>>a>>n;
    if(!a) strlwr(str);
    for (int i=1;i<=n;i++){
        cin>>line;
        strcpy(line2,line);
        if(!a) strlwr(line);
        if(strstr(line,str)) cout<<line2<<endl;
    }
    return 0;
}

 

　　CSP201409-4 最优配餐

 

 

 

 

 

经典dfs（多源最短路）

复习dfs戳这里 

dfs解决两类问题：

第一类问题：从节点A出发，有前往节点B的路径吗？
第二类问题：从节点A出发，前往节点B的哪条路径最短？

以栋栋的分店为起点，客户为目标点，求每个客户到分店的最短距离，若以客户为起点搜索，则对于每一个客户都要进行一次搜索，单次搜索的时间复杂度为O(n²)，则总的时间复杂度O(n⁴)。
换个思路，我们假设存在一个超级远点，这个超级远点与每个分店的距离为0，即将分店加入队列，对其进行bfs，谁先搜索到客户算谁的

这里学习到了结构体内构造函数进行初始化，以及第一次使用stl里面的队列，果然好用，以下几个常用函数

• front()：返回 queue 队列头
• back()：返回 queue 队列尾
• push(obj)：加入队列
• pop()：出队
• size()：队列长度
• empty()：判断是否队空，空为true

//
//  main.cpp
//  CSP201409-4 最优配餐
//
//  Created by sylvia on 2021/10/20.
//  Copyright © 2021 apple. All rights reserved.
//

#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <queue>
#include <string.h>
using namespace std;
#define MAX 1000+5
#define LL long long
int cnt[MAX][MAX];
int vis[MAX][MAX];
LL ans=0;
int n,m,k,d;
struct node{
    int x,y,t;
    node(int xx,int yy,int tt=0):x(xx),y(yy),t(tt){}  //初始化
};

int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
int main(){
    register int a,b,num;
    memset(vis,0,sizeof(vis));
    memset(cnt,0,sizeof(cnt));
    cin>>n>>m>>k>>d;
    queue<node> q;
    while(m--){
        cin>>a>>b;
        q.push(node{a,b});
        vis[a][b]=1;   //加入队列
        
    }
    while(k--){
        cin>>a>>b>>num;
        cnt[a][b]+=num;  //送餐数
    }
    while(d--){
        cin>>a>>b;
        cnt[a][b]=-1;  //走不通
    }
    while (!q.empty()){
        node v=q.front();  //取d头元素
        q.pop();  //出队
        if(cnt[v.x][v.y]>0){ //如果到了客户点
            ans+=(LL)cnt[v.x][v.y]*v.t;
        }
        for (int i=0;i<4;++i){ //四个方向
            int tx=v.x+dir[i][0];
            int ty=v.y+dir[i][1];
            //可以走并未走过
            if(tx>0&&tx<=n&&ty>0&&ty<=n&&!vis[tx][ty]&&cnt[tx][ty]!=-1){
                q.push(node{tx,ty,v.t+1});
                vis[tx][ty]=1;  //打标记
            }
        }
        
    }
    cout<<ans<<endl;
    return 0;
    
}