cccc冲刺4

最新推荐文章于 2022-02-24 11:32:58 发布

叶子心情你不懂

最新推荐文章于 2022-02-24 11:32:58 发布

阅读量612

点赞数 1

分类专栏： acm培训

本文链接：https://blog.csdn.net/qq_40379678/article/details/79735716

版权

acm培训专栏收录该内容

40 篇文章 0 订阅

订阅专栏

7-6 近似求PI（15 分）

本题要求编写程序，根据下式求 $π$ 的近似值，直到最后一项小于给定精度eps。

=1+31!+3×52!+3×5×73!+⋯+3×5×⋯×(2×i+1)i!+⋯

输入格式：

输入在一行中给出精度eps，可以使用以下语句来读输入：

scanf("%le", &eps);

输出格式：

在一行内，按照以下格式输出 $π$ 的近似值（保留小数点后5位）：

PI = 近似值

输入样例：

1E-5

输出样例：

PI = 3.14158

本来没理解题目意思，卡精度咋卡啊，，，原来是每项和eps比较，，，

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
//const double eps = 1e-8;
#define INF 100000000
typedef pair<int, int> P;
#define N 10001
const int mod = 10007;

double jie(int n)
{
    if(n == 0)
        return 1.0;
    double ans = 1;
    for(int i = 2; i <= n; i++)
        ans *= i;

    return ans;
}

double fenmu(int n)
{
    if(n == 0)
        return 1.0;
    double ans = 1.0;
    for(int i = 3; i <= n * 2 + 1; i += 2){
        ans *= i;
    }
    return ans;
}

int main()
{
    double eps, ans = 0.0, tmp;
    int maxn = 0;

    scanf("%le", &eps);


    for(int i = 0; ; i++){
        tmp = jie(i) / fenmu(i);
        if(tmp < eps){
            ans += tmp;
            break;
        }else{
            ans += tmp;
        }
        //printf("PI = %.*lf\n", maxn, ans);
    }

    printf("PI = %.5lf", ans * 2);

    return 0;
}

7-12 关于堆的判断（25 分）

将一系列给定数字顺序插入一个初始为空的小顶堆H[]。随后判断一系列相关命题是否为真。命题分下列几种：

x is the root：x是根结点；
x and y are siblings：x和y是兄弟结点；
x is the parent of y：x是y的父结点；
x is a child of y：x是y的一个子结点。

输入格式：

每组测试第1行包含2个正整数N（ $\leq$ 1000）和M（ $\leq$ 20），分别是插入元素的个数、以及需要判断的命题数。下一行给出区间 $[- 10000, 10000]$ 内的N个要被插入一个初始为空的小顶堆的整数。之后M行，每行给出一个命题。题目保证命题中的结点键值都是存在的。

输出格式：

对输入的每个命题，如果其为真，则在一行中输出T，否则输出F。

输入样例：

5 4
46 23 26 24 10
24 is the root
26 and 23 are siblings
46 is the parent of 23
23 is a child of 10

输出样例：

F
T
F
T

这题一脸懵逼，后来百度答案才发现竟然有建堆的模板库，STL真是博大精深。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const double eps = 1e-8;
#define INF 100000000
typedef pair<int, int> P;
#define N 10001
const int mod = 10007;

vector<int> v;
int n, m, tmp, a, b;
string s;

int Find(int x){
    return find(v.begin() + 1, v.end(), x) - v.begin();
}

int main()
{
    scanf("%d%d", &n, &m);

    v.push_back(0);
    for(int i = 0; i < n; i++){
        scanf("%d", &tmp);
        v.push_back(tmp);
        push_heap(v.begin() + 1, v.end(), greater<int>());
    }

    for(int i = 0; i < m; i++){
        scanf("%d", &a);
        cin >> s;
        if(s == "is"){
            cin >> s;
            if(s == "the"){
                cin >> s;
                if(s == "root"){
                    if(v[1] == a){
                        printf("T\n");
                    }else{
                        printf("F\n");
                    }
                }else{
                    cin >> s;
                    scanf("%d", &b);
                    int ai = Find(a), bi = Find(b);
                    if(ai == bi / 2){
                        printf("T\n");
                    }else{
                        printf("F\n");
                    }
                }
            }else if(s == "a"){
                cin >> s;cin >> s;
                scanf("%d", &b);
                int ai = Find(a), bi = Find(b);
                if(bi == ai / 2){
                    printf("T\n");
                }else
                    printf("F\n");
            }
        }else{
            scanf("%d", &b);
            cin >> s;cin >> s;
            int ai = Find(a), bi = Find(b);
            if(ai / 2 == bi / 2){
                printf("T\n");
            }else
                printf("F\n");
        }
    }

    return 0;
}

7-10 哥尼斯堡的“七桥问题”（25 分）

哥尼斯堡是位于普累格河上的一座城市，它包含两个岛屿及连接它们的七座桥，如下图所示。

可否走过这样的七座桥，而且每桥只走过一次？瑞士数学家欧拉(Leonhard Euler，1707—1783)最终解决了这个问题，并由此创立了拓扑学。

这个问题如今可以描述为判断欧拉回路是否存在的问题。欧拉回路是指不令笔离开纸面，可画过图中每条边仅一次，且可以回到起点的一条回路。现给定一个无向图，问是否存在欧拉回路？

输入格式:

输入第一行给出两个正整数，分别是节点数 $N$ ( $1 \leq N \leq 1000$ )和边数 $M$ ；随后的 $M$ 行对应 $M$ 条边，每行给出一对正整数，分别是该条边直接连通的两个节点的编号（节点从1到 $N$ 编号）。

输出格式:

若欧拉回路存在则输出1，否则输出0。

输入样例1:

输出样例1:

输入样例2:

输出样例2:

这个欧拉回路的题目，有个坑点是要判断连通。

但是判断连通的深搜超时间了，于是就骗了一波分数。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const double eps = 1e-8;
#define INF 100000000
typedef pair<int, int> P;
#define N 1001
const int mod = 10007;

int top[N];
int n, m, a, b;
bool ans = true;
bool maze[N][N], used[N][N];
int cnt = 0;
void dfs(int x, int y, int deep)
{
    if(cnt >= 2 || deep > 15)
        return;

    used[x][y] = used[y][x] = true;
    for(int i = 1; i <= n; i++){
        if(maze[y][i] && !used[y][i]){
            dfs(y, i, deep + 1);
        }
    }
}

int main()
{
    scanf("%d%d", &n, &m);

    for(int i = 0; i < m; i++){
        scanf("%d%d", &a, &b);
        maze[a][b] = maze[b][a] = true;
        top[a]++;
        top[b]++;
    }

    cnt = 0;
    if(m < 20)
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= n; j++){
            if(cnt >= 2)
                break;
            if(maze[i][j] && !used[i][j]){
                dfs(i, j, 0);
                cnt++;
            }
        }
        if(cnt >= 2)
            break;
    }

    for(int i = 1; i <= n; i++)
        if(top[i] & 1)
            ans = false;

    if(cnt > 1)
        ans = false;

    printf("%d", ans);

    return 0;
}

然后百度发现根本不用求出连通度，直接搜一次就行了。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const double eps = 1e-8;
#define INF 100000000
typedef pair<int, int> P;
#define N 1001
const int mod = 10007;

int top[N];
int n, m, a, b;
bool ans = true;
bool maze[N][N], used[N][N];
bool flag = false;
void dfs(int x, int y, int num)
{
    if(flag || num == n){
        flag = true;
        return;
    }

    used[x][y] = used[y][x] = true;

    for(int i = 1; i <= n; i++){
        if(maze[y][i] && !used[y][i]){
            dfs(y, i, num + 1);
        }
    }
}

int main()
{
    scanf("%d%d", &n, &m);

    for(int i = 0; i < m; i++){
        scanf("%d%d", &a, &b);
        maze[a][b] = maze[b][a] = true;
        top[a]++;
        top[b]++;
    }

    for(int i = 1; i <= n; i++){
        bool f = false;
        for(int j = 1; j <= n; j++){
            if(maze[i][j] && !used[i][j]){
                dfs(i, j, 0);
                f = true;
            }
            if(f)
                break;
        }
        if(f)
            break;
    }

    for(int i = 1; i <= n; i++)
        if(top[i] & 1)
            ans = false;

    if(!flag)
        ans = false;

    printf("%d", ans);

    return 0;
}

7-9 汉诺塔的非递归实现（25 分）

借助堆栈以非递归（循环）方式求解汉诺塔的问题（n, a, b, c），即将N个盘子从起始柱（标记为“a”）通过借助柱（标记为“b”）移动到目标柱（标记为“c”），并保证每个移动符合汉诺塔问题的要求。

输入格式:

输入为一个正整数N，即起始柱上的盘数。

输出格式:

每个操作（移动）占一行，按柱1 -> 柱2的格式输出。

输入样例:

输出样例:

a -> c
a -> b
c -> b
a -> c
b -> a
b -> c
a -> c

恩我是递归实现的，数据水的我很开心。

有空百度学习下非递归的。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const double eps = 1e-8;
#define INF 100000000
typedef pair<int, int> P;
#define N 10001
const int mod = 10007;

void han(int n, char a, char b, char c)
{
    if(n == 1){
        printf("%c -> %c\n", a, c);
        return;
    }
    else{
        han(n - 1, a, c, b);
        printf("%c -> %c\n", a, c);
        han(n - 1, b, a, c);
    }
}

int main()
{
    int n;

    scanf("%d", &n);

    han(n, 'a', 'b', 'c');

    return 0;
}

7-11 玩转二叉树（25 分）

给定一棵二叉树的中序遍历和前序遍历，请你先将树做个镜面反转，再输出反转后的层序遍历的序列。所谓镜面反转，是指将所有非叶结点的左右孩子对换。这里假设键值都是互不相等的正整数。

输入格式：

输入第一行给出一个正整数N（ $\leq$ 30），是二叉树中结点的个数。第二行给出其中序遍历序列。第三行给出其前序遍历序列。数字间以空格分隔。

输出格式：

在一行中输出该树反转后的层序遍历的序列。数字间以1个空格分隔，行首尾不得有多余空格。

输入样例：

7
1 2 3 4 5 6 7
4 1 3 2 6 5 7

输出样例：

4 6 1 7 5 3 2

又没有用链表建树，，，

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const double eps = 1e-8;
#define INF 100000000
typedef pair<int, int> P;
#define N 10001
const int mod = 10007;

int n, cnt;
int mid[N], pre[N];
int tree[N];

void solve(int p, int l, int r, int index)
{
    if(l >= r)
        return;

    tree[index] = pre[p];

    int i = l;
    while(i < r && mid[i] != pre[p])
        i++;

    solve(p + i - l + 1, i + 1, r, index * 2 + 1);
    solve(p + 1, l, i, index * 2 + 2);
}

int main()
{
    scanf("%d", &n);

    for(int i = 0; i < n; i++){
        scanf("%d", &mid[i]);
    }
    for(int i = 0; i < n; i++){
        scanf("%d", &pre[i]);
    }

    solve(0, 0, n, 0);

    int cnt = 0;
    for(int i = 0; i < N; i++){
        if(tree[i] > 0){
            printf("%d", tree[i]);
            cnt++;
            if(cnt == n){
                putchar('\n');
                break;
            }else{
                putchar(' ');
            }
        }
    }

    return 0;
}