match1(双周赛)

最新推荐文章于 2022-12-16 20:52:29 发布

多萝西的猫

最新推荐文章于 2022-12-16 20:52:29 发布

阅读量213

点赞数 1

分类专栏： NEUQ 文章标签：算法 c++ 图论

本文链接：https://blog.csdn.net/qq_31054483/article/details/128008912

版权

NEUQ 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

Match1

第一次双周赛

第一次双周赛

1-1 Lily

题目描述

题面描述：
百合花（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

思路分析

二分思路（雾）：
显然，比赛的这周只学了二分这一个算法，并且看到了最大限度更是~~确定了二分的算法~~ 。于是乎开始去想如何判断每一次的二分，然后没想到简便方法，自闭了五分钟。接着去敲完了T2高精度后重新读了一边题目，居然是个纯模拟！
~~喜提T1用时倒数~~

纯模拟（真）：
对于每一个格子，只要其前面、后面、自己本身都不是L，即可满足题意。

参考代码：

#include<bits/stdc++.h>
using namespace std;
int n;
string s;

int main(){
    cin>>n>>s;
    for (int i=0; i<n; i++){
        if (s[i-1]!='L'&&s[i+1]!='L'&&s[i]!='L')
            s[i]='C';
    }
    cout<<s;
    //system("pause");
    return 0;   
}

1-2 a * b

题目描述

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

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

输出格式:
输出一行，表示a∗b

输入样例:
在这里给出一组输入。例如：
1BF52
1D4B42

输出样例:
在这里给出相应的输出。例如：
332FCA5924

代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

思路分析

高精度板子题。
注意：
1.高精度乘法中，第i位与第j位的乘积在第i+j-1位。
2.输出时前导零的清除。

参考代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e3+5;
int a[maxn],b[maxn];
int ans[maxn*maxn+10];
void stringtoint(char s1[],char s2[]){
    a[0]=strlen(s1);
    b[0]=strlen(s2);
    for (int i=a[0],j=0; i>0; i--,j++){
        if (s1[j]=='A')
            a[i]=10;
        else if (s1[j]=='B')
            a[i]=11;
        else if (s1[j]=='C')
            a[i]=12;
        else if (s1[j]=='D')
            a[i]=13;
        else if (s1[j]=='E')
            a[i]=14;
        else if (s1[j]=='F')
            a[i]=15;   
        else      
            a[i]=s1[j]-'0';
    }
    for (int i=b[0],j=0; i>0; i--,j++){
        if (s2[j]=='A')
            b[i]=10;
        else if (s2[j]=='B')
            b[i]=11;
        else if(s2[j]=='C')
            b[i]=12;
        else if(s2[j]=='D')
            b[i]=13;
        else if(s2[j]=='E')
            b[i]=14;
        else if(s2[j]=='F')
            b[i]=15;   
        else    
        b[i]=s2[j]-'0';
    }
    return;
}
void multi(){
    for (int i=1; i<=a[0]; i++)
        for (int j=1; j<=b[0]; j++){
            ans[i+j-1]=ans[i+j-1]+a[i]*b[j];
            ans[i+j]=ans[i+j]+ans[i+j-1]/16;
            ans[i+j-1]=ans[i+j-1]%16;
        }
    ans[0]=a[0]+b[0];
}
void print_ans(){
    while(ans[ans[0]]==0) 
        ans[0]--;
    while (ans[0]>0){
        if (ans[ans[0]]==10)
            cout<<"A";
        else if (ans[ans[0]]==11)
            cout<<"B";
        else if (ans[ans[0]]==12)
            cout<<"C";
        else if (ans[ans[0]]==13)
            cout<<"D";
        else if (ans[ans[0]]==14)
            cout<<"E";
        else if (ans[ans[0]]==15)
            cout<<"F";
        else
            cout<<ans[ans[0]];
        ans[0]--;
    }
}
int main(){
    char s1[maxn],s2[maxn];
    cin>>s1>>s2;
    stringtoint(s1,s2);
    multi();
    print_ans();
    //system("pause");
    return 0;   
}

1-3 山头狙击战

题目描述

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

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

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

样例输入
6 100
236
120
120
120
120
120

样例输出
25

代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

思路分析

显然的二分算法。
需要特别处理的是每一次二分的判断：在每击倒一个敌人后，判断下一个敌人是否在攻击范围内，如果不在攻击范围内，时间需要加上下一个敌人进入攻击范围所用的时间。

参考代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+5;
int n,m;
int a[maxn];
int doit(int k){
    int bg=0;
    if (a[1]>m){
        bg=a[1]-m;
    }
    bg+=k;
    int num=2;
    while (num<=n){
        if (bg>a[num]){
            return 0;
        }
        if (a[num]-bg<=m)
            bg+=k,num++;
        else {
            bg+=a[num]-bg-m+k,num++;
        }
    }
    return 1;
}
int main(){
    cin>>n>>m;
    for (int i=1; i<=n; i++){
        cin>>a[i];
    }
    sort(a+1,a+1+n);
    int l=0,r=a[n];
    while (l<=r){
        int mid=l+r>>1;
        if (doit(mid)){
            l=mid+1;
        }
        else {
            r=mid-1;
        }
        //cout<<"l:"<<l<<" "<<"r:"<<r<<endl;
    }
    cout<<(l+r)/2;
   // system("pause");
    return 0;   
}

注意：
二分的输出结果，最好用(l+r)/2，用l与r可能会出现一定偏差。

1-4 Reversing Linked List

题目描述

题面描述：
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 (≤10
5
) 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

思路分析

整体上双向链表。
因为存在前导零，可以先string读入每一个地址，再stoi转成整数下标方便处理。
因为以-1结尾，所以这里所构造的假地址（即永远是首位的假地址）设置为-2。
因为存在翻转，所以可以记录下两个值：froe为每一次翻转（从+1到+k）时+1左边的地址，lase为+k右边的地址，要注意到froe与lase的不断更新。
a数组的下标即为该地址的下标，b数组存储每次需要翻转的k个数。

参考代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+5;
struct node{
    int l,r,dat;
}a[maxn];
int b[maxn];

int main(){
    string s;
    int n,k;
    cin>>s>>n>>k;
    int fir;
    fir=stoi(s);
    a[-2].r=fir;
    for (int i=1; i<=n; i++){
        int add;
        cin>>s; 
        add=stoi(s);
        cin>>a[add].dat>>s;
        a[add].r=stoi(s);
    }

    fir=-2;
    for (int i=1; i<=n; i++){
        a[a[fir].r].l=fir;
        fir=a[fir].r;
    }

    fir=-2;
    int num=0;
    int froe=-2,lase=0;
    while (fir!=-1){
        if (num==k){

            for (int i=k; i>=1; i--){
                a[b[i]].r=b[i-1];
                a[b[i-1]].l=b[i];
            }
            a[b[k]].l=froe;
            a[b[1]].r=lase;
            a[froe].r=b[k];
            a[lase].l=b[1];
            froe=b[1];
            num=0;
            fir=b[1];
        }
        else {
            fir=a[fir].r;
            b[++num]=fir;
            lase=a[fir].r;
        }
    }

    fir=-2;

    for (int i=1; ; i++){
        fir=a[fir].r;
        if (a[fir].r==-1){
        printf("%05d %d %d\n",fir,a[fir].dat,a[fir].r);
        break;
        }
        else {
            printf("%05d %d %05d\n",fir,a[fir].dat,a[fir].r);
        }
    }
    //system("pause");
    return 0;   
}

彩蛋（写题心路）：

~~（英文题面，助力四级考试）~~
反复阅读题面后，终于弄懂了大致意思（5-digit nonnegative integer 译为 5位非负整数）
比赛时写到这里，还有七十分钟，心中一想这题稳了。
~~结果剩下的时间卡死在了这题~~

赛后反思：

1.对于双向链表还是不够熟练
2.没有仔细审题，一开始直接用int读取了地址，没有注意前导零的存在
3.debug还是不够熟练

1-5 一元三次方程

题目描述

题面描述：
给定一个形如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⁻⁶

输入样例:
在这里给出一组输入。例如：
1
1.000000 -5.000000 -4.000000 20.000000 -10.000000 10.000000

输出样例:
在这里给出相应的输出。例如：
-2.000000 2.000000 5.000000

思路分析

洛谷有一道类似的题目LGP1024，但那道题的解较为特殊，在连续的长度为1的区间上，最多只有1个解。这道题更普适化。
对于未知区域的解，可以通过求导化为二次式，找到每一个单调区间，也就找到了每一个解的区间。在每个区间上二分时，可以通过判断左端点和该点符号相同与否，进行区间的不断逼近。

参考代码：

#include<bits/stdc++.h>
using namespace std;
double a,b,c,d,p,q;
int T;
double multi(double k){
    return (a*k*k*k+b*k*k+c*k+d);
}

double midsearch(double l,double r){
    double lans=multi(l),rans=multi(r);
    if (lans==0){
        return l;
    }
    while (r-l>=1e-6){
        double mid=(l+r)/2;
        double midans=multi(mid);
        if (midans==0){
            return mid;
        }
        
        if (midans*lans>0){
                l=mid;
            }
        else {
                r=mid;
            }
    }
    return (l+r)/2;
}
int main(){
    cin>>T;
    while (T--){
        scanf("%lf%lf%lf%lf%lf%lf",&a,&b,&c,&d,&p,&q);
        double a2,b2,c2;
        a2=3*a;
        b2=2*b;
        c2=c;
        double l1,r1;
        l1=(-1*(b2)-sqrt(b2*b2-4*a2*c2))/(2*a2);
        r1=(-1*(b2)+sqrt(b2*b2-4*a2*c2))/(2*a2);
        if (l1>r1){
            swap(l1,r1);
        }
        printf("%.6lf %.6lf %.6lf\n",midsearch(p,l1),midsearch(l1,r1),midsearch(r1,q));
        //cout<<midsearch(p,l1)<<" "<<midsearch(l1,r1)<<" "<<midsearch(r1,q)<<;
    }
    //system("pause");
    return 0;
}