SUST_ACM_2019届暑期ACM集训热身赛题解

问题A:Hello SUST!

知识点：基本输入输出

C/C++：

 1 #include <stdio.h>
 2 
 3 int main() {
 4     int n;
 5     scanf("%d", &n);
 6     while(n --) {
 7         printf("Hello SUST!
");
 8     }
 9     return 0;
10 }

问题B:计算A+B

知识点：基本输入输出

C/C++：

1 #include <cstdio>
2 
3 int main() {
4     int a, b;
5     while(~scanf("%d %d", &a, &b)) {
6         printf("%d
", a + b);
7     }
8     return 0;
9 }

问题C:

知识点：基本输入输出

C/C++：

1 #include <cstdio>
2 
3 int main() {
4     int n;
5     while(scanf("%d", &n) && n) {
6         printf("%d
", n * (n + 1) / 2);
7     }
8     return 0;
9 }

问题D:

知识点：递推

C/C++：

#include <cstdio>
using namespace std;

const int maxn = 20 + 5;
typedef long long ll;
ll ans[maxn];
int t, n;

int main() {
    ans[0] = ans[1] = 1;
    for(int i = 2; i < maxn; i ++) {
        ans[i] = ans[i - 1] + ans[i - 2];
    }
    scanf("%d", &t);
    while(t --) {
        scanf("%d", &n);
        printf("%lld
", ans[n]);
    }
    return 0;
}

问题E:

知识点：排序

C/C++：

#include <cstdio>
#include <algorithm>
using namespace std;

const int maxn = 10 + 5;
double score[maxn];

bool cmp(const double &a, const double &b) {
    return a > b;
}

int main() {
    int t, n, m;
    scanf("%d", &t);
    while(t --) {
        scanf("%d %d", &n, &m);
        for(int i = 0; i < n; i ++) scanf("%lf", &score[i]);
        // sort(score, score + n, cmp);//可用冒泡排序代替
        // /*
            for(int i = 0; i < n - 1; i ++) {
                for(int j = 0; j < n - 1 - i; j ++) {
                    if(score[j + 1] > score[j]) {
                        double temp = score[j];
                        score[j] = score[j + 1];
                        score[j + 1] = temp;
                    }
                }
            }
        // */
        double ans = 0.0;
        for(int i = 0; i < m; i ++) {
            ans += score[i];
        }
        printf("%.2f
", ans / m * 1.0);
    }
    return 0;
}

问题F:

知识点：循环语句和判断语句

C/C++：

#include <cstdio>
#include <cstring>
using namespace std;

char G[3][3];
bool ans;

int main() {
    int t, flag;
    scanf("%d", &t);
    while(t --) {
        ans = false;
        for(int i = 0; i < 3; i ++) {
            scanf("%s", G[i]);
        }
        if((G[0][0] == '0' && G[1][1] == '0' && G[2][2] == '0') || (G[0][2] == '0' && G[1][1] == '0' && G[2][0] == '0'))
            ans = true;//检查斜向true
        if(!ans) {
            for(int i = 0; i < 3; i ++) {
                flag = 0;
                for(int j = 0; j < 3; j ++) {
                    if(G[i][j] == '0') flag ++;
                }
                if(flag == 3) {
                    ans = true;
                    break;
                }//检查横向
                flag = 0;
                for(int j = 0; j < 3; j ++) {
                    if(G[j][i] == '0') flag ++;
                }//检查纵向
                if(flag == 3) {
                    ans = true;
                    break;
                }
            }
        }
        if(ans) printf("Yes
");
        else printf("No
");
    }
    return 0;
}

问题G:

知识点：字符串存储

C/C++：

#include <cstdio>
#include <cstring>
using namespace std;

char str[8][20] = {
    "Monday",
    "Tuesday",
    "Wednesday",
    "Thursday",
    "Friday",
    "Saturday",
    "Sunday"
};

int main() {
    int n;
    while(scanf("%d", &n) && n) {
        if(n <= 7)
            printf("%s
", str[n - 1]);
    }
    return 0;
}

问题H:

知识点：循环语句

C/C++：

#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 100;
int value[4] = {2, 3, 5, 10};
bool vis[maxn];

int main() {
    int n;
    for(int i = 0; i <= 2; i ++) {
        for(int j = 0; j <= 2; j ++) {
            for(int k = 0; k <= 2; k ++) {
                for(int p = 0; p <= 2; p ++) {
                    vis[i * value[0] + j * value[1] + k * value[2] + p * value[3]] = true;
                }
            }
        }
    }
    while(scanf("%d", &n) && n) {
        if(vis[n]) printf("Y
");
        else printf("N
");
    }
    return 0;
}

问题I:

知识点：题目要判断三维空间内四个点是否共面，则只需知道由四个点组成的三个向量是否共面即可知道答案。

　　我们知道两个向量a, b, 的向量积等于垂直于他们所在平面的空间向量c,如果c与另一个向量d垂直，那我们就可以证明a，b，c三向量共面。

　　我们可以利用矩阵(行列式)计算出c向量，再与d进行点乘，判定结果是否为零即可(两向量平行，内积为零)。

C/C++：

#include <cstdio>
#include <cstdlib>
using namespace std;

struct node{
    int x, y, z;
} a[4], b[3];

bool plane() {
    bool ret = false;
    if(b[0].x * (b[1].y * b[2].z - b[1].z * b[2].y) - b[1].x * (b[0].y * b[2].z - b[0].z * b[2].y) + b[2].x * (b[0].y * b[1].z - b[0].z * b[1].y) == 0)
        ret = true;
    return ret;
}

int main()
{
    int T, day = 1;
    scanf("%d", &T);
    while(T--) {
        for(int i = 0; i < 4; i ++) {
            scanf("%d %d %d", &a[i].x, &a[i].y, &a[i].z);
        }
        for(int i = 0; i < 3; i ++) {
            b[i].x = a[i + 1].x - a[i].x;
            b[i].y = a[i + 1].y - a[i].y;
            b[i].z = a[i + 1].z - a[i].z;
        }
        if(plane())
            printf("Day #%d: Yes
", day);
        else
            printf("Day #%d: No
", day);
        day ++;
    }
    return 0;
}

问题J:

题意：

　　从L走到C的最短路dist是否小于k？小于k的话从L到C路径长度等于dist的不全重复的路径有几条？

思路：

　　由于DFS求解最短路之缓慢，所以我们可以先用BFS算出最短路，判断可行之后再用DFS求出满足条件的条数即可。在执行DFS时，我们先从起点出发，任意选择其中一条路并且一直走到不满足题解的状态时我们回退到上一个可以继续往前走的状态继续往前走，往前走的时候记得标记走过的路，往回走的时候记得取消标记，这样可以保证所有路都被找到并且没有重复，实现起来也比较简便。

C/C++：

#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
using namespace std;

typedef pair<int, int> pii;
const int maxn = 1e3 + 5;
int n, m, k, step, ans, Dist;
char G[maxn][maxn];
int dist[maxn][maxn];
bool vis[maxn][maxn];
pii B, E, now, Next;
/*
    这里的pair完全可以用结构体代替

    pair<int, int> 可以看作是一个类似于结构体的寄存器
    比如 struct P {
        int first, second;
    }now;
    可以用now.first, now.second访问这个变量的两个值。
    也可以申明pair<int, int>类型的数组，也就相当于struct P array[size];
 */
int bfs(int x, int y) {
    memset(vis, false, sizeof vis);
    memset(dist, 0, sizeof dist);
    queue <pii> Q;
    Q.push(make_pair(x, y));
    dist[x][y] = 0;
    while(!Q.empty()) {
        pii now = Q.front();
        Q.pop();
        if(now.first == E.first && now.second == E.second) return dist[now.first][now.second];
        for(int dx = -1; dx <= 1; dx ++) {
            for(int dy = -1; dy <= 1; dy ++) {
                if(abs(dx - dy) == 1) {
                    Next.first = now.first + dx;
                    Next.second = now.second + dy;
                    if(!vis[Next.first][Next.second] && Next.first >= 0 && Next.first < n && Next.second >= 0 && Next.second < m && G[Next.first][Next.second] != '#') {
                        dist[Next.first][Next.second] = dist[now.first][now.second] + 1;
                        Q.push(make_pair(Next.first, Next.second));
                        vis[Next.first][Next.second] = true;
                    }
                }
            }
        }
    }
    return -1;
}

void dfs(pii B, pii E, int D) {
    if(B.first == E.first && B.second == E.second) {
        if(D == ans) step ++;//如果当前访问的结点为终点且到起点的距离为最短路则step++
    }
    if(D > ans) return;//如果当前路径在D步内不能到达终点则回退，换下一条路
    for(int i = -1; i <= 1; i ++) {
        for(int j = -1; j <= 1; j ++) {
            if(abs(i - j) == 1) {//由于只能从上下左右四个方向走，所以可以找出这样的关系式，读者可以自行在草稿纸上进行验证
                if(B.first + i >= 0 && B.first + i < n && B.second + j >= 0 && B.second + j < m) {//不越界
                    if(G[B.first + i][B.second + j] != '#' && !vis[B.first + i][B.second + j]) {//判断是否没有访问过且不为石头
                        vis[B.first + i][B.second + j] = true;
                        dfs(make_pair(B.first + i, B.second + j), E, D + 1);//递归走下一步
                        vis[B.first + i][B.second + j] = false;//记得修复状态
                    }
                }
            }
        }
    }
}

int main() {
    int t, Case = 0;
    scanf("%d", &t);
    while(t --) {
        step = 0;
        Dist = 0x3f3f3f3f;
        scanf("%d %d %d", &n, &m, &k);
        for(int i = 0; i < n; i ++) scanf("%s", G[i]);
        for(int i = 0; i < n; i ++) {
            for(int j = 0; j < m; j ++) {
                if(G[i][j] == 'L') B = make_pair(i, j);
                if(G[i][j] == 'C') E = make_pair(i, j);
            }
        }
        ans = bfs(B.first, B.second);
        if(ans > k) ans = -1;
        printf("Case #%d: %d ", ++Case, ans);
        if(ans != -1) {
            memset(vis, false, sizeof vis);
            dfs(B, E, 0);
            printf("%d", step);
        }
        printf("
");
    }
    return 0;
}