atcoder364（A~E）

最新推荐文章于 2024-11-09 20:38:27 发布
最新推荐文章于 2024-11-09 20:38:27 发布
阅读量442 收藏 4
点赞数 3
文章标签： 算法 c语言 数据结构 c++ 经验分享 动态规划 贪心算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sgyjhhik/article/details/140782656
版权

###A.Glutton Takahashi

/*    ʕ•̀ ω • ʔ  *˘︶˘*).。.:*♡ (∗ᵒ̶̶̷̀ω˂̶́∗)੭₎₎̊₊♡ (⋈◍＞◡＜◍)       ʕ•̫͡• ʔ•̫͡•ཻʕ•̫͡•ʔ•͓͡•ʔ.•♫•♬ •♬•♫•.✿.｡.:* ☆ .:**:.☆*.:｡.✿  *★°*:.☆:*.°★*
●▂● ●０● ●︿● ●ω● ●﹏● ●△● ●▽●   ♡⃝ ʜᴇʟʟᴏ •ᴗ• ☽⋆
     ∩  ∩        ̋(๑˃́ꇴ˂̀๑)   ᐕ)⁾⁾  *:ஐ (๑´ᵕ`) ஐ:* *ଘ(੭*ˊᵕˋ)੭* (੭ˊᵕˋ)੭* ੈ✩˚
  ＞(>_<)＜
    I   I
    I   I     ʕง•ᴥ•ʔง
    IU UI
   I     I          ꉂꉂ꒰•̤▿•̤*ૢ꒱
≧▂≦ ≧０≦ ≧︿≦ ≧ω≦ ≧﹏≦ ≧△≦ ꒰๑˃͈꒵˂͈๑꒱
☗♪叮☖叮♫ ☗铛♪ ☖♫☗♪叮☖叮♫ ☗铛♪ ☖♫☗♪叮☖叮♫ ☗铛♪ ☖♫☗♪叮☖叮♫ ☗铛♪ ☖♫
(～o▔▽▔)～o o～(▔▽▔o～)   ‿︵‿︵‿︵୨˚̣̣̣͙୧ - - - -୨˚̣̣̣͙୧‿︵‿︵‿︵
  */
#include<bits/stdc++.h>
using namespace std;
#define lll __int128
#define endl '\n'
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll> PII;
const int mod=1e9+7;
inline ll read()
{
   ll x = 0, y = 1;
   char c = getchar();
   while (!isdigit(c))
   {
      if (c == '-')
         y = -1;
      c = getchar();
   }
   while (isdigit(c))
   {
      x = (x << 3) + (x << 1) + (c ^ 48);
      c = getchar();
   }
   return x *= y;
}
inline void write(ll x)
{
   if (x < 0)
      x = -x, putchar('-');
   ll sta[35], top = 0;
   do
      sta[top++] = x % 10, x /= 10;
   while (x);
   while (top)
      putchar(sta[--top] + '0');
}

const int N = 3e5 + 10;
int a[N];
void Miraitowa(){
   int n;
   cin >> n;

   for (int i = 1; i <= n;i++){
      string s;
      cin >> s;
      if(s[s.size()-1]=='t')   a[i] = 1;
         else   a[i] = 0;
   }

   for (int i = 1; i < n;i++){
           if(a[i]==a[i+1]&&a[i]==1){
                  if(i+1==n){
                     cout << "Yes" << endl;
                     return;
                  }
                     else{
                        cout << "No" << endl;
                        return;
                     }
           }  
   }
   cout << "Yes" << endl;
}

int main(){
 ios::sync_with_stdio(false);
 cin.tie(0),cout.tie(0);
   // int t;
   // cin>>t;
   // while(t--)
      Miraitowa();
     return 0;
};

B. Grid Walk

/*    ʕ•̀ ω • ʔ  *˘︶˘*).。.:*♡ (∗ᵒ̶̶̷̀ω˂̶́∗)੭₎₎̊₊♡ (⋈◍＞◡＜◍)       ʕ•̫͡• ʔ•̫͡•ཻʕ•̫͡•ʔ•͓͡•ʔ.•♫•♬ •♬•♫•.✿.｡.:* ☆ .:**:.☆*.:｡.✿  *★°*:.☆:*.°★*
●▂● ●０● ●︿● ●ω● ●﹏● ●△● ●▽●   ♡⃝ ʜᴇʟʟᴏ •ᴗ• ☽⋆
     ∩  ∩        ̋(๑˃́ꇴ˂̀๑)   ᐕ)⁾⁾  *:ஐ (๑´ᵕ`) ஐ:* *ଘ(੭*ˊᵕˋ)੭* (੭ˊᵕˋ)੭* ੈ✩˚
  ＞(>_<)＜
    I   I
    I   I     ʕง•ᴥ•ʔง
    IU UI
   I     I          ꉂꉂ꒰•̤▿•̤*ૢ꒱
≧▂≦ ≧０≦ ≧︿≦ ≧ω≦ ≧﹏≦ ≧△≦ ꒰๑˃͈꒵˂͈๑꒱
☗♪叮☖叮♫ ☗铛♪ ☖♫☗♪叮☖叮♫ ☗铛♪ ☖♫☗♪叮☖叮♫ ☗铛♪ ☖♫☗♪叮☖叮♫ ☗铛♪ ☖♫
(～o▔▽▔)～o o～(▔▽▔o～)   ‿︵‿︵‿︵୨˚̣̣̣͙୧ - - - -୨˚̣̣̣͙୧‿︵‿︵‿︵
  */
#include<bits/stdc++.h>
using namespace std;
#define lll __int128
#define endl '\n'
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll> PII;
const int mod=1e9+7;
inline ll read()
{
   ll x = 0, y = 1;
   char c = getchar();
   while (!isdigit(c))
   {
      if (c == '-')
         y = -1;
      c = getchar();
   }
   while (isdigit(c))
   {
      x = (x << 3) + (x << 1) + (c ^ 48);
      c = getchar();
   }
   return x *= y;
}
inline void write(ll x)
{
   if (x < 0)
      x = -x, putchar('-');
   ll sta[35], top = 0;
   do
      sta[top++] = x % 10, x /= 10;
   while (x);
   while (top)
      putchar(sta[--top] + '0');
}

int n, m;
char a[1000][1000];

void Miraitowa(){
   cin >> n >> m;
   int sx, sy;
   cin >> sx >> sy;
   for (int i = 1; i <= n;i++)
      for (int j = 1; j <= m;j++)
         cin >> a[i][j];

   string s;
   cin >> s;

   for (int i = 0; i < s.size();i++){
        if(s[i]=='U'&&a[sx-1][sy]=='.')
           sx--;
        if (s[i] == 'L' && a[sx][sy-1] == '.')
           sy--;
        if (s[i] == 'R' && a[sx][sy+1] == '.')
           sy++;
        if (s[i] == 'D' && a[sx+1][sy] == '.')
           sx++;
   }
   cout << sx << " " << sy << endl;
}


int main(){
 ios::sync_with_stdio(false);
 cin.tie(0),cout.tie(0);
   // int t;
   // cin>>t;
   // while(t--)
      Miraitowa();
     return 0;
};

C.Minimum Glutton

/*    ʕ•̀ ω • ʔ  *˘︶˘*).。.:*♡ (∗ᵒ̶̶̷̀ω˂̶́∗)੭₎₎̊₊♡ (⋈◍＞◡＜◍)       ʕ•̫͡• ʔ•̫͡•ཻʕ•̫͡•ʔ•͓͡•ʔ.•♫•♬ •♬•♫•.✿.｡.:* ☆ .:**:.☆*.:｡.✿  *★°*:.☆:*.°★*
●▂● ●０● ●︿● ●ω● ●﹏● ●△● ●▽●   ♡⃝ ʜᴇʟʟᴏ •ᴗ• ☽⋆
     ∩  ∩        ̋(๑˃́ꇴ˂̀๑)   ᐕ)⁾⁾  *:ஐ (๑´ᵕ`) ஐ:* *ଘ(੭*ˊᵕˋ)੭* (੭ˊᵕˋ)੭* ੈ✩˚
  ＞(>_<)＜
    I   I
    I   I     ʕง•ᴥ•ʔง
    IU UI
   I     I          ꉂꉂ꒰•̤▿•̤*ૢ꒱
≧▂≦ ≧０≦ ≧︿≦ ≧ω≦ ≧﹏≦ ≧△≦ ꒰๑˃͈꒵˂͈๑꒱
☗♪叮☖叮♫ ☗铛♪ ☖♫☗♪叮☖叮♫ ☗铛♪ ☖♫☗♪叮☖叮♫ ☗铛♪ ☖♫☗♪叮☖叮♫ ☗铛♪ ☖♫
(～o▔▽▔)～o o～(▔▽▔o～)   ‿︵‿︵‿︵୨˚̣̣̣͙୧ - - - -୨˚̣̣̣͙୧‿︵‿︵‿︵
  */
#include<bits/stdc++.h>
using namespace std;
#define lll __int128
#define endl '\n'
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll> PII;
const int mod=1e9+7;
inline ll read()
{
   ll x = 0, y = 1;
   char c = getchar();
   while (!isdigit(c))
   {
      if (c == '-')
         y = -1;
      c = getchar();
   }
   while (isdigit(c))
   {
      x = (x << 3) + (x << 1) + (c ^ 48);
      c = getchar();
   }
   return x *= y;
}
inline void write(ll x)
{
   if (x < 0)
      x = -x, putchar('-');
   ll sta[35], top = 0;
   do
      sta[top++] = x % 10, x /= 10;
   while (x);
   while (top)
      putchar(sta[--top] + '0');
}

const int N = 2e5 + 10;
PII a[N];


bool cmp1(PII a,PII b){
   return a.first > b.first;
}
bool cmp2(PII a,PII b){
   return a.second > b.second;
}

void Miraitowa(){
   ll n, x, y;
   cin >> n >> x >> y;
   for (int i = 1; i <= n;i++)
      cin >> a[i].first ;
   for (int i = 1; i <= n;i++)
      cin >> a[i].second;

      sort(a + 1, a + 1 + n, cmp1);

      ll w1 = 0, w2 = 0, cnt = 0;
      for (int i = 1; i <= n; i++){
         w1 += a[i].first, w2 += a[i].second;
         if(w1>x||w2>y){
            cnt = i;
            break;
         }
         cnt++;
      }
      ll ans = cnt;

      // for (int i = 1; i <= n;i++)
      //    cout << a[i].first << " " << a[i].second << endl;

         w1 = 0, w2 = 0, cnt = 0;

      sort(a + 1, a + 1 + n, cmp2);

      for (int i = 1; i <= n; i++)
      {
         w1 += a[i].first, w2 += a[i].second;
         if (w1 > x || w2 > y)
         {
            cnt = i ;
            break;
         }
         cnt++;
      }
      cout << min(ans, cnt) << endl;
}


int main(){
 ios::sync_with_stdio(false);
 cin.tie(0),cout.tie(0);
   // int t;
   // cin>>t;
   // while(t--)
      Miraitowa();
     return 0;
};

D.Minimum Glutton

/*    ʕ•̀ ω • ʔ  *˘︶˘*).。.:*♡ (∗ᵒ̶̶̷̀ω˂̶́∗)੭₎₎̊₊♡ (⋈◍＞◡＜◍)       ʕ•̫͡• ʔ•̫͡•ཻʕ•̫͡•ʔ•͓͡•ʔ.•♫•♬ •♬•♫•.✿.｡.:* ☆ .:**:.☆*.:｡.✿  *★°*:.☆:*.°★*
●▂● ●０● ●︿● ●ω● ●﹏● ●△● ●▽●   ♡⃝ ʜᴇʟʟᴏ •ᴗ• ☽⋆
     ∩  ∩        ̋(๑˃́ꇴ˂̀๑)   ᐕ)⁾⁾  *:ஐ (๑´ᵕ`) ஐ:* *ଘ(੭*ˊᵕˋ)੭* (੭ˊᵕˋ)੭* ੈ✩˚
  ＞(>_<)＜
    I   I
    I   I     ʕง•ᴥ•ʔง
    IU UI
   I     I          ꉂꉂ꒰•̤▿•̤*ૢ꒱
≧▂≦ ≧０≦ ≧︿≦ ≧ω≦ ≧﹏≦ ≧△≦ ꒰๑˃͈꒵˂͈๑꒱
☗♪叮☖叮♫ ☗铛♪ ☖♫☗♪叮☖叮♫ ☗铛♪ ☖♫☗♪叮☖叮♫ ☗铛♪ ☖♫☗♪叮☖叮♫ ☗铛♪ ☖♫
(～o▔▽▔)～o o～(▔▽▔o～)   ‿︵‿︵‿︵୨˚̣̣̣͙୧ - - - -୨˚̣̣̣͙୧‿︵‿︵‿︵
  */
#include<bits/stdc++.h>
using namespace std;
#define lll __int128
#define endl '\n'
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll> PII;
const int mod=1e9+7;
inline ll read()
{
   ll x = 0, y = 1;
   char c = getchar();
   while (!isdigit(c))
   {
      if (c == '-')
         y = -1;
      c = getchar();
   }
   while (isdigit(c))
   {
      x = (x << 3) + (x << 1) + (c ^ 48);
      c = getchar();
   }
   return x *= y;
}
inline void write(ll x)
{
   if (x < 0)
      x = -x, putchar('-');
   ll sta[35], top = 0;
   do
      sta[top++] = x % 10, x /= 10;
   while (x);
   while (top)
      putchar(sta[--top] + '0');
}

const int N = 4e5 + 10;
ll n, q;
ll a[N];

ll getl(ll d, ll x)
{
   ll lo = lower_bound(a + 1, a + 1 + n, x - d) - a, ro = upper_bound(a + 1, a + 1 + n, x + d) - a - 1;
   return ro - lo + 1;
}

void Miraitowa(){
   cin >> n >> q;
   for (int i = 1; i <= n;i++)  cin >> a[i];
   sort(a + 1, a + 1 + n);

   while(q--){
      ll x, k;
      cin >> x >> k;
      ll l = 0, r = 3e8, res = 0;
      while(l<=r){
         int mid = l + r >> 1;
         if(getl(mid,x)>=k)    r = mid - 1, res = mid;
            else      l = mid + 1;
      }
      cout << res << endl;
   }


}


int main(){
 ios::sync_with_stdio(false);
 cin.tie(0),cout.tie(0);
   // int t;
   // cin>>t;
   // while(t--)
      Miraitowa();
     return 0;
};

E. Maximum Glutton

/*    ʕ•̀ ω • ʔ  *˘︶˘*).。.:*♡ (∗ᵒ̶̶̷̀ω˂̶́∗)੭₎₎̊₊♡ (⋈◍＞◡＜◍)       ʕ•̫͡• ʔ•̫͡•ཻʕ•̫͡•ʔ•͓͡•ʔ.•♫•♬ •♬•♫•.✿.｡.:* ☆ .:**:.☆*.:｡.✿  *★°*:.☆:*.°★*
●▂● ●０● ●︿● ●ω● ●﹏● ●△● ●▽●   ♡⃝ ʜᴇʟʟᴏ •ᴗ• ☽⋆
     ∩  ∩        ̋(๑˃́ꇴ˂̀๑)   ᐕ)⁾⁾  *:ஐ (๑´ᵕ`) ஐ:* *ଘ(੭*ˊᵕˋ)੭* (੭ˊᵕˋ)੭* ੈ✩˚
  ＞(>_<)＜
    I   I
    I   I     ʕง•ᴥ•ʔง
    IU UI
   I     I          ꉂꉂ꒰•̤▿•̤*ૢ꒱
≧▂≦ ≧０≦ ≧︿≦ ≧ω≦ ≧﹏≦ ≧△≦ ꒰๑˃͈꒵˂͈๑꒱
☗♪叮☖叮♫ ☗铛♪ ☖♫☗♪叮☖叮♫ ☗铛♪ ☖♫☗♪叮☖叮♫ ☗铛♪ ☖♫☗♪叮☖叮♫ ☗铛♪ ☖♫
(～o▔▽▔)～o o～(▔▽▔o～)   ‿︵‿︵‿︵୨˚̣̣̣͙୧ - - - -୨˚̣̣̣͙୧‿︵‿︵‿︵
  */
#include <bits/stdc++.h>
using namespace std;
#define lll __int128
#define endl '\n'
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> PII;
const int mod = 1e9 + 7;
inline ll read()
{
   ll x = 0, y = 1;
   char c = getchar();
   while (!isdigit(c))
   {
      if (c == '-')
         y = -1;
      c = getchar();
   }
   while (isdigit(c))
   {
      x = (x << 3) + (x << 1) + (c ^ 48);
      c = getchar();
   }
   return x *= y;
}
inline void write(ll x)
{
   if (x < 0)
      x = -x, putchar('-');
   ll sta[35], top = 0;
   do
      sta[top++] = x % 10, x /= 10;
   while (x);
   while (top)
      putchar(sta[--top] + '0');
}

const int N = 100, M = 2e4 + 10;
int f[N][M][N];
int n, X, Y;

void Miraitowa()
{

   cin >> n >> X >> Y;
   memset(f, 0x3f, sizeof f);

   f[0][0][0] = 0;

   for (int i = 1; i <= n;i++){
      int a, b;
      cin >> a >> b;
         for (int k = 0; k <= X; k++)
            for (int j = 0; j <= i; j++)
            {
               f[i][k][j] = f[i - 1][k][j];
               if (j && k >= a)
                  f[i][k][j] = min(f[i][k][j], f[i - 1][k-a][j-1] + b);
         }
   }
   int res = 0;
   for (int j = 0; j <= X; j++)
      for (int i = 0; i <= n; i++)
         if(f[n][j][i]<=Y)
            res = max(res, min(i + 1, n));

   cout << res << endl;
}

int main()
{
   ios::sync_with_stdio(false);
   cin.tie(0), cout.tie(0);
   // int t;
   // cin >> t;
   // while (t--)
   Miraitowa();
   return 0;
};
hh妙蛙种子
关注
E - Xor Sigma Problem（abc365）
m0_74310050的博客
08-05 367
会发现其实只要每次算第i位最后得出来的数字乘以2的i次方即可。cnt[0] 统计到目前为止出现的前缀异或结果为0的次数。cnt[1] 统计到目前为止出现的前缀异或结果为1的次数。用an记录异或为1的个数，直接加上s[i]^1的个数就好啦。题意：给定一个长度为n的数组，求。
atcoder ABC 356-A题详解
2301_80662593的博客
06-02 569
将1～n个数存储到数组里，先要将l到r的数颠倒过来，可以用while循环实现并输出。
ABC 365 F-Takahashi on Grid
qq_74190237的博客
08-06 561
因为第二步结束之后，我们的位置一定是这一列的最上面或者最下面，那么明显的优化思路就是，预处理出从每列最上面点和最下面的点，重复一次上面的步骤能够走到的点。第一个难点，是怎么预处理出一次跳跃的点，我们可以使用st表来维护区间的最大值和最小值，如果我们是从一列的最上方的点开始走那么，我们操作结束之后，我们肯定是停留在某一列的最上方的点，这一列一定是最上方的点，低于操作值的点。如果我们是从一列的最下方的点开始走那么，我们操作结束之后，我们肯定是停留在某一列的最下方的点，这一列一定是最下方的点，高于操作值的点。
AtCoder ABC366 A-D题解
seanli1008的博客
08-12 291
AtCoder ABC366题解
Toyota Programming Contest 2024#8（AtCoder Beginner Contest 365）(A~E题解)
2301_80475191的博客
08-04 481
这次abc还是四个题，40分钟做了四个，由于前面三个题比较水，所以用的时间不多，第四个是忘了初始化，检查了十几分钟才发现错误，第五个拆位思想给忘了，后面去看了一下之前的那个博客才过的题意：就是说给你一个年份，让你去判断那个年份有多少天思路：4的倍数但是不是100的倍数是366天，400的倍数是366天，除了这两种情况都是365天。
AtCoder Beginner Contest 364 A~E
swan416的博客
07-27 810
好久没打atc了 这场打的挺烂的
atcoder361 A~E
2301_81239743的博客
07-07 954
他的路径数为n-1条，可以将图想象成一棵树，那么从一点去遍历这颗树再回到起点所需路程是所有路径×2.而题目没有要求回到起点，意味着从起点到其中一个叶子节点的路程是可以省略的，那么我们尝试去求出其中两叶子结点的最大距离，也就是求二叉树的直径，便能得出答案。相当于在序列中选取N-k个元素，使其中最大值减去最小值的结果最小，贪心的想，排序后连续的一段是最优的，所以先排序，然后遍历每一段长度为n-k的序列。给定一个长度为N的序列A，在删除k个元素后求出最小值ans=序列中的最大值-序列中的最小值。
AtCoder 235 A~E题
涛涛的个人博客
01-23 830
AtCoder小菜鸡训练A~D题
Atcoder abc A~E
yh2021tanghao的博客
08-24 441
AtCoder Beginner Contest 265 A~E
AtCoder Beginner Contest 166 A ~~E
01-03
A 水题： #include using namespace std; int main(){ string s; cin>>s; if(s==ABC) cout<<ARC>>n>>k; int d; for(int i=
2022.11.12日atcoder解题报告（A~E题）
wp_fxy的博客
11-14 566
atcoder277（A~E题解）
AtCoder Beginner Contest 250 A~E
m0_51731088的博客
05-09 556
AtCoder Beginner Contest 250 A~E A - Adjacent Squares 题意：给出一个行列为H，W的矩阵，再给一个坐标，问周围有多少个正方形。 // Problem: C - Adjacent Swaps // Contest: AtCoder - AtCoder Beginner Contest 250 // URL: https://atcoder.jp/contests/abc250/tasks/abc250_c // Memory Limit: 1024 MB /
AtCoder Beginner Contest 239 A~E
muxing_mushroom的博客
02-26 437
AtCoder Beginner Contest 239 A~E
Atcoder Beginner Contest abc 276 A~E
yh2021tanghao的博客
11-06 570
Atcoder Beginner Contest 276 A~E
STL set
最新发布
hls0611的博客
11-09 206
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
100种算法【Python版】第51篇——希尔排序
AnFany
11-06 313
100种算法【Python版】第51篇——希尔排序
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 363
Leetcode 160. 相交链表
洛谷 P2239 [NOIP2014 普及组] 螺旋矩阵
jzwalliser的博客
11-09 915
本文由Jzwalliser原创，发布在CSDN平台上，遵循CC 4.0 BY-SA协议。因此，若需转载/引用本文，请注明作者并附原文链接，且禁止删除/修改本段文字。
GJ Round (2024.10) Round 8~21
lunjiahao的博客
11-06 857
前言： 点此 返回 GJ Round 目录 Round 8 (10.5) A 给定 nnn 个区间，每个区间 [li,ri][l_i,r_i][li​,ri​]，最大化选取区间对数，使得每对区间 [li,ri],[lj,rj][l_i,r_i],[l_j,r_j][li​,ri​],[lj​,rj​] 满足 [li,ri]∩[lj,rj]=∅[l_i,r_i] \cap [l_j,r_j] =\varnothing[li​,ri​]∩[lj​,rj​]=∅ 先按 lil_ili​ 从小到大排序，再按
Atcoder358
06-17
AtCoder 358是指 AtCoder（一个知名的日本在线编程平台）的第358次比赛。AtCoder定期举办编程比赛，通常包含多种编程题目，涵盖算法、数学、数据结构等多个主题，目的是提供一个练习和提升编程技能的平台，并吸引...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值