KEYENCE Programming Contest 2024（AtCoder Beginner Contest 374）

已于 2024-10-06 10:39:48 修改
阅读量1.1k 收藏 26
点赞数 14
分类专栏： AtCoder 文章标签： 算法
于 2024-10-06 00:53:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80379979/article/details/142721170
版权

KEYENCE Programming Contest 2024（AtCoder Beginner Contest 374）

题目链接： KEYENCE Programming Contest 2024（AtCoder Beginner Contest 374） - AtCoder

A - Takahashi san 2

题目链接： A - Takahashi san 2 (atcoder.jp)

题目描述：

给定一个由小写字母组成的字符串 ( S )，如果 ( S ) 以 “san” 结尾，输出 “Yes”，否则输出 “No”。

解题思路：

这是一个简单的字符串匹配问题，要求判断字符串是否以特定后缀 “san” 结尾。

步骤：

  1. 读取字符串 ( S )。
  2. 获取字符串的长度，并检查最后三个字符是否依次为 ‘s’、‘a’、‘n’。
  3. 如果是，输出 “Yes”；否则输出 “No”。

这种问题可以通过简单的字符串索引操作解决，复杂度为 ( O(1) )，因为我们只需要检查固定长度的后缀。

C++代码实现：

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
#define close ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
vector<array<int, 3>> arr;
void solved()
{
    string s;
    cin>>s;
    int len = s.length();
    if(s[len-3]=='s' && s[len-2]=='a'&&s[len-1]=='n')
    {
        cout << "Yes";
    }
    else
    {
        cout << "No";
    }
}

signed main()
{
    close;
    solved();
}

B - Unvarnished Report

题目链接： B - Unvarnished Report (atcoder.jp)

题目描述：

给定两个字符串 ( S ) 和 ( T )，如果它们完全相同，输出 0；否则，输出第一个不同字符的位置。

解题思路：

这是一个字符串比较的问题，要求输出第一个不同字符的位置，或者确认两个字符串完全相同。

步骤：

  1. 读取两个字符串 ( S ) 和 ( T )。
  2. 比较它们的字符，逐一检查是否相等，直到找到第一个不同的字符。
  3. 如果找到了不同字符，输出其索引；如果一个字符串较短，直接输出较短字符串结束后的索引。
  4. 如果两个字符串完全相同，输出 0。

注意：如果字符串长度不等且短字符串完全匹配长字符串的前缀，则不同的字符位置是长度较短的字符串结束后的第一个字符。

C++代码实现：

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
#define close ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
vector<array<int, 3>> arr;
void solved()
{
    string s1;
    string s2;
    cin >> s1 >> s2;
    if(s1==s2)
    {
        cout << 0;
    }
    else
    {
        int len1 = s1.length();
        int len2 = s2.length();
        int minNum = min(len1, len2);
        int ans = -2;
        for (int i = 0; i < minNum;i++)
        {
            if(s1[i]!=s2[i])
            {
                ans = i;
                break;
            }
        }
        ++ans;
        if(ans == -1)
        {
            ans = minNum + 1;
        }
        cout << ans;
    }
}

signed main()
{
    close;
    solved();
}

C - Separated Lunch

题目链接： C - Separated Lunch (atcoder.jp)

题目描述：

KEYENCE 总部的员工需要分成两组 A 和 B，错开午休时间。总部有 ( N ) 个部门，部门 ( i ) 的人数为 ( K_i )。要求将所有部门分成两组，使得两组人数的较大者尽可能小。

解题思路：

这是一个典型的分组问题，类似于背包问题。目标是将人数总和尽可能平分，使得两组中人数较大者最小。

步骤：

  1. 将问题视作背包问题，寻找一种分组方式，使得两组人数尽量平衡。
  2. 通过递归或者动态规划计算所有可能的分组人数。
  3. 最终选取满足条件的最小较大者。

C++代码实现：

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
#define close ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
void split(int idx, int end, const vector<int> &nums, vector<int> &sums, int current_sum)
{
    if (idx == end)
    {
        sums.push_back(current_sum);
        return;
    }
    split(idx + 1, end, nums, sums, current_sum);
    split(idx + 1, end, nums, sums, current_sum + nums[idx]);
}

void solved()
{
    int n;
    cin >> n;
    vector<int> nums(n);
    int total = 0;
    for (auto &v : nums)
    {
        cin >> v;
        total += v;
    }
    int mid = n / 2;
    vector<int>sums1, sums2;
    split(0, mid, nums, sums1, 0);
    split(mid, n, nums, sums2, 0);
    sort(sums2.begin(), sums2.end());
    int half = total / 2;
    int minMax = LLONG_MAX;

    for (auto s1 : sums1)
    {
        if (s1 > half)
        {
            continue;
        }
        auto it = upper_bound(sums2.begin(), sums2.end(), half - s1);
        if (it != sums2.begin())
        {
            --it;
            int s2 = *it;
            int sum1 = s1 + s2;
            int sum2 = total - sum1;
            minMax = min(minMax, max(sum1, sum2));
        }
    }
    cout << minMax << endl;
}

signed main()
{
    close;
    solved();
}

D - Laser Marking

题目链接： D - Laser Marking (atcoder.jp)

题目描述：

给定一个 ( H imes W ) 的网格，使用激光在其中进行标记。激光可以沿着上下左右四个方向移动，要求用最少的步数标记尽量多的格子。

解题思路：

这是一个经典的图搜索问题，可以使用 BFS 来寻找最短路径，并标记尽量多的格子。由于每个格子只能被标记一次，问题可归结为如何在最短步数内遍历尽可能多的格子。

步骤：

  1. 从起始点开始，使用 BFS 搜索。
  2. 标记经过的每一个格子，确保不会重复访问。
  3. 记录步数，并在结束时统计总共标记的格子数。

C++代码实现：

#include <map>
#include <set>
#include <fstream>
#include <queue>
#include <deque>
#include <stack>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdio>
#include <bitset>
#include <iomanip>
#define endl '\n'
#define int long long
#define Max(a, b) (((a) > (b)) ? (a) : (b))
#define Min(a, b) (((a) < (b)) ? (a) : (b))
#define BoBoowen ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
using namespace std;

int n, S, T;
int f[114], vis[114];
double ans = 1e18;
struct node
{
    int x[2];
    int y[2];
} a[1145];

double dis(double x, double y, double a, double b)
{
    return sqrt(1.0 * (1.0 * x - a) * (x - a) + 1.0 * (1.0 * y - b) * (y - b));
}

void dfs(int x)
{
    if (x == n + 1)
    {
        int x = 0, y = 0;
        double res = 0;
        for (int s = 0; s < (1 << n); s++)
        {
            res = 0;
            x = 0;
            y = 0;
            for (int i = 1; i <= n; i++)
                if (s & (1 << i - 1))
                {
                    res += dis(x, y, a[f[i]].x[0], a[f[i]].y[0]) / 1.0 / S + dis(a[f[i]].x[0], a[f[i]].y[0], a[f[i]].x[1], a[f[i]].y[1]) / 1.0 / T;
                    x = a[f[i]].x[1];
                    y = a[f[i]].y[1];
                }
                else
                {
                    res += dis(x, y, a[f[i]].x[1], a[f[i]].y[1]) / 1.0 / S + dis(a[f[i]].x[0], a[f[i]].y[0], a[f[i]].x[1], a[f[i]].y[1]) / 1.0 / T;
                    x = a[f[i]].x[0];
                    y = a[f[i]].y[0];
                }
            ans = min(ans, res);
        }
        return;
    }
    for (int i = 1; i <= n; i++)
    {
        if (vis[i] == 0)
        {
            vis[i] = 1;
            f[x] = i;
            dfs(x + 1);
            vis[i] = 0;
        }
    }
}

signed main()
{
    cin >> n >> S >> T;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i].x[0];
        cin >> a[i].y[0];
        cin >> a[i].x[1];
        cin >> a[i].y[1];
    }
    dfs(1);
    cout << fixed << setprecision(8) << ans << endl;
}

E - Sensor Optimization Dilemma 2

题目链接： E - Sensor Optimization Dilemma 2 (atcoder.jp)

题目描述：

有 ( N ) 道工序，每道工序每天可以加工 ( A_i ) 个产品，处理的单价是 ( P_i )。总预算为 ( X ) 日元，目标是最大化每天的生产能力 ( W_i )，其中 ( W = \min(W_i) )。请问在预算范围内可以实现的最大生产能力是多少？

解题思路：

这是一个典型的预算优化问题，要求在给定预算限制下最大化生产能力。

步骤：

  1. 问题分析：我们需要在预算限制内，通过不同工序的调整来最大化生产能力。
  2. 二分查找：由于生产能力和预算之间存在单调关系，可以使用二分查找来确定最大可能的生产能力。
  3. 贪心计算预算需求：对于每个工序，通过当前生产能力需求计算所需费用。使用贪心算法计算每个工序在给定预算下的最优处理方式。
  4. 判断是否满足预算：对于每个二分出的生产能力，计算总费用是否在预算之内。

C++代码实现：

#include <map>
#include <set>
#include <fstream>
#include <queue>
#include <deque>
#include <stack>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdio>
#include <bitset>
#include <iomanip>
#define endl '\n'
#define int long long
#define Max(a, b) (((a) > (b)) ? (a) : (b))
#define Min(a, b) (((a) < (b)) ? (a) : (b))
#define BoBoowen ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
using namespace std;

const int N = 110;

int n, m;

int a[N], p[N], b[N], q[N];

signed main()
{
    BoBoowen;

    cin >> n >> m;

    for (int i = 1; i <= n; ++i)
    {
        cin >> a[i] >> p[i] >> b[i] >> q[i];
        if (p[i] * b[i] > q[i] * a[i])
        {
            swap(a[i], b[i]);
            swap(p[i], q[i]);
        }
    }
    int l = 0, r = 1e9;
    while (l < r)
    {
        int mid = l + r + 1 >> 1;
        int need = 0;
        for (int i = 1; i <= n; ++i)
        {
            int mn = 1e9;
            int cnt = (mid + a[i] - 1) / a[i];
            for (int j = Max(0, cnt - 1000); j <= cnt; ++j)
            {
                int lef = mid - j * a[i];
                int now = j * p[i];
                if (lef > 0)
                {
                    now += ((lef + b[i] - 1) / b[i]) * q[i];
                }
                mn = Min(mn, now);
            }
            need += mn;
        }
        if (need <= m)
        {
            l = mid;
        }
        else
        {
            r = mid - 1;
        }
    }
    cout << l << endl;
}

F - Shipping

题目链接： F - Shipping (atcoder.jp)

题目描述：

有 ( N ) 个订单，每个订单将在第 ( T_i ) 天到达。每次最多可以发货 ( K ) 个订单，并且每次发货后必须间隔 ( X ) 天才能再次发货。

每个订单的发货时间越晚，不满意度越高。不满意度的计算方式是：如果订单 ( i ) 在第 ( S_i ) 天发货，则该订单的不满意度为 ( (S_i - T_i) )。

求如何安排发货，以使总的不满意度最小。

解题思路：

这是一个典型的动态规划问题，目标是通过最优发货安排来最小化总不满意度。我们可以按照以下步骤进行：

  1. 订单排序：根据到达时间 ( T_i ) 对订单进行排序。
  2. 动态规划：使用动态规划来跟踪到当前订单的最小不满意度：
    • 使用二维数组 ( dp[i][j] )，表示在第 ( i ) 天发货第 ( j ) 批订单的最小不满意度。
    • 对于每个订单，计算当前发货安排对后续订单的影响。
  3. 贪心选择：每次发货时，优先选择不满意度最低的组合。

C++代码实现：

#include <map>
#include <set>
#include <fstream>
#include <queue>
#include <deque>
#include <stack>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdio>
#include <bitset>
#include <iomanip>
#define endl '\n'
#define int long long
#define Max(a, b) (((a) > (b)) ? (a) : (b))
#define Min(a, b) (((a) < (b)) ? (a) : (b))
#define BoBoowen ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
using namespace std;

const int N = 105;
const int inf = 1e9;
const int INF = 1e18;

int n, K, X;
int f[N][N][N], a[N], s[N];

signed main()
{
    BoBoowen;

    cin >> n >> K >> X;

    for (int i = 1; i <= n; ++i)
    {
        cin >> a[i];
        s[i] = s[i - 1] + a[i];
    }

    for (int i = 0; i <= n; ++i)
    {
        for (int j = 0; j <= n; ++j)
        {
            for (int k = 0; k <= n; ++k)
            {
                f[i][j][k] = INF;
            }
        }
    }

    for (int i = 1; i <= K; ++i)
    {
        f[i][i][0] = 1ll * a[i] * i - s[i];
    }

    for (int i = 1; i <= n; ++i)
    {
        for (int j = 1; j <= n; ++j)
        {
            for (int k = 0; k <= n; ++k)
            {
                for (int l = i + 1; l <= n; ++l)
                {
                    if (l - i > K)
                    {
                        continue;
                    }
                    if (f[i][j][k] != INF)
                    {
                        if (a[j] + k * X + X <= a[l])
                        {
                            f[l][l][0] = Min(f[l][l][0], f[i][j][k] + a[l] * (l - i) - (s[l] - s[i]));
                        }
                        if (a[j] + k * X + X >= a[l])
                        {
                            f[l][j][k + 1] = Min(f[l][j][k + 1], f[i][j][k] + (a[j] + k * X + X) * (l - i) - (s[l] - s[i]));
                        }
                    }
                }
            }
        }
    }

    int ans = INF;
    for (int i = 1; i <= n; ++i)
    {
        for (int j = 0; j <= n; ++j)
        {
            ans = Min(ans, f[n][i][j]);
        }
    }
    
    cout << ans;
}
BoBoo文睡不醒
关注
专栏目录
AtCoder Beginner Contest 374 A-E 题解
AKDreamer_HeXY的博客
10-09 948
每个步骤就至少得每天生产这么多个产品，求出总钱数判断是否。暴力枚举每一个选分到第一组还是第二组，用二进制数表示，最多。将两个字符串用特殊符号补全，使它们长度相等即可判断。在每个全排列中，要使用二进制数枚举画线起点和终点。个数，将它们分成两组，设这两组的和分别为。给你一个字符串，判断这个字符串是否以。元钱来购买机器，不一定要全用完。画一条线段，一条线段不能中断。一个机器，要画出平面上的。画一条线段，也可以从。函数来枚举画线顺序，
AtCoder Beginner Contest 374
2301_79470071的博客
10-09 217
dfs枚举每个数是否选入a数组中，求和比较。
KEYENCE Programming Contest 2024（AtCoder Beginner Contest 374） 题解
nike0good |Oier&ACMer | 熟能生巧
10-06 928
Problem Statement KEYENCE has a culture of addressing everyone with the suffix “-san,” regardless of roles, age, or positions.You are given a string S consisting of lowercase English letters.If S ends with san, print Yes; otherwise, print No. B - Unvarnish
KEYENCE Programming Contest 2024（AtCoder Beginner Contest 374）E题
weixin_65585251的博客
10-12 487
【代码】KEYENCE Programming Contest 2024（AtCoder Beginner Contest 374）E题。
KEYENCE Programming Contest 2024（AtCoder Beginner Contest 374）A-D题解
Zhou_yu_cong的博客
10-06 369
读入字符串，检查最后几个字符是不是san。
HUAWEI Programming Contest 2024（AtCoder Beginner Contest 342） --- E - Last Train -- 题解
weixin_73936404的博客
02-26 517
计算每个车站到第N个车站最晚的出发时间，如果我们从前往后查询答案是很复杂的（并且并不显然）但是如果我们假设我们到达第N个车站的时间为无限大，那么我们就可以得到这些车站最晚多久出发能到达这个车站，得到这些车站的最晚出发信息，我们就可以往前查询连接他们的车站最晚多久出发能到达他们。为什么这样一定是对的，因为如果他在最晚时间都无法到达这个车站，那么他在更少的时间也无法到达。（并且这样可以简单的往前继续查询怎么最晚到达这个车站）
KEYENCE Programming Contest 2021 (AtCoder Beginner Contest 227) B
Zmk123134的博客
11-14 754
Time Limit: 2 sec / Memory Limit: 1024 MB Score :200200points Problem Statement There areNpeople numbered1toN. Personiiguessed the building area of KEYENCE headquarters building to be Si square meters. The shape of KEYENCE headquarters buil...
KEYENCE Programming Contest 2021 (AtCoder Beginner Contest 227) A
Zmk123134的博客
11-14 347
题目： A - Last Card (atcoder.jp) 此题只需枚举每个数，再根据周期问题，解题。 代码： #include <iostream> #include <algorithm> using namespace std; #define N 1005 int a[N]; int main(){ int n,k,f; cin >> n >> k >> f; a[1] = f; for(int
KEYENCE Programming Contest 2021 (AtCoder Beginner Contest 227) F. Treasure Hunting（线性dp）
小衣同学的博客
03-27 253
h*w(h<=30,w<=30)的格子矩阵，第i行第j列格子权值a[i][j](1<=a[i][j]<=1e9)当前位于(i,j)，最小值是否已经出现过了，大于等于最小值的权值已经选了k个，权值和最小是多少。当前位于(i,j)，当前最小值是x，大于等于最小值的权值已经选了k个，权值和最小是多少。找到一条路径，取途中最大的k(k<h+w)个格子的权值求和后，和是所有路径中最小的。终态要么是大于最小值，要么是等于最小值，并且大于最小值的时候的值都是必取的。一开始想的是dp[i][j][x][k]表示，
KEYENCE 基恩士 SR GSDML file
04-25
KEYENCE 基恩士 SR GSDML file SR-X1H3H SR-PN1 SR-LR1 SR-5000 GSDML-V2.3-Keyence-N-L20-20150818 GSDML-V2.4-Keyence-SR-X1H3H-20240321
keyence ljv 基恩士keyence sdk资料.zip
01-07
《基恩士Keyence SDK资料详解》 基恩士（Keyence）是一家全球知名的自动化设备制造商，其产品广泛应用于各种工业领域。Keyence SDK（Software Development Kit）是基恩士提供的开发工具包，用于帮助开发者集成和...
keyence plc
01-18
### Keyence PLC 知识点详解 #### 一、Keyence PLC 介绍 Keyence PLC 是由日本Keyence公司开发的一款高性能可编程逻辑控制器（Programmable Logic Controller），广泛应用于工业自动化领域。Keyence 公司是全球...
Keyence基恩士LK-G5001驱动+LK-Navigator 2
03-02
Keyence基恩士LK-G5001驱动与LK-Navigator 2是针对Keyence公司生产的LK-G5001系列激光测距传感器的重要软件组件。这个系统为用户提供了高效、精确的非接触式距离测量解决方案，广泛应用于工业自动化、质量控制、生产...
基恩士Keyence新资料整理
02-28
基恩士Keyence是一家全球知名的自动化技术和传感器制造商，其产品广泛应用于工业自动化、检测和测量等领域。本资料整理主要聚焦于基恩士的最新产品和技术发展，以下将详细阐述相关知识点。 1. **基恩士Keyence公司...
100种算法【Python版】第36篇——Graham Scan算法
AnFany
11-02 272
100种算法【Python版】第36篇——Graham Scan算法
算法基础-链表
最新发布
August的专栏
11-05 217
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 324
华为od算法——HJ33
Keyence PLC OPC连接配置指南
“基恩士/Keyence OPC连接配置手册_以太网” 该手册主要介绍了如何配置基恩士/Keyence的KV系列PLC（可编程逻辑控制器）与OPC（OLE for Process Control，用于过程控制的对象链接与嵌入）进行以太网连接。OPC是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值