SDUT 2021 summer team contest 3rd(for 20) A E J L

最新推荐文章于 2024-07-10 16:47:58 发布
最新推荐文章于 2024-07-10 16:47:58 发布
阅读量136 收藏
点赞数 2
文章标签： 算法 数据结构 二分法 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kirie_/article/details/119480595
版权

组队赛补题 3rd A E J L

本次比赛使用文件格式的输入输出，需添加：
freopen(“file_name.in”,“r”,stdin);
freopen(“file_name.out”, “w”, stdout);

比赛链接

A. Alex Origami Squares

大意：一个长方形里面裁剪出三个正方形，使其中面积（边长）最大

/*
 * @Description: 
 * @Author: Kirie
 * @LastEditTime: 2021-08-06 21:05:35
 */
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define bug cout << "BUG HERE\n"
#define debug(x) cout << #x << " = " << x << endl
#define ll long long
typedef pair<int, int> PII;

double a, b;

void swap() {
    double t = a;
    a = b;
    b = t;
}

double Min(double x, double y) {
    return x < y ? x : y;
}

int main()
{
    ios::sync_with_stdio(false);
    freopen("alex.in", "r", stdin);
    freopen("alex.out", "w", stdout);
    cin >> a >> b;
    if(a > b) swap(); // 保证a < b
    double r = Min(a, b / 3.0);
	if(r < a / 2.0) r = a / 2.0;
    cout << fixed << setprecision(3) << r << endl;
    return 0;
}

E - Easy Arithmetic

大意：给出一个计算式，通过添加加号或者减号使其计算结果最大。计算前后都符合规则(1)没有前导0(2)没有连续符号(3)最后一位是数字

/*
* @Description: 
* @Author: Kirie
* @LastEditTime: 2021-08-06 21:13:54
*/
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define bug cout << "BUG HERE\n"
#define debug(x) cout << #x << " = " << x << endl
#define ll long long
typedef pair<int, int> PII;

int main()
{
    ios::sync_with_stdio(false);
    freopen("easy.in","r",stdin);
    freopen("easy.out", "w", stdout);
    string a;
    cin>>a;
    for(int i=0;i<a.size();i++) {
        if(a[i]=='-'){ // 如果减号
            cout<<a[i]<<a[i+1]; // 减号和后面这个数不会变
            if(a[i+2]>='0'&&a[i+2]<='9') { // 如果后面还有数字
                int j=i+2; // 从这个数字开始
                while(j<a.size()&&a[j]=='0') { // 输出"+"号和数字，直到结尾 或者 不是0了
                    cout<<"+"<<a[j];
                    j++;
                }
                if(j!=a.size()&&a[j]>='0'&&a[j]<='9') { // 不是0的部分一次性输出
                    cout<<"+";
                }
                i=j-1; // 指针读到遍历到的位置
            } else {
                i=i+1;
            }
        } else { // 除了减号直接输出
            cout<<a[i];
        }
    }
    return 0;
}

J - Journey to the “The World’s Start”

大意：

  1. 输入n和t。1~n个车站共n个车站，某人要从第一个到最后一个车站，t为最大花费时间。
  2. 我们认为每经过一站花费1分钟，所以最大时长t要减去n-1分钟。
  3. 有n-1种票，票上有两种属性：一次最远能坐的距离(i) & 票价(p[i])。在第二行依次给出：p[1],p[2]…p[n-1]。
  4. 中间每个中转车站需要花费d[i]的时间重新进站。在第三行依次给出：d[2],d[3]…d[n-1]。第一站和最后一站不需要考虑该时间。
  5. 题目所求在不超过最大时间到达最后一站的条件下所需最小票价。
  6. 注意：票是一次性付钱，每次选择一种票，即可无限次乘车，每次在票允许的范围内。

思路：二分查找 + 单调队列优化

  1. (优化查找) 如果范围r的票可以完成任务，范围(r+1,n-1)的票也可以。所以如果有一个范围大的价格更低，那么在它之前的价格更高的都没有意义(或者说第i张票的价格p[i] = min(p[i] ~ p[n-1]))
  2. (优化查找) 二分的是票，如果满足条件，向左找看是否能找到满足的，直到找到满足题意的范围最小的票(经过上面的优化，已经保证对每张票来说价格是合理的)
  3. (优化方案) 对每一个车站，它都等于它之前的滑动窗口的最小值(队头.首元素)+该车站重新进站的时间(d[i])
/*
 * @Description: 
 * @Author: Kirie
 * @LastEditTime: 2021-08-07 09:14:35
 */
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define bug cout << "BUG HERE\n"
#define debug(x) cout << #x << " = " << x << endl
#define ll long long
typedef pair<int, int> PII;

const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
const int N = 5e4 + 7;

int p[N], d[N], n;
int ans, l, r;
ll t;

void init() {
    ans = 0;
    l = 1;
    r = n - 1;
}

bool solve(int x) { // x是某张票的序号，也是它能走的范围
    // 单调队列优化。队头代表出发站，first元素代表其花费时间，second元素代表站点序号
    deque < pair <ll, int> > q;
    // 插入第一个站点：从用时为0的第1站出发
    q.push_back(make_pair(0, 1));
    rep(i,2,n) {// 从第二站到最后一站
        // (1)单调队列清除不符合区间要求的元素，该元素已经滑出窗口，队首出队
        while(!q.empty() && q.front().second < i - x) q.pop_front();

        // (2)错误条件：到达某一站已经超过最大时长
        if(q.front().first > t - (n - 1)) return false;

        // (3)清除比要插入元素优先级小的元素以维护单调队列
        // 如果该元素小于队尾元素，说明队头元素无效
        while(!q.empty() && q.back().first >= q.front().first + d[i] ) q.pop_back();

        // (4)无论是否弹出队尾，都会将现有元素压入队尾
        q.push_back(make_pair(q.front().first + d[i], i));
    }
    return true;
}

int main()
{
    ios::sync_with_stdio(false);
    freopen("journey.in", "r", stdin);
    freopen("journey.out", "w", stdout);
    cin >> n >> t;
    rep(i,1,n-1) cin >> p[i];
    rep(i,2,n-1) cin >> d[i];
    // 如果范围r的票可以完成任务，范围(r+1,n-1)的票也可以
    // 所以如果有一个范围大的价格更低，那么在它之前的价格更高的都没有意义
    for(int i = n - 2;i > 0;i --) p[i] = min(p[i], p[i + 1]);
    //令p[i]为后缀区间中的最小值，方便下一步二分
    init();//初始化
    while (r >= l) { // 二分查找
        int mid = (l + r) >> 1;
        if (solve(mid)) {
            ans = p[mid];
            r = mid - 1;
        } else l = mid + 1;
    }
    cout << ans << endl;
    return 0;
}

L. Lucky Chances

大意：一个网格内每个区域一个数字，我们称某数字“赢得一个方向”是指该数字比该方向的任意数字都要大，注意边界时直接赢得该方向。
思路：暴力（时间复杂度O(n * n * (n+n)) : 对每一个点，找它的行和列）

/*
 * @Description: 
 * @Author: Kirie
 * @LastEditTime: 2021-08-05 13:18:18
 */
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <queue>
#include <stack>
#include <iomanip>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define bug cout << "BUG HERE\n"
#define debug(x) cout << #x << " = " << x << endl
#define ll long long
typedef pair<int, int> PII;

const int N = 1e2 + 7;

int mp[N][N];
int flag [5];
int cnt;
int t;

void init(){
    mem(flag, 1);
    cnt = 1;
}

int main()
{
	freopen("lucky.in","r",stdin);
	freopen("lucky.out", "w", stdout);
	ios::sync_with_stdio(false);
    int c,r;
    cin >> r >> c ;
    rep(i, 1, r)
        rep(j, 1, c) 
            cin >> mp[i][j];
    int ans = 0;
    rep(i, 1, r) {
        rep(j, 1, c) {//对每一个点
            init();
            t = mp[i][j];
            rep(k, 1, i-1) { //上 cnt = 1
                if(mp[k][j] >= t) {
                    flag[cnt] = 0;
                    break;
                }
            }
            //if(flag[cnt]) debug(cnt);
            cnt ++;
            rep(k, 1, j-1) { //左 cnt = 2
                if(mp[i][k] >= t) {
                    flag[cnt] = 0;
                    break;
                }
            }
            //if(flag[cnt]) debug(cnt);
            cnt ++;
            rep(k, i+1, r) { // 下 cnt = 3
                if(mp[k][j] >= t) {
                    flag[cnt] = 0;
                    break;
                }
            }
            //if(flag[cnt]) debug(cnt);
            cnt ++;
            rep(k, j+1, c) { //右 cnt = 4
                if(mp[i][k] >= t) {
                    flag[cnt] = 0;
                    break;
                }
            }
            //if(flag[cnt]) debug(cnt);
            rep(i, 1, 4) {
                if(flag[i]){
                    ans ++;
                }
            }
        }
    }
    cout << ans << endl;   
    return 0;
}

/*
 *
 ?                        _oo0oo_
 !                       o8888888o
 ?                       88" . "88
 !                       (| = = |)
 ?                       0\  √ /0
 !                     ___/`---'\___
 ?                   .' \\|     |// '.
 !                  / \\|||  :  |||// \
 ?                 / _||||| -:- |||||- \
 !                |   | \\\  - /// |   |
 ?                | \_|  ''\---/''  |_/ |
 !                \  .-\__  '-'  ___/-. /
 ?              ___'. .'  /--.--\  `. .'___
 !           ."" '<  `.___\_<★>_/___.' >' "".
 ?          | | :  `- \`.;`\ _ /`;.`/ - ` : | |
 !          \  \ `_.   \_ __\ /__ _/   .-` /  /
 ?      =====`-.____`.___ \_____/___.-`___.-'=====
 !                        `=---='
 ? 
 * 
//                                                      
 * 
 todo   佛祖保佑 = 永不宕机 && 永无BUG && 不掉头发 = true
 */
Kirie_
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Sdut-Ver5.2.0
10-26
sdut客sdut客户端
stepbystep:SDUTACM训练计划
06-10
"SDUTACM训练计划"是一个面向初学者到高级选手的逐步学习路径，旨在帮助学生提升在算法竞赛（如ACM/ICPC）中的技能。这个训练计划可能包含一系列的练习题、教程和代码示例，以HTML为主要的展示形式。HTML（HyperText...
SDUT 2022 Spring Team Contest(for 21) - 3
Bookerbobo的博客
04-06 861
C - Cardboard Containerhttps://vjudge.net/problem/Kattis-cardboardcontainer c题是给定n个 棱长为1的立方体，来摆成一大的长方体（包括正方体），求所有可能摆成的长方体的表面积最小值。 暴力枚举其中两条边，计算出第三条边（因为最小单位是1，所以必须整除） #include <iostream> #include<algorithm> #include<cstring> #include&lt
SDUT 2021 Spring Individual Contest(for 20) - 10（补题+部分题解）
weixin_54699118的博客
03-28 2362
Third-Party Software Pavel is developing a game. To do that, he needs functions available in a third-party library too famous to be called. It is known that the function i first appeared in version ai and existed until version bi, and starting from the ver
SDUT 2021 Spring Individual Contest(for 20) - 12 补题
再看_的博客
04-03 3130
H题Genta Game 题意：首先给定n和m，n为字符串长度，接着给定字符串，m次操作，问m次操作中有多少次会出现回文串 思路：因为给的数据范围是1e5,所以时间复杂度应该控制在O（nlogn）以内。首先先把给定的字符串预处理一下，查询字符串中有多少个不回文的部分，之后的每一次操作中，操作结束时判断不回文的部分是否为0，如果是，结果加一。 #include<bits/stdc++.h> using namespace std; const int N=1e5+10; char a[N]; in
SDUT 2020 Summer Team Contest 2nd(for 19) BDJ题解
Here_SDUT的博客
07-30 985
Clone from Regional Olympiad of Student St Petersburg, October 24, 2015 题目pdf版本 前言 主要整理了觉得有意思的题以及赛后补的题，VJ的训练赛难度确实没有多校赛高，下午的体验总体比自闭多校赛好很多了。 这次的题要用文件形式输出，前前后后因为这个整队wa了有四五发（离谱），以后细节还是要多注意。另外还有一个就是英文题面读题慢，读不懂，读错题的问题还是蛮严重的，英语阅读能力还有待加强。组队赛和单枪匹马感觉还是很不一样的，有人一起讨.
SDUT 2021 Spring Team Contest--- 20 （Gym 103107）题解
qq_45830025的博客
05-29 1062
Gym 103107DD - Doin' TimeF - FunctionH - Hack DSU!J - JOJO's FactoryK - Keep Eating D - Doin’ Time 题目链接 答案 #include <iostream> #include <algorithm> #include<bits/stdc++.h> #define ll long long #define mem(a,b) memset(a,b,sizeof a) #define
SDUT 2021 Spring Individual Contest(for 20) - 3补题
再看_的博客
03-07 2359
题意： 给三个长度为10的二进制字符串，对其中一个字符串里面的数字你可以随意调动，求字符串进行异或处理，求可以得到的最大值 1 ^ 1 ^ 1=1,1 ^ 0 ^ 0=1.只有这两种能得到1。因为要求取得的值尽可能的大一些，所以我们尽可能的将1排到前面，因为我们要得到更多的1。所以我们先用1 0 0组合，如果不能用1 0 0 再看能否用1 1 1，若都不能，则该位置是0。 #include<bits/stdc++.h> using namespace std; struct node { .
SDUT 2021 Spring Individual Contest(for 20) - 11 补题
再看_的博客
03-31 2204
B题Bonuses on a Line 思路：四种情况：只往左走，只往右走，先向右走再向左走，先向左走再向右走。枚举每种情况的最大值，还要判断0处是否有，如果有最大值+1，如果没有，输出最大值 #include<bits/stdc++.h> using namespace std; const int N=2e5+10; typedef long long ll; ll pos[N]; ll neg[N]; ll p1=0; ll p2=0; int main() { ios::sync
SDUT 2022 Summer Individual Contest - 2(for 21)
yuanxinya_的博客
07-05 199
SDUT 2022 Summer Individual Contest - 2(for 21)补题
SDUT 2021 Spring Team Contest--- 24（Gym 103145） 题解
qq_45830025的博客
06-19 952
Gym 103145E - Easy Math ProblemI - TakeawayJ - TransformK - CityM - Master of Shuangpin E - Easy Math Problem 题目链接 答案 #include <iostream> #include <algorithm> #include<bits/stdc++.h> #define ll long long #define mem(a,b) memset(a,b,sizeof
SDUT 2021 Spring Team Contest--- 16(Gym 103081) 题解
qq_45830025的博客
05-15 959
Gym 103081A - GratitudeC - Safe DistanceD - JoggingE - CakesK - Unique Activities A - Gratitude 题目链接 答案： #include <math.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <algorithm> #include <deque>
解题报告代码 sdut2107
07-29
解题报告， sdut 2107 自己写的代码、 欢迎指正 、、、、、、、
SDUT数据库系统练习
07-09
Your team has been assigned to develop a database system for your neighborhood health club (gym). It is typically privately owned and the “players” involved are the owner(s), the administrators, the...
第4章-13 求误差小于输入值的e的近似值 (20分)python
12-23
自然常数e可以用级数1+1/1!+1/2!+⋯+1/n!来近似计算。ei代表前i项求和。输入误差范围error,当 ei+1-ei表示e的近似值满足误差范围。 输入格式: 在一行输入误差范围。 输出格式: 在一行输出e的近似值（保留6位小数）。...
36. Adam 算法详解
最新发布
qq_41238579的博客
07-10 646
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 299
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
D1.排序
2302_79232710的博客
07-07 181
快速排序和归并排序
每周算法：无向图的双连通分量
少儿编程乔老师
07-06 1235
通过Tarjan算法求无向连通图的双连通分量，计算至少添加多少条边可以将原图变为一个双连通分量。
sdut-入门-1 A+B for Input-Output Practice(I)
10-15
好的，这是一道简单的输入输出练习题，题目描述如下： 给定两个整数 A 和 B，输出 A+B 的值。 输入格式： 共一行，包括两个整数 A 和 B。 输出格式： 共一行，包括一个整数，表示 A+B 的值。 样例输入： 3 4 样例输出： 7 你可以使用以下代码来实现： ```python a, b = map(int, input().split()) print(a + b) ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值