2019寒假训练赛03解题报告

最新推荐文章于 2023-12-09 05:04:57 发布
原创 最新推荐文章于 2023-12-09 05:04:57 发布 · 346 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文精选了多个算法竞赛题目，包括括号匹配、序列划分、数字排列、任务排序等，详细解析了每道题目的解题思路，如模拟、二分、拓扑排序等，并提供了完整的代码实现。

这场比赛感觉。。。怎么说呢，WA、TLE、RE、MLE、PE、CE都有，做题十分钟，改BUG一小时（心情复杂）。

A - Replace To Make Regular Bracket Sequence CodeForces - 612C

题意：给你（)、[]、{}、<>四种括号，任意左括号之间或者右括号之间都可以变换。现在给你一个括号组成的字符串，问使其中括号之间完全配对最少需要变换几次，若无法完全配对则输出-1。

题解：模拟，因为里层的括号一定优先配对，所以最少变换次数也就是从最里层开始配，按部就班来就好。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
using namespace std;
stack<char>s;
int main()
{
    string x;
    while(cin>>x)
    {
        while(!s.empty()) s.pop();
        int n=x.length();
        int ans=0;
        for(int i=0;i<n;i++)
        {
            if(s.empty()) s.push(x[i]);
            else
            {
                if(x[i]==')'&&s.top()=='(')
                {
                    s.pop();
                }
                else if(x[i]==']'&&s.top()=='[')
                {
                    s.pop();
                }
                else if(x[i]=='}'&&s.top()=='{')
                {
                    s.pop();
                }
                else if(x[i]=='>'&&s.top()=='<')
                {
                    s.pop();
                }
                else if((x[i]==')'||x[i]==']'||x[i]=='}'||x[i]=='>')&&(s.top()=='('||s.top()=='{'||s.top()=='['||s.top()=='<'))
                {
                    ans++;
                    s.pop();
                }
                else
                {
                    s.push(x[i]);
                }
            }
        }
        if(s.empty())
        printf("%d\n",ans);
        else
        printf("Impossible\n");
    }
}

B - Pearls in a Row CodeForces - 620C
题意：给你一个序列，其中包含两个相同数字的子序列被称为好序列，问最多可以划分成几个好序列。

题解：模拟，这里两个相同的数字不一定是好序列的头和尾，因为所有好序列必须可以拼成最初的整个序列。这里我用map记录前面是否有相同数字，再用个数组存下好序列的尾，最后直接输出。

#include<iostream>
#include<cstdio>
#include<map>
using namespace std;
int a[1000000+10];
int ans[1000000+10];
map<int,bool>q;
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        q.clear();
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
        }
        int m=0;
        for(int i=1;i<=n;i++)
        {
            if(q[a[i]])
            {
                m++;
                ans[m]=i;
                q.clear();
            }
            else
            {
                q[a[i]]=1;
            }
        }
        if(!m)
        {
            printf("-1\n");
        }
        else
        {
            printf("%d\n",m);
            int last=1;
            for(int i=1;i<=m;i++)
            {
                if(i==m)
                {
                    printf("%d %d\n",last,n);//边界是最后一个数字
                }
                else
                {
                    printf("%d %d\n",last,ans[i]);
                    last=ans[i]+1;
                }
            }
        }
    }
    return 0;
}

C - 排列2 HDU - 1716

题意：现有四张卡片，用这四张卡片能排列出很多不同的4位数，要求按从小到大的顺序输出这些4位数。

题解：四位数首先前面不能有0，其次卡片可能有重复所以要去重，这里我用的dfs+set去重

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<set>
using namespace std;
char a[100];
char b[100];
bool vis[100];
set<string>s;
set<string>::iterator it;
void dfs(int x)
{
    if(x>4)
    {
        string now="";
        for(int i=1;i<=4;i++)
        {
            now+=b[i];
        }
        s.insert(now);
        return;
    }
    for(int i=1;i<=4;i++)
    {
        if(!vis[i])
        {
            vis[i]=1;
            b[x]=a[i];
            dfs(x+1);
            vis[i]=0;
        }
    }
}
int main()
{
    
    int t=0;
    while(cin>>a[1]>>a[2]>>a[3]>>a[4])
    {
        s.clear();
        if(a[1]=='0'&&a[2]=='0'&&a[3]=='0'&&a[4]=='0') break;
        t++;
        if(t!=1)
        {
            printf("\n");
        }
        sort(a+1,a+4+1);
        dfs(1);
        string now="0000";
        string last="0000";
        bool flag=0;
        for(it=s.begin();it!=s.end();it++)
        {
            now=*it;
            if(now[0]!='0')
            {
                if(now[0]!=last[0])
                {
                    if(!flag)
                    {
                        flag=1;
                    }
                    else
                    {
                        cout<<endl;
                    }
                }
                else
                {
                    cout<<" ";
                }
                cout<<now;
            }
            last=now;
        }
        printf("\n");
    }
    return 0;
}

D - Can you find it? HDU - 2141
题意：给你三个数字L、M、N接下来三行分别有L个、M个和N个数字，以下S组询问，问能否从三组数字中各选一个数字使和等于X，输出YES或者NO。

题解：二分，先将前两组数字两两相加，再在第三组数字中寻找能凑出X的数，每次询问复杂度L * M * logn。

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int a[505],b[505],c[505];
int es[250000+10];
int main()
{
    int n,m,l;
    int t=0;
    while(scanf("%d%d%d",&n,&m,&l)!=EOF)
    {
        t++;
        printf("Case %d:\n",t);
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        for(int i=1;i<=m;i++) scanf("%d",&b[i]);
        for(int i=1;i<=l;i++) scanf("%d",&c[i]);
        int r=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                r++;
                es[r]=a[i]+b[j];
            }
        }
        sort(es+1,es+r+1);
        int k;
        scanf("%d",&k);
        for(int i=1;i<=k;i++)
        {
            int x;
            scanf("%d",&x);
            bool flag=0;
            for(int j=1;j<=l;j++)
            {
                if(*lower_bound(es+1,es+r+1,x-c[j])==x-c[j])
                {
                    flag=1;
                    break;
                }
            }
            if(flag)
            {
                printf("YES\n");
            }
            else
            {
                printf("NO\n");
            }
        }
    }
}

E - Legal or Not [HDU - 3342]

题意：n个人，m组关系。A B表示A是B的上级，而且关系之间是相互传递的，比如A是B的上级，B是C的上级，那么A也是C的上级。但是如果A是B的上级，B是C的上级，而C又是A的上级，那么关系就矛盾了。现在问你关系是否矛盾。

题解：bfs找是否存在一个圈。

F - Ignatius and the Princess IV HDU - 1029

题意：给你N个数字，让你找出哪个数字出现在（n+1）/2次（该数字一定存在且唯一）。

题解：模拟，排序后直接找。

G - Can you solve this equation? HDU - 2199

给你一个数字Y，让你求8x^4 + 7x^3 + 2x^2 + 3x + 6 == Y的解，答案在0到100直接，没有则输出-1.。

题解：二分答案，注意精度问题。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
double check(double mid)
{
    return 8*mid*mid*mid*mid+7*mid*mid*mid+2*mid*mid+3*mid+6;
}
double del(double y)
{
    double l=0,r=100;
    while(r-l>1e-7)
    {
        double mid=(l+r)/2;
        if(check(mid)<=y)
        {
            l=mid;
        }
        else
        {
            r=mid;
        }
    }
    return r;
}
int main()
{
    int t;
    scanf("%d",&t);
    double y;
    while(t--)
    {
        scanf("%lf",&y);
        if(y<check(0)||y>check(100))
        {
            printf("No solution!\n");
        }
        else
        {
            printf("%.4lf\n",del(y));
        }
    }
    return 0;
}

H - Ordering Tasks UVA - 10305

题意：有一些任务，其中A B表示A任务排在B任务前面，求可能存在的任务顺序。

题解：拓扑排序

#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
using namespace std;
const int maxn=10000+10;
stack<int>s;
struct cc{
    int from,to;
}es[maxn];
int first[maxn],nxt[maxn];
bool vis[maxn];
bool pd[105][105];
int tot=0;
void build(int ff,int tt)
{
    es[++tot]=(cc){ff,tt};
    nxt[tot]=first[ff];
    first[ff]=tot;
}
int ru[maxn];
int ans[maxn];
int m;
int n,k;
void del()
{
    for(int i=1;i<=n;i++)
    {
        if(ru[i]==0&&!vis[i])
        {
            //puts("233");
            m++;
            ans[m]=i;
            s.push(i);
            vis[i]=1;
        }
    }
    while(!s.empty())
    {
        int u=s.top(); s.pop();
        for(int i=first[u];i;i=nxt[i])
        {
            int v=es[i].to;
            ru[v]--;
        }
    }

    if(m!=n)
    {
        del();
    }
}
int main()
{

    while(scanf("%d%d",&n,&k)!=EOF)
    {
        if(n==0&&k==0) break;
        tot=0;
        m=0;
        memset(nxt,0,sizeof(nxt));
        memset(vis,0,sizeof(vis));
        memset(pd,0,sizeof(pd));
        memset(first,0,sizeof(first));
        int x,y;
        for(int i=1;i<=k;i++)
        {
            scanf("%d%d",&x,&y);

            if(!pd[x][y])
            {
                ru[y]++;
                build(x,y);
            }

        }
        del();
        for(int i=1;i<n;i++)
        {
            cout<<ans[i]<<" ";
        }
        cout<<ans[n]<<endl;
    }
    return 0;
}

I - I Can Guess the Data Structure! UVA - 11995

题意：给你一些操作 1 X表示插入X元素，2 Y表示弹出元素Y，问你能完成这些操作的数据结构是queue、stack、priority_queue的哪一种，如果满足一个以上输出not sure，一个都不满足输出impossible。

题解：直接用三个数据结构模拟，有可能出现数据结构为空依然弹出的操作，注意防止RE。

#include<iostream>
#include<cstdio>
#include<queue>
#include<stack>
using namespace std;
queue<int>q1;
priority_queue<int>q2;
stack<int>q3;
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        while(!q1.empty()) q1.pop();
        while(!q2.empty()) q2.pop();
        while(!q3.empty()) q3.pop();
        int flag1=1,flag2=1,flag3=1;
        for(int i=1;i<=n;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            if(x==1)
            {
                q1.push(y);
                q2.push(y);
                q3.push(y);
            }
            else
            {
                if(q1.empty()||q1.front()!=y) flag1=0;
                if(q2.empty()||q2.top()!=y) flag2=0;
                if(q3.empty()||q3.top()!=y)  flag3=0;
                if(!q1.empty()) q1.pop();
                if(!q2.empty()) q2.pop();
                if(!q3.empty()) q3.pop();
            }
        }
        if(flag1+flag2+flag3==1)
        {
            if(flag1==1)
            {
                printf("queue\n");
            }
            if(flag2==1)
            {
                printf("priority queue\n");
            }
            if(flag3==1)
            {
                printf("stack\n");
            }
        }
        if(flag1+flag2+flag3>1)
        {
            printf("not sure\n");
        }
        if(flag1+flag2+flag3<1)
        {
            printf("impossible\n");
        }
    }
}

J - 4 Values whose Sum is 0 UVA - 1152

题意：n行，每行四个数字，从四列中个取一个数字，使其和为零，问可以找出几组这样的数字。

题解：二分，前两列一组，后两列一组，两两相加，二分查找和为零。

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
long long a[4005][5];
long long b[16000000+10];
int n;
int check(long long x)
{
    int l=1,r=n*n;
    while(l<=r)
    {
        int mid=(l+r)/2;
        if(b[mid]<x)
        {
            l=mid+1;
        }
        else if(b[mid]>x)
        {
            r=mid-1;
        }
        else if(b[mid]==x)
        {
            //cout<<b[mid]<<endl;
            int sum=1;
            for(int i=mid+1;i<=n*n;i++)
            {
                if(b[i]==x)
                {
                    sum++;
                }
                else
                {
                    break;
                }
            }
            for(int i=mid-1;i>=1;i--)
            {
                if(b[i]==x)
                {
                    sum++;
                }
                else
                {
                    break;
                }
            }
            return sum;
        }
    }
    return 0;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            scanf("%lld%lld%lld%lld",&a[i][1],&a[i][2],&a[i][3],&a[i][4]);
        }
        int m=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                m++;
                b[m]=a[i][1]+a[j][2];
            }
        }
        sort(b+1,b+m+1);
        int ans=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                long long now=a[i][3]+a[j][4];
                ans+=check(-now);
            }
        }
        printf("%d\n",ans);
        if(t!=0)
        {
            printf("\n");
        }
    }
    return 0;
}
2018年全国多校算法寒假训练营练习比赛（第二场）解题报告
Tsingcheng_liu的博客
02-02 596
2018年全国多校算法寒假训练营练习比赛（第二场） 题目源地址点此 A 吐泡泡 题目描述 小鱼儿吐泡泡，嘟嘟嘟冒出来。小鱼儿会吐出两种泡泡：大泡泡"O"，小泡泡"o"。 两个相邻的小泡泡会融成一个大泡泡,两个相邻的大泡泡会爆掉。 （是的你没看错，小气泡和大气泡不会产生任何变化的，原因我也不知道。） 例如:ooOOoooO经过一段时间以后会变成oO。 输入描述
2018年全国多校算法寒假训练营练习比赛（第五场）解题报告
Tsingcheng_liu的博客
02-26 1209
A-逆序数 https://www.nowcoder.com/acm/contest/77/A 题目描述 在一个排列中，如果一对数的前后位置与大小顺序相反，即前面的数大于后面的数，那么它们就称为一个逆序。一个排列中逆序的总数就称为这个排列的逆序数。比如一个序列为4 5 1 3 2， 那么这个序列的逆序数为7，逆序对分别为(4, 1), (4, 3), (4, 2), (5, 1),...
2019寒假训练赛05解题报告
muyu__的博客
02-12 224
水体欢乐赛O(∩_∩)O A - Easy Marks SPOJ - EASYMRKS 题意：你现在已经进行了n场考试并且知道了这n场考试的分数，现在你只剩下一场考试，问这场考试考多少分才能使得这n+1场考试的平均分为k。 题解：k*（n+1）-sum。 B - Candy I SPOJ - CANDY 题意：有n个小朋友，每个小朋友都有一些糖，现在要糖多的小朋友分给糖少的小朋友一些糖使...
2019寒假训练赛10解题报告
muyu__的博客
02-24 329
A - Bungee Jumping POJ - 2463 题意：有一个人要用一段绳子来跳楼，现在给你绳子的弹性系数、绳子的长度、楼的高度和人的质量，根据物理知识判断这个人是会摔死、还是安全着陆、还是被挂在半空（如果下落速度超过10m/s就会摔死、重力势能小于到达地面的弹性势能会被挂在半空中）。 题解：初中物理 重力势能：m * g * h 弹性势能：0.5 * k * x ^ 2 动能： 0.5...
2019寒假训练赛⑨解题报告
muyu__的博客
02-22 184
A - Minimum’s Revenge HDU - 5922 题意：有n个节点，编号为1~n，任意两个点之间的权值为两点编号的最小公倍数，问建最小生成树的最少花费为多少。 题解：最少花费即所有节点都与1号节点连边。 答案为n*(n+1)/2-1 C - Mr. Frog’s Problem HDU - 5924 题意：给出两个数A和B，让你找出C和D满足A/B+B/A&lt;=C/D+D/C，...
2019寒假训练赛06解题报告
muyu__的博客
02-14 263
咕咕咕
2019寒假训练赛08解题报告
muyu__的博客
02-18 219
B -Piggy-Bank HDU - 1114 题意：给你存钱罐的重量和装满钱的存钱罐的重量，再给你一些货币的重量和价值，问这个存钱罐装满钱后的最小价值是多少。 题解：完全背包问题。 #include&amp;amp;lt;iostream&amp;amp;gt; #include&amp;amp;lt;cstdio&amp;amp;gt; #include&amp;amp;lt;cstring&amp;amp;gt; using namespace std
2019寒假训练赛07解题报告
muyu__的博客
02-14 340
A - Candy division Gym - 101597C 题意：你有n块糖要分给三个小朋友，要求每个小朋友分到的数量可以被n整除，任意输出一种情况，如果不能则输出IMPOSSIBLE。 题解：由题意，得出n=n/x+n/y+n/z，即1=1/x+1/y+1/z，满足此公式只有3 3 3或者2 4 4的组合。所以只要判断n能否被3或者4整除即可。 #include&amp;amp;lt;iostream...
2019寒假训练赛04解题报告
muyu__的博客
02-10 403
米斯达镇楼 A - Frog Jumping CodeForces - 1077A 题意:有一只青蛙左右横跳，开始时青蛙在0位置，给你青蛙向右跳的距离a、向左跳的距离b和跳的步数k，问你青蛙最终的位置是多少。 题解：简单模拟，如果k为奇数就输出 （a-b） * k / 2 + a，如果是偶数就输出（a-b） *k / 2。 B - Disturbed People CodeForces - 1...
2019寒假训练赛01解题报告
muyu__的博客
01-24 328
起床发现8点50多了，想起来还有个比赛，吃了点饭开始准备，从9点打到11点A了6道题，看其他的题没啥思路就去干别的事了，最后一个小时回来专心做F题，思路没错但还是没做出来，其他三个都是考验脑力的，果然我太菜了。 A - The kth great number HDU-4006 题意：输入n和k，以下n行，每行第一个字符为I，后面将一个数字加入序列中，如果为Q，则输出当前序列第k大的数。 题解：用...
2019寒假训练赛02解题报告
muyu__的博客
01-30 221
比完后等到12点成功一发呼符艾蕾get o(￣▽￣)ブ（卡池刚开时70多石头都没出货… A - Partition CodeForces - 946A 题意：给你一堆数，将其分成两部分，两部分分别求和再相减，使得差最大，求最大差。 题解：非负数直接加，负数直接减，直接得到答案。 B - A/B HDU - 1576 题意：要求(A/B)%9973，但由于A很大，我们只给出n(n=A%9973)(...
蓝桥杯2019寒假算法题目集
5. 编程竞赛题目训练：通过在线OJ（Online Judge）平台或其它编程练习资源，不断刷题，提高编程能力和解题速度。 6. 软件开发流程：理解软件工程的概念，包括需求分析、系统设计、编码实现、测试和维护等环节。 7....
2023年湖南理工学院程序设计竞赛新生赛 解题报告(简化版) | 珂学家 | 思维场
每天多一点干货
12-09 1172
1、海康威视，测试，base杭州，慧影，工作时间早八点多到晚九点多，貌似是大小周，14k×142、苏小研，测试，base苏州，工作时长未知，据hr说18w+6～弹性工作制 不打卡上班！#华为# #腾讯# #阿里# #华为求职进展汇总# #华为保温# #晒一晒我的offer# #华子oc时间线# #华为开奖那些事# 告诉了我的薪资。
SCAU--ACM--team--2019级寒假训练Beginers Problem(一)合集---SCAU--LEO
Leo_zehualuo的博客
01-12 2680
题目简介： A - Hex-a-bonacci Given a code (not optimized), and necessary inputs, you have to find the output of the code for the inputs. The code is as follows: int a, b, c, ...
yubaolee_OpenAuthNet_25456_1764964690631.zip
12-07
yubaolee_OpenAuthNet_25456_1764964690631.zip
基于PID控制器和电流控制器的电池充电比较研究（Matlab代码实现）
12-07
基于PID控制器和电流控制器的电池充电比较研究（Matlab代码实现）内容概要：本文主要围绕《基于PID控制器和电流控制器的电池充电比较研究（Matlab代码实现）》展开，介绍了利用Matlab进行电池充电控制策略的仿真与比较研究。重点对比了PID控制器与电流控制器在电池充电过程中的性能表现，涵盖系统建模、控制算法设计、仿真分析及结果评估等内容，旨在为电池管理系统中的充电控制提供优化方案和技术参考。; 适合人群：具备一定自动控制理论基础和Matlab编程能力的电气工程、自动化、能源系统等相关专业的研究生、科研人员及工程技术人员。; 使用场景及目标：①用于电池管理系统中充电控制策略的设计与优化；②开展PID控制与电流控制在动态响应、稳定性、充电效率等方面的性能对比研究；③支持教学实验、科研仿真及实际工程项目中的控制器选型与验证。; 阅读建议：建议读者结合Matlab代码进行仿真实践，重点关注控制器参数设置、系统响应曲线分析及不同工况下的性能差异，同时可扩展至其他先进控制算法（如模糊控制、自适应控制）的对比研究，以深化对电池充电控制技术的理解与应用。
一个基于SpringBoot和MyBatis框架开发的用于高校或公共图书馆自习室资源智能化管理的Web应用程序系统_包含用户注册登录座位预约状态查询取消预约留言反馈及管理员对自习室.zip
12-07
一个基于SpringBoot和MyBatis框架开发的用于高校或公共图书馆自习室资源智能化管理的Web应用程序系统_包含用户注册登录座位预约状态查询取消预约留言反馈及管理员对自习室.zip
nats.swift-Swift资源
最新发布
12-08
Swift client for NATS, the cloud native messaging system.
ACM算法竞赛题解与优化技巧 练习题
12-07
ACM算法竞赛题解与优化技巧
2019寒假蓝桥杯编程题刷题精粹
综上所述，我们可以合理推测，这个压缩包 "2019寒假蓝桥杯刷题.zip" 可能包含了针对2019年寒假期间蓝桥杯竞赛的编程题目和练习材料。这些材料对于准备参加蓝桥杯的学生来说是很有价值的，通过大量练习这些题目，学生...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值