2024第一次测试题解

已于 2024-03-25 21:05:04 修改
阅读量473 收藏 9
点赞数 5
文章标签： 算法 数据结构 c++ 排序算法 动态规划
于 2024-03-25 21:02:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w20221013/article/details/137024210
版权

题组链接：

第一次测试 - Virtual Judge (vjudge.net)

一.A - Determinant

直接输出a*d-b*c

#include<stdio.h>


int main(){
    int a,b,c,d;
    scanf("%d%d%d%d",&a,&b,&c,&d);
    printf("%d\n",a*d-b*c);
    return 0;
}

二.B - Quizzes

#include<stdio.h>
int main()
{
    int n,x,i,j,ans=0;
    char k;
    scanf("%d%d",&n,&x);
    ans+=x;
    getchar();
    for(i=0;i<n;i++)
    {
        scanf("%c",&k);
        if(k=='o')
        {
            ans++;
        }
        else if(k=='x')
        {
            ans--;
            if(ans<0)
                ans=0;
        }
    }
    printf("%d\n",ans);
    return 0;
}

三.C - Super Ryuma

可以将题目中的三种情况，转化为两种：

1.斜着走
2.两坐标绝对值差之和小于等于3

两两匹配刚好种情况：

所以一共对应的走两步的情况：1+2, 1+1, 2+2；

其余的就是走三步的情况（所有两点都可以走三部来到达，斜着走两次再走一步）

#include<bits/stdc++.h>
using namespace std;

#define endl '\n'
#define ios ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr)

#define int long long
typedef pair<int,int> pr;
#define fr(i,l,r) for(int i=l;i<=r;i++)
#define fe(i,r,l) for(int i=r;i>=l;i--)
#define pb(x) push_back(x)
#define all(a) a.begin(),a.end()
#define fi first
#define se second

const int N = 1e6+10;
string YES="YES",Yes="Yes",yes="yes",NO="NO",No="No",no="no";
const int mod=998244353,inf=LONG_LONG_MAX;
int dx[]={0,0,-1,0,1},dy[]={0,-1,0,1,0};
int n,m,k;

int a[N];

void solve()
{
    int a, b, c, d;
    cin >> a >> b >> c >> d;
    c -= a, d -= b, a = 0, b = 0;
    int ans = 0;
    c = abs(c), d = abs(d);//转化到第一象限中
    if(c == 0 && d == 0){
        ans = 0;
    }
    else if (c == d || c + d <= 3){//1或者2
        ans = 1;
    }
    else if (abs(c - d) <= 3 || c + d <= 6){//1 + 2 , 2 + 2
        ans = 2;
    }
    else if (!((c & 1) ^ (d & 1))){//c和d奇偶同性,1 + 1
        ans = 2;
    }
    else{
        ans = 3;
    }
    cout << ans << endl;
}

signed main()
{
    ios;
    int t=1;
    // cin>>t;
    while(t--) solve();
    return 0;
}

四.D - One Time Swap

该题意转化后为：进行交换的两个字母要是不相等就ans++，否则则只保留第一次的情况；

所以采用map进行存储 i 之前的所有值字母个数，要是不相等就加上，要是相等就记上一次；

#include<bits/stdc++.h>
using namespace std;

#define endl '\n'
#define ios ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr)

#define int long long
typedef pair<int,int> pr;
#define fr(i,l,r) for(int i=l;i<=r;i++)
#define fe(i,r,l) for(int i=r;i>=l;i--)
#define pb(x) push_back(x)
#define all(a) a.begin(),a.end()
#define fi first
#define se second

const int N = 1e6+10;
string YES="YES",Yes="Yes",yes="yes",NO="NO",No="No",no="no";
const int mod=998244353,inf=LONG_LONG_MAX;
int dx[]={0,0,-1,0,1},dy[]={0,-1,0,1,0};
int n,m,k;

int a[N];

void solve()
{
    string s;
    cin>>s;
    n = s.size();
    s = " " + s;
    map<int,int>mp;
    int ans = 0;
    int f = 0;
    fr(i,1,n){
        fr(j,0,25){
            char c = j + 'a';
            if(s[i] == c){
                if(mp[s[i]-'a']&&f ==0){
                    f = 1;
                }
                else{
                    continue;
                }
            }
            ans += mp[j];
        }
        mp[s[i]-'a'] ++;
    }
    cout<<ans<<endl;
}

signed main()
{
    ios;
    int t=1;
    // cin>>t;
    while(t--) solve();
    return 0;
}

五.E - increment of coins（简单dp）

#include<stdio.h>
#include<string.h>
#include<vector>
#include<iostream>
using namespace std;
#define ll long long
char a;
double dp[101][101][101];
ll ans;
int main()
{
	int a, b, c, total;
	cin >> a >> b >> c;
	for (int i = 99; i >= a; i--)
		for (int j = 99; j >= b; j--)
			for (int k = 99; k >= c; k--) {
				double sum = i + j + k;
				dp[i][j][k] = ((double)i / sum) * (dp[i + 1][j][k] + 1) + ((double)j / sum) * (dp[i][j + 1][k] + 1) + ((double)k / sum ) * (dp[i][j][k + 1] + 1);
			}
			printf("%.9lf",dp[a][b][c]);
	return 0;
}

六.F - Third Avenue（简单搜索）

用一个数组存储所有字母的传送门，然后遇到字母就遍历该数组进行传送即可，当然也可以不进行传送

#include<stdio.h>
int n,m,x,y,X,Y;
bool vis[2001][2001];
char a[2001][2001];
int b[100],dx[4]= {0,0,-1,1},dy[4]= {1,-1,0,0};
struct node
{
    int x,y;
} chuang[30][10000];

struct Node
{
    int x,y,t;
} p[4000001];

int bfs()
{
    int r=1,l=-1,i,j;
    vis[x][y]=1;
    p[0].x=x,p[0].y=y;
    while(++l<r)
    {
        if(a[p[l].x][p[l].y]=='G')
        {
            return p[l].t;
        }
        for(i=0; i<4; i++)
        {
            int xx=p[l].x+dx[i],yy=p[l].y+dy[i],tt=p[l].t+1;
            if(xx<0||xx>=n||yy<0||yy>=m) continue;
            if(vis[xx][yy]==0&&a[xx][yy]!='#')
            {
                //printf("%d,%d,%d\n",xx,yy,tt);
                vis[xx][yy]=1;
                p[r].x=xx,p[r].y=yy,p[r++].t=tt;
            }
        }
        if(a[p[l].x][p[l].y]>='a'&&a[p[l].x][p[l].y]<='z')
        {
            int xx=p[l].x,yy=p[l].y,tt=p[l].t+1;

            char k=a[xx][yy]-'a';
            for(i=0; i<b[k]; i++)
            {
                //printf("%d,%d,%d\n",xx,yy,tt);
                if(xx==chuang[k][i].x&&yy==chuang[k][i].y||vis[chuang[k][i].x][chuang[k][i].y]!=0) continue;

                //printf(" %d,%d,%d\n",xx,yy,tt);
                xx=chuang[k][i].x,yy=chuang[k][i].y;
                vis[xx][yy]=1;
                //printf(" %d,%d,%d\n",xx,yy,tt);
                p[r].x=xx,p[r].y=yy,p[r].t=tt;
                r++;
            }
        }
    }
    return -1;
}

int main()
{
    int i,j;
    scanf("%d%d",&n,&m);
    for(i=0; i<n; i++)
    {
        getchar();
        for(j=0; j<m; j++)
        {
            scanf("%c",&a[i][j]);
            if(a[i][j]=='S')
            {
                x=i,y=j;
            }
            else if(a[i][j]=='G')
            {
                X=i,Y=j;
            }
            else if(a[i][j]>='a'&&a[i][j]<='z')
            {
                chuang[a[i][j]-'a'][b[a[i][j]-'a']].x=i;
                chuang[a[i][j]-'a'][b[a[i][j]-'a']++].y=j;
            }
        }
    }
    //for(i=0;i<n;i++)
    //printf("%s\n",a[i]);
    printf("%d\n",bfs());
    return 0;
}

七.G - Programming Contest（01背包变式）

其实考察了01背包的部分性质；只是由于给的数据过大，无法采用普通数组进行转化，我代码是直接采用map数字来进行实现的；

由于数据N=40，在最坏的情况下，所有组合的数都不会重合的话，那么将会产生2^40 - 1次方个数，空间和时间都会超限；

所以我们可以采取将数据一分2，那么将会得到两个2 ^ 20 - 1的数组a和b，然后从中知道和最大并且小于T的值，遍历其中一个数组a，在那个数组中找到比T - a[i]小于等于中最大的数；

我的代码：

#include<bits/stdc++.h>
using namespace std;

#define endl '\n'
#define ios ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr)

#define int long long
typedef pair<int,int> pr;
#define fr(i,l,r) for(int i=l;i<=r;i++)
#define fe(i,r,l) for(int i=r;i>=l;i--)
#define pb(x) push_back(x)
#define all(a) a.begin(),a.end()
#define fi first
#define se second

const int N = 1e6+10;
string YES="YES",Yes="Yes",yes="yes",NO="NO",No="No",no="no";
const int mod=998244353,inf=LONG_LONG_MAX;
int dx[]={0,0,-1,0,1},dy[]={0,-1,0,1,0};
int n,m,k;

int a[N];

void solve()
{
    cin >> n >> k;
    map<int, int> mp1,mp2;
    fr(i,1,n) cin>>a[i];
    mp1[0] = 1,mp2[0] = 1;
    fr(i,1,n/2){
        vector<int>vt;
        for(auto [x,y] : mp1){
            if(x + a[i] <= k){
                vt.push_back(x + a[i]);
            }
        }
        for(auto x : vt){
            mp1[x] = 1;
        }
    }
    fr(i,n/2 + 1,n){
        vector<int>vt;
        for(auto [x,y] : mp2){
            if(x + a[i] <= k){
                vt.push_back(x + a[i]);
            }
        }
        for(auto x : vt){
            mp2[x] = 1;
        }
    }
    int ans = 0;
    for(auto [x,y] : mp1){
        auto [xx,yy] = *prev(mp2.upper_bound(k - x));
        ans = max(ans, xx + x);
    }
    cout << ans << endl;
}

signed main()
{
    ios;
    int t=1;
    // cin>>t;
    while(t--) solve();
    return 0;
}

 题解中代码：

#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
void chmax(ll& a, ll b){ if(a < b) a = b; }

int main(){
    ll N, T;
    cin >> N >> T;
    vector<ll> A(N);
    for(ll& a : A) cin >> a;
    vector<ll> B{0}, C{0};
    for(ll a : A){
        for(ll i = B.size(); i--; ) B.push_back(B[i] + a);
        swap(B, C);
    }
    sort(B.begin(), B.end(), greater());
    
    ll ans = 0;
    for(ll x : C){
        if(x > T) continue;
        x += *lower_bound(B.begin(), B.end(), T - x, greater());
        chmax(ans, x);
    }
    cout << ans << endl;
}

建议多去使用c++容器以及函数

不会英语的机器人
关注
2023年测试题目
ping_hong的博客
05-27 233
根据标准体型的公式，奶牛的标准体重应该是：174-105=69 公斤，所以奶牛超重 73 - 69 = 4。发现网站好多训练题啊，伙伴们在上面做题可热闹了，真是非常适合小学水平的奶牛训练！假设奶牛的身高不会变化。但是奶牛也发现了网站的一个问题，那就是伙伴们做题的结果没有排名。过计算，发现奶牛的体重太重了，于是为奶牛制定跑步计划，奶牛每减重。挑选奶牛的原则是：挑选编号是连续的一段奶牛，这一段奶牛的颜色必须。一个整数，表示为了达到标准体型，奶牛总共需要跑步的次数。行，每行一个整数，每行对应农夫的一个问题。
2020.03.08测试题4
zzu957的博客
03-18 1143
题目 LED屏的液晶显示在工业上有着十分重要的应用， 现在W老师给你个任务，给你一个仅包含数字的字符串，输出其液晶显示效果。本题中，我们利用’-‘和’|’表示液晶数字中的笔画，可以看出每个数字对应的液晶显示格式都严格占据5行3列的空间（空格也需要输出），例如数字8： 因此，数字0-9可以表示为： 输入格式: 一行，仅包含数字的字符串（字符串长度不超过200） 输出格式: 该数字对应的液晶显示效...
2024牛客算法冬令营第一次比赛全题解
2203_75327677的博客
02-04 1219
本篇博客是2024牛客算法冬令营第一次比赛全题解
美团2024春招第二场笔试 - 题解
weixin_63448617的博客
03-17 2661
计算所点菜品的总价，然后减去满减和红包。
2024牛客算法冬令营第二次比赛部分题解
2203_75327677的博客
02-07 1482
2024牛客算法冬令营第二次比赛部分题解
python-leetcode面试题解之第136题只出现一次的数字-题解.zip
05-07
这道题是LeetCode中的第136题，名为“只出现一次的数字”（Single Number）。下面我们将详细探讨这个问题，以及如何用Python来解决它。 题目描述： 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个...
第三次练习赛题解2
08-03
同时，对于需要即时输出的题目，要注意本地测试时可能出现的输入输出交织情况，这是正常现象。 接下来是求区间交集和并集的问题。题目中提到，我们需要维护两个区间，一个代表交集，另一个代表并集。每读入一个新的...
蓝桥杯第一次训练赛题解
Qq1739206233的博客
01-13 1046
蓝桥杯第一次训练赛题解 A+B for Input-Output Practice (I) 题目描述 Description 计算A+B 程序设计任务中常常会包含多组输入输出。 Input 第一行一个正整数n，代表输入数据的组数。 以下n行，每行两个正整数 Output 计算这n组数的和，每组答案占一行 Sample Input 2 1 5 10 20 Sample Output 6 30 代码 #include <cstdio> using namespace std; int main()
电力系统继电保护测试考核复习题解第四章.doc
12-10
4. **通道维护与检验**：高频通道设备需要定期进行全面检验，一般每3~5年进行一次。运行中的高频保护在进行信号交换试验时，不应断开跳闸连接片，以保持保护功能的连续性。在某些情况下，如母差跳闸停信，是为了防止...
电力系统继电保护测试考核复习题解-第五章.doc
12-04
3. 双母线接线的母差保护采用电压闭锁是为了防止二次回路切换问题导致的误动，而一个半断路器接线的母差保护不采用电压闭锁是因为不存在这个问题。 4. 母联电流相位比较式完全电流差动保护在倒闸操作中需要断开母联...
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1108
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
深度优先算法，广度优先算法，hill climbing，贪心搜索，A*算法，启发式搜索算法是什么，比起一般搜索法算法有什么区别
mimo_mimo的博客
09-10 1150
A算法通过维护一个优先队列（通常是最小堆），并根据启发式函数（如g(n) + h(n)，其中g(n)是从起点到当前点的实际距离，h(n)是从当前点到目标点的估计距离）来评估节点的优先级。它从图的某个顶点V0开始，依次访问V0的各个未被访问过的邻接点，然后从这些邻接点出发，再依次访问它们的未被访问过的邻接点，直到图中所有已被访问过的顶点的邻接点都被访问到。它从当前的节点开始，和周围的邻居节点的值进行比较，如果当前节点不是最大的，就用最高的邻居节点来替换当前节点，从而实现向“山峰”的高处攀爬的目的。
算法基础-约数
qq_65186476的博客
09-11 266
试除法求约数、约数个数、约数之和、最大公约数
C语言程序设计-练习篇
最新发布
2402_85207276的博客
09-14 688
·三角形的判断 ·使用指针打印数组内容 ·字符串逆序 ·计算求和 ·打印水仙花数
Codeforces Round 969 (Div. 2) C. Dora and C++ （裴蜀定理）
2302_79440616的博客
09-10 432
取模，这样就能够得到所有数的最简形式（可以当成是让所有数尽可能消去。所以在这时候我们就可以让输入的所有数都去对。那么在取模之后我们现在排序，得到的极差就是。可以想到使用同样是需要给出两个定值的。由于这里给出了a和b两个数，我们。的判断，因为不排除有这种情况存在。，那么这里我们还要进行一次。，这样我们会取到最优解。
leecode100题-双指针-三数之和
kian9one的博客
09-10 413
固定i，即可转换为寻找满足 nums[l]+nums[r]=−nums[i] 的三元组，因为不能包含重复的三元组，以下两个三元组只能取一个，而后我们再考虑其是否满足 nums[l]+nums[r]=−nums[i]。先对数组排序，设一非递减的数组示例和初始三指针位置及名字如下所示。不同的三元组是 [-1,0,1] 和 [-1,-1,2]。移动指针的时候，需要规避连续的重复元素。答案中不可以包含重复的三元组。，判断是否存在三元组。
拥塞控制算法为何失效，网络为何难以测量？
Netfilter
09-14 1511
所以你知道实验室仿真的宇宙第一算法为啥拉了吧，也就不用再问为什么部署了 bbr 却还不如 cubic 了吧，如果你还希望研发一个精准的，普适的端到端算法，我劝你改行去卖皮鞋，至少还有很多经理市场。这和上一篇说的测量系统容量的方法并不矛盾，因为对于网络传输系统而言，系统是动态变化的，在流量部署到系统上并开始传输时，没有全局视图，就不能指望全局公平，留下的 gap 是固有的，没法靠算法弥补。，超级经典的一篇论文，我推荐过不止一次，因此我本文不谈异构问题，说点别的，比如拓扑。对，就是要砸，因为我不干了。
算法里面的离散化
admin_zbn的博客
09-11 877
离散化的主要目的是将连续的值或大范围的值映射到一个有限的集合中，以便进行高效的存储和处理。这通常通过对连续的数据进行排序、分组、或者映射来实现。离散化的关键是将原始的、可能是连续或无限范围的数据，转化为有限且可处理的编号或索引。这样不仅优化了存储空间，也提高了数据处理的效率。二、在算法中，“映射”是指将一个集合中的每个元素通过某种规则或函数转换为另一个集合中的元素的过程。这一概念广泛应用于数据处理、函数设计和数据结构中。
18068 选择排序
huang1xiao1sheng的博客
09-11 384
输入10个整数，编写一个实现对数组进行选择排序的函数 #include int sort(int a[], int n) { int i,j,k,tmp; for(i=0;i
CSP-J第一轮模拟赛题解：判断题解析与参赛须知
"CSP-J第一轮学军信友队开放模拟赛的题解，涵盖了CSP-J/S的相关规则和知识点" CSP-J第一轮比赛是针对计算机科学基础能力的认证，旨在评估参赛者的算法和编程技能。这个级别的认证相较于专业级别（CSP-S）更为简单，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值