高精度，实数二分法，链表例题详解

你想太多了！

已于 2022-11-15 21:19:04 修改

阅读量136

点赞数 1

文章标签：算法 c++ 图论链表

于 2022-11-15 01:05:42 首次发布

本文链接：https://blog.csdn.net/qq_71829924/article/details/127858458

版权

7-1 Lily

分数 300

全屏浏览题目切换布局

作者 neuqAcmClub

单位东北大学秦皇岛分校

百合花（Lily）是一种美丽的花。她通常一年只开一次花，所以如果你看到百合花盛开，它会非常珍贵。然而，她对猫有剧毒，所以你必须注意让好奇的猫远离可爱的百合花。

你有n个网格的土壤土地排成一行，从1到n，其中一些是百合花。我们不想伤害百合，也不想伤害猫。你可以在网格上放一些猫粮，但对于任何有猫粮的网格i，在区域[i−1,i+1]不得含有百合花。你喜欢猫和百合，所以你想最大限度地增加有猫粮的格子。

设计满足上述要求的计划。

输入格式:

有一个整数n（1≤n≤1000）表示网格的数量。

第二行包含仅由“L”和“.”组成的字符串R，表示有和没有百合花的格子。

输出格式:

输出包含一行，字符串R′仅由“L”、“”组成和“C”，其中“C”表示在满足上述要求的同时分配给R中空网格的猫粮。

输入样例:

在这里给出一组输入。例如：

5
..L..

输出样例:

在这里给出相应的输出。例如：

C.L.C

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB
第一题还是比较友好

#include <iostream>
using namespace std;
char d[1005];
int main()
{
    int n;
    cin >> n;
    char c[n];

    for (int i = 0; i < n; i++)
    {
        cin >> c[i];
    }
    for (int i = 0; i < n; i++)
    {
        if (i == 0)
        {
            if (c[i] != 'L' && c[i + 1] != 'L')
            {
                d[i] = 'C';//判断的第一个点
            }
        }
        else if (i == n - 1)
        {
            if (c[i] != 'L' && c[i - 1] != 'L')
            {
                d[i] = 'C';//判断中间的点
            }
        }
        else
        {
            if (c[i] != 'L' && c[i - 1] != 'L' && c[i + 1] != 'L')
            {
                d[i] = 'C';//判断最末的点
            }
        }
    }
    for (int i = 0; i < n; i++)
    {
        if (d[i] == 'C')
            cout << d[i];
        else
            cout << c[i];
    }
}

7-2 a * b

分数 300

全屏浏览题目切换布局

作者 neuqAcmClub

单位东北大学秦皇岛分校

给出两个不超过1000位的十六进制数a,b。
求a∗b的值

输入格式:

输入共两行，两个十六进制的数

输出格式:

输出一行，表示a∗b

输入样例:

在这里给出一组输入。例如：

1BF52
1D4B42

输出样例:

在这里给出相应的输出。例如：

332FCA5924

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

#include <algorithm>
#include <iostream>
#include <cstring>
using namespace std;
const int maxn = 1e6;
int c[maxn], cc[maxn];
int aa[maxn], bb[maxn];
char convert(int x)
{
    if (x < 10)
        return x + '0';
    else
        return x + 55;
}
int main()
{
    string a;
    string b;
    cin >> a;
    cin >> b;
    reverse(a.begin(), a.end());//反转字符串，便于从末尾计算
    reverse(b.begin(), b.end());
    int la = a.length();
    int lb = b.length();
    int ls = la + lb;
    for (int i = 0; i < la; i++)
    {
        if (a[i] >= '0' && a[i] <= '9')//如果是0~9，就转为0~9整型
            aa[i] = a[i] - '0';
        else
            aa[i] = a[i] - '0' - 7;//否则，把字母转成数字，如a->10
        ;
    }
    for (int i = 0; i < lb; i++)//同上
    {
        if (b[i] >= '0' && b[i] <= '9')
            bb[i] = b[i] - '0';
        else
            bb[i] = b[i] - '0' - 7;
    }
    for (int i = 0; i < la; i++)//数字相乘，先不进位
    {
        for (int j = 0; j < lb; j++)
        {
            c[i + j] += aa[i] * bb[j];
        }
    }
    int t = 1;
    for (int i = 0; i < ls; i++)//数字进位
    {
        if (c[i] > 15)
        {
            cc[i] += c[i];
            t = cc[i];
            if (cc[i] > 15)
            {
                cc[i] = t % 16;
                cc[i + 1] += t / 16;
            }
        }
        else if (c[i] <= 15 && c[i] >= 0)
        {
            cc[i] += c[i];
            if (cc[i] > 15)
            {
                t = cc[i];
                cc[i] %= 16;
                cc[i + 1] += t / 16;
            }
        }
    }
    int tail = ls - 1;
    while (cc[tail] == 0 && tail > 0)//利用栈舍去前导0
        tail--;
    for (int i = tail; i >= 0; i--)
    {
        cout << convert(cc[i]);
    }
}

7-3 山头狙击战

分数 300

全屏浏览题目切换布局

作者 neuqAcmClub

单位东北大学秦皇岛分校

题目描述

小明为了掩护大部队，单枪匹马同敌人周旋，后来被敌人包围在某山头……等等，为什么怎么听怎么像狼牙山五壮士！不过不用着急，这次小明携带了足够的弹药，完全可以将涌上来的敌人一个一个干掉。小明是个神枪手，只要他的枪膛中有子弹，他就能将在他射程m（用从敌人位置到山头的直线距离算）以内的一个敌人瞬间射杀。但如果在射程内没有敌人，出于节约子弹考虑和面子问题，小明会等待敌人靠近然后射击。
正当小明为自己的强大而自我膨胀时，他忽然发现了一个致命的失误：他携带的枪是单发枪，每射出一发子弹都必须花k秒钟的时间装子弹。而凶残的敌人才不会花时间等你换子弹呢。他们始终在以1m/s的速度接近山头。而如果在一个敌人到达山头时小明无法将他击毙，那么我们可怜的小明就将牺牲在敌人的刺刀下。现在小明用心灵感应向你发出求助：要保住自己的性命并且歼灭所有敌人，小明最多只能用多少时间给枪装上一发子弹？
说明：假设一开始小明的枪中就有一发子弹，并且一旦确定一个装弹时间，小明始终会用这个时间完成子弹的装卸。希望你能帮助小明脱离险境。

输入格式

每组输入数据，第一行有两个整数n和m，（2≤n≤100,000; 1≤m≤10,000,000）n代表敌人个数，m代表小明的射程。
接下来有n行，每行一个整数mi,（1≤mi≤10,000,000），代表每个敌人一开始相对山头的距离（单位为米）。

输出格式

每组输出数据仅有一个整数，代表小明的换弹时间（单位为秒）。

样例输入

样例输出

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

#include <iostream>
#include <algorithm>
using namespace std;
long long n, m;
long long mi[100005];
long long answ[100005];
int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i++)
    {
        cin >> mi[i];
    }
    sort(mi, mi + n); //将敌人距离从小到大排序
    if (mi[0] > m)    //最小距离大于射程，则之后距离减去差值
    {
        for (int i = 1; i < n; i++)
        {
            mi[i] = mi[i] - (mi[0] - m);
            answ[i] = mi[i] / i; //求出小明对每一个敌人的最小换弹时间
        }
    }
    else //最小距离不大于射程，只需求出小明对每一个敌人的最小换弹时间，则无需额外操作
    {
        for (int i = 1; i < n; i++)
        {
            answ[i] = mi[i] / i;
        }
    }
    sort(answ, answ + n); //从小到大排出每个敌人的最小换弹时间
    cout << answ[1];      // answ[0]一定等于0，故输出answ[1]
}

7-4 Reversing Linked List

分数 300

全屏浏览题目切换布局

作者陈越

单位浙江大学

Given a constant K and a singly linked list L, you are supposed to reverse the links of every K elements on L. For example, given L being 1→2→3→4→5→6, if K=3, then you must output 3→2→1→6→5→4; if K=4, you must output 4→3→2→1→5→6.

Input Specification:

Each input file contains one test case. For each case, the first line contains the address of the first node, a positive N (≤105) which is the total number of nodes, and a positive K (≤N) which is the length of the sublist to be reversed. The address of a node is a 5-digit nonnegative integer, and NULL is represented by -1.

Then N lines follow, each describes a node in the format:

Address Data Next

where Address is the position of the node, Data is an integer, and Next is the position of the next node.

Output Specification:

For each case, output the resulting ordered linked list. Each node occupies a line, and is printed in the same format as in the input.

Sample Input:

00100 6 4
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218

Sample Output:

00000 4 33218
33218 3 12309
12309 2 00100
00100 1 99999
99999 5 68237
68237 6 -1

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

读不懂？我来翻译一下

给定一个常数K和单向链表L，您应该反转每个链接K元素上L.例如，给定L为 1→2→3→4→5→6，如果K=3，则必须输出 3→2→1→6→5→4;如果K=4，则必须输出 4→3→2→1→5→6。

如果K=2,则必须输出2→1→4→3→6→5。

输入规范：

每个输入文件包含一个测试用例。对于每种情况，第一行包含第一个节点的地址，一个正数N (≤105）是节点总数，为正数K (≤N）是要反转的子列表的长度。节点的地址是 5 位非负整数，NULL 表示为 -1。

然后N接下来是几行，每行描述一个节点，格式如下：

Address Data Next

其中节点的位置是一个整数，是下一个节点的位置。Address``Data``Next

输出规格：

对于每种情况，输出生成的有序链表。每个节点占用一行，并以与输入相同的格式打印。

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int first, k, n, temp;
    cin >> first >> n >> k;
    int data[100005], next[100005], list[100005];
    for (int i = 0; i < n; i++)
    {
        cin >> temp;
        cin >> data[temp] >> next[temp]; //[]中的temp可理解为地址
    }
    int sum = 0;        //计数器，同时去掉多余的节点
    while (first != -1) //直到链表最末尾结束循环
    {
        list[sum++] = first; //一链连一链
        first = next[first];
        //可理解为list[i]=next[list[i-1]]
    }
    for (int i = 0; i < (sum - sum % k); i += k) //直接调用reverse反转数组当前节点，对应的data不会改变
    {
        reverse(list + i, list + i + k);
    }
    for (int i = 0; i < sum - 1; i++)
    {
        printf("%05d %d %05d\n", list[i], data[list[i]], list[i + 1]);
    }
    printf("%05d %d -1", list[sum - 1], data[list[sum - 1]]);
}

7-4 Reversing Linked List

分数 300

全屏浏览题目切换布局

作者 neuqAcmClub

单位东北大学秦皇岛分校

给定一个形如ax³+bx²+cx+d=0的一元三次方程。

已知该方程有三个不同的实数根（根与根之差的绝对值≥10⁻⁶），且根范围均在[p,q]之间，你需要解出这个方程的三个根。

输入格式:

第一行一个整数T(1≤T≤1000)，表示有T组数据

接下来T行，每行6个实数，分别表示a,b,c,d,p,q

数据保证：−10²≤p,q≤10²，且对于∀x∈[p,q],−10⁶≤f(x)≤10⁶

输出格式:

输出三个实数，表示方程的三个解。

你的答案可以以任意顺序输出。

一个答案被认为是正确的，当且仅当其与标准答案的绝对误差不超过10−6

输入样例:

在这里给出一组输入。例如：

1
1.000000 -5.000000 -4.000000 20.000000 -10.000000 10.000000

输出样例:

在这里给出相应的输出。例如：

-2.000000 2.000000 5.000000

提示1：

样例所给方程的图像如下：

提示2：

对于方程：ax²+bx+c=0(Δ=b²−4ac≥0)，可以求出它的两个根分别为：x1,x2

代码长度限制

16 KB

时间限制

500 ms

内存限制

128 MB

#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
double a, b, c, d, p, q;
double x1, x2;
double value(double x) //求函数值
{
    return a * pow(x, 3) + b * x * x + c * x + d;
}
double find(double x, double y) //里用二分法寻根
{
    double mid = (x + y) / 2;
    while (fabs(value(mid)) > eps) //笔者归纳能力不太好，分了6中情况，看样子复杂，其实画个图就一目了然
    {
        if (value(mid) > 0 && value(x) < 0)
        {
            if (value((mid + x) / 2) < 0)
            {
                x = (x + mid) / 2;
            }
        }
        else if (value(mid) < 0 && value(x) > 0)
        {
            if (value((mid + x) / 2) > 0)
            {
                x = (x + mid) / 2;
            }
        }
        if (value(mid) > 0 && value(y) < 0)
        {
            if (value((mid + y) / 2) < 0)
                y = (mid + y) / 2;
        }
        else if (value(mid) < 0 && value(y) > 0)
        {
            if (value((mid + y) / 2) > 0)
                y = (mid + y) / 2;
        }
        if (value(mid) * value(x) > 0)
        {
            mid = (mid + y) / 2;
        }
        if (value(mid) * value(y) > 0)
        {
            mid = (mid + x) / 2;
        }
    }
    return mid;
}
int main()
{
    int T;
    cin >> T;
    for (int i = 0; i < T; i++)
    {
        cin >> a >> b >> c >> d >> p >> q;
        x1 = (-b - sqrt(b * b - 3 * a * c)) / (3 * a); //求根公式，自己可以推导
        x2 = (-b + sqrt(b * b - 3 * a * c)) / (3 * a);
        if (x1 > x2)
            swap(x1, x2);
        printf("%.6lf %.6lf %.6lf\n", find(p, x1), find(x1, x2), find(x2, q));
    }
}