ABC374

已于 2024-10-10 08:55:24 修改
阅读量472 收藏 14
点赞数 21
分类专栏： Atcoder 文章标签： 算法 c++ 开发语言
于 2024-10-09 11:32:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acrux1985/article/details/142781830
版权

A

字符串是否有san后缀

B

两个字符串第一个不同的位置

C

将一个数组分为两部分，求不同分法中更大那一部分和的最小值。

n<=20,位运算枚举

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <stack>
#include <unordered_map>
#include <algorithm>

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

int n;
int a[20];


int main(){
    //freopen("in.txt", "r", stdin);
    cin >> n;
    for (int i = 0; i < n; ++i) cin >> a[i];
    ll s = 0;
    for (int i = 0; i < n; ++i) s += a[i];
    ll mn = 1ll << 60;
    for (int i = 0; i < (1 << n); ++i) {
        ll t = 0;
        for (int j = 0; j < n; ++j) {
            if (i & (1 << j)) t += a[j];
        }
        mn = min(mn, max(t, s - t));
    }
    printf("%lld\n", mn);
    return 0;
}

D

给定一些线段，机器从(0,0)点开始移动，画线段时的速度为S，不画时的移动速度为T
求机器画完所有线段的最短时间

next_permutation遍历排列，注意每条线段中有两个顺序

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <stack>
#include <unordered_map>
#include <algorithm>

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

struct Line {
    double x0, y0, x1, y1;
}a[6];
int n;
double s, t;
int p[6] = {};
double ans;

double get(int mask) {
    double x = 0, y = 0;
    double ret = 0;
    for (int i = 0; i < n; ++i) {
        int j = p[i];
        if (mask & (1 << i)) {
            double t0 = sqrt((a[j].x0 - x) * (a[j].x0 - x) + (a[j].y0 - y) * (a[j].y0 - y)) / s;
            double t1 = sqrt((a[j].x1 - a[j].x0) * (a[j].x1 - a[j].x0) + (a[j].y1 - a[j].y0) * (a[j].y1 - a[j].y0)) / t;
            ret += t0 + t1;
            x = a[j].x1, y = a[j].y1;
        }
        else {
            double t0 = sqrt((a[j].x1 - x) * (a[j].x1 - x) + (a[j].y1 - y) * (a[j].y1 - y)) / s;
            double t1 = sqrt((a[j].x1 - a[j].x0) * (a[j].x1 - a[j].x0) + (a[j].y1 - a[j].y0) * (a[j].y1 - a[j].y0)) / t;
            ret += t0 + t1;
            x = a[j].x0, y = a[j].y0;
        }
    }
    return ret;
}

int main(){
    //freopen("in.txt", "r", stdin);
    cin >> n >> s >> t;
    for (int i = 0; i < n; ++i) 
        p[i] = i;
    for (int i = 0; i < n; ++i) {
        double x0, y0, x1, y1;
        cin >> x0 >> y0 >> x1 >> y1;
        a[i] = { x0, y0, x1, y1 };
    }
    ans = 1e20;
    for (int i = 0; i < (1 << n); ++i) {
        do {
            ans = min(ans, get(i));
        } while (next_permutation(p, p + n));
    }
    
    printf("%.12f\n", ans);
    return 0;
}

E

N道工序，每道工序有两部分机器组成，你可以选任意个机器去制造零件
第一部分：每个机器制造A个零件，每个零件需要P元
第二部分：每个机器制造B个零件，每个零件需要Q元
设每道工序最后的零件数为 w i w_i wi​
给一个公式W= min ⁡ w i \min w_i minwi​，在总的预算X约束下
求最大的W

设 x 1 i x_{1i} x1i​为第i个工序的第一部分机器数量， x 2 i x_{2i} x2i​为第二部分机器数量
给定约束 A i x i P i + B i y i Q i ≤ X A_ix_{i}P_i+B_i y_{i}Q_i \leq X Ai​xi​Pi​+Bi​yi​Qi​≤X
求 m a x { min ⁡ ( A i x i + B i y i ) } max\left\{\min (A_ix_{i}+B_iy_{i}) \right \} max{min(Ai​xi​+Bi​yi​)}

最大化最小化的题目，二分答案，看是否能够满足预算
对于每道工序，贪心是不对的，因为这是一个整数规划问题
min ⁡ ( A i x i P i + B i y i Q i ) \min (A_ix_iP_i+B_iy_iQ_i) min(Ai​xi​Pi​+Bi​yi​Qi​)对于 A i x i + B i y i ≤ W A_ix_i+B_iy_i \leq W Ai​xi​+Bi​yi​≤W
有两种解法，第一种是对 W W W加一个余数，可以证明这个余数小于100，得到 A i x i + B i y i = W + r A_ix_i+B_iy_i = W+r Ai​xi​+Bi​yi​=W+r
然后用扩展欧几里得去做，一定有唯一解
第二种解法假设 P i A i > Q i B i \frac{P_i}{A_i}>\frac{Q_i}{B_i} Ai​Pi​​>Bi​Qi​​
那么一定优先选 B B B
但是现在有整数限制，因此枚举 y i y_i yi​,直觉告诉我只要枚举100个就可以了
最后拍一个二分模板就好了

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <stack>
#include <unordered_map>
#include <algorithm>

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

struct Mach {
    ll a, p, b, q;
} m[101];
int n;
ll x;

ll get(ll v) {
    ll ret = 0;
    for (int i = 1; i <= n; ++i) {
        auto [a, p, b, q] = m[i];
        if (b * p < a * q) {
            swap(a, b);
            swap(p, q);
        }
        ll t = v / b;
        ll y; 
        if (v % b) t++;
        y = q * t;
        if (v % b) {
            for (int j = 1; j <= min(2000, int(t)); ++j) {
                ll lft = v - b * (t - j);
                ll t0 = lft / a;
                if (lft % a) t0++;
                ll z = q * (t - j) + p * t0;
                y = min(y, z);
            }
            
        }
        ret += y;
    }
    return ret <= x;
}


int main(){
    //freopen("in.txt", "r", stdin);
    cin >> n >> x;
    for (int i = 1; i <= n; ++i) {
        int a, p, b, q;
        cin >> a >> p >> b >> q;
        m[i] = { a, p, b, q };
    }
    ll lo = 1, hi = 1e10;
    //get(4);
    if (!get(1)) {
        printf("0\n");
        return 0;
    }
    while (lo <= hi) {
        ll mi = (lo + hi) / 2;
        bool rt = get(mi);
        if (rt) {
            lo = mi + 1;
        }
        else {
            hi = mi - 1;
        }
    }
    if (get(hi)) lo = hi;
    printf("%lld\n", lo);
    return 0;
}

F

需要运送n个货物，每个货物的运送时间都不能在 t i t_i ti​前( ≥ t i \geq t_i ≥ti​)
每一天可以运送K个货物，
对于天数D，每个货物的代价是 x i − D x_i-D xi​−D
在第D天运送货物后，下一次必须大于X+D天后才能运送货物
求代价和的最小值

又是一个需要直觉的题目。看起来无从下手，但是只需要敏锐感觉到：
运送时间是可以确定的，而且一定在 t i + i X t_i+iX ti​+iX天。由于n<=100，天数的选择最多是10100个。
dp方程是:
f ( t , i ) f(t,i) f(t,i)代表在t天运完第i个货物的最小值
f ( t , i ) = min ⁡ f ( d , i − k ) + c o s t [ i − k + 1.. i ] f(t,i)=\min f(d,i-k) + cost[i-k+1..i] f(t,i)=minf(d,i−k)+cost[i−k+1..i] 其中d ∈ [ 1 , t − x ] \in[1,t-x] ∈[1,t−x]当然这里的t和d需要离散化，另外用mn来记录最小值

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <stack>
#include <unordered_map>
#include <algorithm>

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

int n, K;
ll x;
ll t[110];
ll a[10200];
ll s[110];
map<ll, int> idx;
int m;
ll f[10200][110];
ll mn[10200][110];


int main(){
    //freopen("in.txt", "r", stdin);
    cin >> n >> K >> x;
    for (int i = 1; i <= n; ++i) {
        cin >> t[i];
        s[i] = s[i - 1] + t[i];
    }
    set<ll> can;
    for (int i = 1; i <= n; ++i) {
        for (int j = 0; j <= n; ++j) {
            can.insert(t[i] + x * j);
        }
    }
    int i = 0;
    ll bg = -ll(1e16);
    idx[bg] = i;
    a[i++] = bg;
    for (auto it = can.begin(); it != can.end(); ++it) {
        idx[*it] = i;
        a[i] = *it;
        i++;
    }
    m = idx.size();
    memset(f, 0x3f, sizeof(f));
    memset(mn, 0x3f, sizeof(mn));
    f[0][0] = 0;
    mn[0][0] = 0;
    ll ans = f[0][n];
    for (int i = 1; i <= m; ++i) {
        int pre = upper_bound(a, a + m + 1, a[i] - x) - a - 1;
        mn[i][0] = min(f[i][0], mn[i - 1][0]);
        for (int j = 1; j <= n; ++j) {
            //f[i][j] = min(f[i][j], f[i - 1][j]);
            if (a[i] >= t[j]) {
                for (int k = 0; k < j; ++k) {
                    if (j - k <= K) {
                        ll val = a[i] * (j - k) - (s[j] - s[k]);
                        f[i][j] = min(f[i][j], mn[pre][k] + val);
                    }
                }
            }
            mn[i][j] = min(f[i][j], mn[i - 1][j]);
            if (j == n) {
                ans = min(f[i][j], ans);
            }
        }
    }
    printf("%lld\n", ans);
    return 0;
}
rag_doll
关注
专栏目录
AtCoder ABC374 A-D题解
seanli1008的博客
10-07 223
AtCoder ABC374题解
atcoder ABC 374
2201_75845839的博客
10-09 166
思路：求最小的最大值，显然二分，二分出答案之后，对于每个i，贪心地使得处理的机器大于二分的值，并且花费最小。这时注意到每种机器处理的数量都是不大于100的，这也就意味着性价比较差的那一台机器最多不会超过100台。思路：注意到n很小，因此考虑爆搜，对于所有的点，枚举出所有的连接顺序，这一点可以用next_permutation很快的实现（注意next permutation枚举的是字典序不大于当前序列的所有排列，因此想要枚举所有的情况，应在最开始对原有序列进行sort操作使得原有序列的字典序最小）
abc 374 E (二分答案贪心）
x1653673086的博客
10-07 268
先贪心的想，我们肯定要选择性价比高的机器（用较少的钱做更多的工作）.如果刚好这些机器的效率是mid,那么这是最优的。如果效率>mid ，那么就有可能存在将几个a替换为b ,然后效率为MId,花费的更少。然后因为a b 很小，X很大，可以枚举性价比低的次数）随着效率的增大，所需要的钱变多。所以效率和需要的钱之间是单调的。那么问题变成 给定效率 判断所需要的最少的钱 是否小于等于X。那么对于给定的效率怎样找到 所 需要的最少的钱。最终的生产效率是所有工序的产品数量的最小值。现有 x元，问生产效率的最大值。
【题解】241005ABC374
nobkin的博客
10-06 195
思路：发现数据范围是20可以接受递归，每次把当前数加入到a,b其中之一然后往下搜索即可；D：最多六条线段，6!* pow(2,6) ≈ 50000 ，可以用dfs。B：判断两个字符串从第几个字符开始不同，如果相同输出0。C：将给定的一列数分成两对，求两对最小的差。A：判断是不是特定字符结尾。
abc374 g
Unlimitedz的博客
10-09 280
对于最小可相交路径覆盖，每个点的前驱节点和后继节点的个数不在保证至多为1，所以我们需要先进行一遍传递闭包，例如a->b->c->d,我们对于中间的不关心，我们只关心最终的结果，即a可以到达d，中间的过程我们不关心，因为可以重复覆盖。由此就转化为了最小不相交路径覆盖问题。的边，这样是不可行的，有以下反例：ab，bc，ac，如果我们按照上述进行建图，我们最终得到的答案为1，因为我们只需要一个abc的字符串即可，但对于字符串ac，其并没有作为子串进行出现。对于建图，我们不能将字母和字母之间直接建图，例如。
ABC 374 F - Shipping
qq_74355721的博客
10-08 220
i是某个节点，是一轮发货的开始，j是本次发货第一个的火舞 ，dp[i][j]代表的数是不算上这一轮发货的，前i-1个节点，发j-1个货的最小值。发货时间不宜推迟，一段从开始到发货的时间，要么是捡起该组第一个开始，然后捡起最后一个结束的紧密的时间节点，要么是缓冲期x结束之后立刻发货。然后我们每次处理，都预定一个最近的，差值比x大的时间节点next，我们把时间节点i获得的状态转移给next，然后最后一组的时候再结算。如若第i个节点什么事都不干的话，就把dp[i][j]的状态过度给dp[i+1][j]
AT_abc374_c [ABC374C] Separated Lunch 题解
2301_76224755的博客
10-07 1752
右侧可以传送到原题位置。
Atcoder Beginner Contest 374 . abc 题解
Haohuihuidododo的博客
10-06 471
用数组a存储初始时每一组的人数 用sum表示总人数 dfs中的两个参数分别表示已经遍历过的组和目前拿出的人数（没拿出的自动归入另一组）， 即 对于每一组 只有两种可能 拿出或者不拿出。四个科目 每个科目有n个作业 可同时处理一个科目的两个作业 仍然采用深度优先搜索。字符串问题 要求判断两个字符是否一致 如果不一致 输出第一个不一致的字符。优化的方式是取左右脑max与当前已经获得的Min的最小值。再已经获得的答案与这一轮更新的答案中取最小值即可。dfs()中的两个参数分别为组别和目前搜索到的题目。
AtCoder Beginner Contest 374 Solution
curry的博客
10-05 838
需要注意的是图可能有环. 这样就不能直接用DAG上的经典可重链覆盖套路.Note: 一个连通块至少需要一条链, 故每个连通块的答案应该纠正为。, 那么只有起点终点有流量变化. (一个流会贡献。的流量变化给两点) 我们对图作一个传递闭包, 记。为 流入的流量-流出的流量,则直观的答案就是。值域过大,需要离散化,可以发现关键点只有。每天的部分考虑背包, 可以发现对容量。的要求, 我们可以求一个最大的时刻。. 然后再贪心地让尽量多的船靠岸即可.的容量, 这一部分暴力背包即可., 然后计算每天的开销.
经典SQL学习笔记 (二)－单行函数
陆讯
03-12 3252
SQL函数即数据库的内置函数，可以运用在SQL语句中实现特定的功能。SQL单行函数对于每一行数据进行计算后得到一行输出结果。SQL单行函数根据数据类型分为字符函数、数字函数、日期函数、转换函数，另外还有一些别的函数。例如NVL函数 字符函数--lower（）：将字符串大写变成小写; upper（）：将字符串小写变成大写 ;initcap（）：字符串的首字母大写 SELECT UPPER('h
【ai】Easy-RAG 2： 安装依赖项
突围
07-25 119
pip3 install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple
基于STM32的水族馆鱼缸系统设计172
07-02 775
当前设计的水族馆鱼缸控制系统主要是针对大型水族馆的智能管理。在大型水族馆中，维持良好的水环境和鱼类的生存状态是十分重要的。这涉及到各种设备的精确控制和监测，包括水温、光照、水泵、鱼食投放、水质监测等。
在SpringBoot中转换_geometry数据_到Mysql_Postgresql中的TOAST_以及Postgis常用函数_以及JTS操作进行位置计算---PostgreSQL工作笔记008
添柴程序猿的专栏
08-03 626
可以看到这里的geoCol,就是对应的geometry的那个数据,格式就是字符串类型的,16进制的数据。然后把这个数据使用BinaryParser进行转换就可以了,转换后得到的Geometry类型的数据通过。然后我们拿到这个带有格式的数据以后就可以,使用mysql的sql语句,插入了。16进制的,然后我们拿到16进制的数据以后.调用toString()方法会得到一个字符串。这个字符串就是带有格式的,比如。
Netty 支持哪些常用的解码器？
悟已往之不谏，知来者之可追
11-12 564
之前我们介绍了 TCP 拆包/粘包的问题，以及如何使用 Netty 实现自定义协议的编解码。可以看到，网络通信的底层实现，Netty 都已经帮我们封装好了，我们只需要扩展 ChannelHandler 实现自定义的编解码逻辑即可。更加人性化的是，Netty 提供了很多开箱即用的解码器，这些解码器基本覆盖了 TCP 拆包/粘包的通用解决方案。本文章我们将对 Netty 常用的解码器进行讲解，一起探索下它们有哪些用法和技巧。 我们首先回顾一下 TCP 拆包/粘包的主流解决方案。并梳理出 Netty 对应的编码器
【C++算法】8.双指针_四数之和
hlyd520的博客
10-04 604
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 414
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
c语言练习题2(字符串和函数的使用)
最新发布
m0_74859128的博客
10-10 146
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 826
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
探究ABC压缩包中的文本内容
资源摘要信息:"ABC.rar_ABC" 本次分析的文件是一个压缩包文件，其文件名为"ABC.rar_ABC"，并且包含一个在压缩包内的文本文件"ABC.txt"。根据提供的描述内容，我们可以推断出以下几点信息： 首先，该文件标题"ABC....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值