AtCoder Beginner Contest 300（D-G）

最新推荐文章于 2024-07-17 18:07:42 发布
最新推荐文章于 2024-07-17 18:07:42 发布
阅读量531 收藏
点赞数 1
分类专栏： Atcoder 期望类Dp 思维题 文章标签： c++ 算法 数据结构
kkk
本文链接：https://blog.csdn.net/scanner___yw/article/details/130458343
版权
思维题 同时被 3 个专栏收录
25 篇文章 0 订阅
订阅专栏
Atcoder
22 篇文章 1 订阅
订阅专栏
期望类Dp
2 篇文章 0 订阅
订阅专栏

D - AABCC (atcoder.jp)

        （1）题目大意

                给你个数N，问你不超过N的三个质数abc组成的数有多少个。

         （2）解题思路

                考虑到枚举的数不会特别多，因此预处理出1e6的质因子，暴力枚举即可。

         （3）代码实现

#include<bits/stdc++.h>
#define sz(x) (int) x.size()
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 1e6 + 10;
struct Primes {
    bitset <N> st;
    int cnt,primes[N],idx[N],n;
 
    Primes(int n = N - 1) {
        this->n = n;
        init(n);
    }
 
    void init(int n) {
        st[0] = st[1] = 1;
        for(int i = 2;i <= n;i ++) {
            if(!st[i]) {
                primes[++ cnt] = i;
                idx[i] = cnt;
            }
            for(int j = 1;primes[j] <= n / i;j ++) {
                st.flip(primes[j] * i);
                if(i % primes[j] == 0) break;
            }
        }
    }
    
    //判断x是否是质数      
    bool isPrime(int x) {
        assert(x <= n);
        return !st[x];
    }
    
    //求解x在质数表是第几个                    
    bool atIndex(int x) {
        assert(!st[x]);
        assert(x <= n);
        return idx[x];
    }
};
using i128 = __int128;
void solve(){
	ll n;
	cin >> n;
	Primes pr(1e6);
	vector <int> v;
	for(int i = 1;i <= 1e6;i ++) {
		if(pr.isPrime(i)) v.pb(i);
	}
	int cnt = 0,siz = sz(v);
	for(int i = 0;i < siz;i ++) {
		ll v1 = 1ll * v[i] * v[i];
		if(v1 > n) break;
		for(int j = i + 1;j < siz;j ++) {
			i128 v2 = (i128) 1 * v[j];
			if((i128) 1ll * v1 * v2 > n) break;
			for(int k = j + 1;k < siz;k ++) {
				i128 v3 = 1ll * v[k] * v[k];
                if((i128) v1 * v2 * v3 > n) break;
				cnt ++;
			}
		}
	}
	cout << cnt << endl;
}

int main()
{
    ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int T = 1;
//	cin >> T;
	while(T --) solve();
}

E - Dice Product 3 (atcoder.jp)

        （1）题目大意

                给你一个数N，然后给你一个初始数1，每次你可以摇一下骰子，摇到多少把当前的数乘上多少，问你最后变成N的概率是多少？

         （2）解题思路

                观察题目，考虑1没用，我们可以直接dp[i][j][k]表示2还剩i次，3还剩j次，5还剩k次的概率，因为4和6可以用2和3表示出来，因此我们考虑把N质因子分解，然后倒着dp即可。

                需要注意的是每一次只需要乘上1/5的概率。

                解释：考虑当前数为n

                        f(n) = \frac{1}{6}(f(n)+f(2n)+f(3n)+f(4n)+f(5n)+f(6n))

                移项可得

                ​​​​​​​        \frac{5}{6}f(n) = \frac{1}{6}(f(2n)+f(3n)+f(4n)+f(5n)+f(6n))

                        f(n) = \frac{1}{5}(f(2n)+f(3n)+f(4n)+f(5n)+f(6n))

         （3）代码实现

#include<bits/stdc++.h>
#define sz(x) (int) x.size()
#define PII pair<int,int>
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define rep(i, j, k) for (int i = (j); i <= (k); ++i)
#define per(i, j, k) for (int i = (j); i >= (k); --i)
#define SZ(v) int((v).size())
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
#define gc getchar
#define pc putchar
using namespace std;
using ll = long long;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
using namespace std;
const ll mod = 998244353;
ll ksm(ll a,ll b)
{
	ll res = 1;
	while(b) {
		if(b & 1) res = res * a % mod;
		a = a * a % mod;
		b >>= 1;
	}
	return res;
}
template <class T = int> T read() {
  T x = 0; bool f = 0; char ch = gc();
  while (!isdigit(ch)) f = ch == '-', ch = gc();
  while (isdigit(ch)) x = (x << 3) + (x << 1) + (ch ^ 48), ch = gc();
  return f ? -x: x;
}
template <class T> void write(T x) {
  if (x >= 0) { if (x > 9) write(x / 10); pc(x % 10 + 48); }
  else { pc('-'); if (x < -9) write(-x / 10); pc(48 - x % 10); }
}

namespace pr {
  mt19937_64 rnd(random_device{}());
  using ull = unsigned long long;
  using u128 = unsigned __int128;
  
  struct barrett_64 {
    ull mod, r;
    u128 k;
    barrett_64(ull _mod) {
      mod = _mod;
      r = __lg(mod);
      if ((1ull << r) < mod) r++;
      k = ((r == 64 ? u128(0) : u128(1) << r * 2) - 1) / mod + 1;
    }
    ull mul(ull a, ull b) {
      u128 c = ((u128(a) * b >> r) * k) >> r;
      if (c) c--;
      u128 d = u128(a) * b - u128(c) * mod;
      while (d >= mod) d -= mod;
      return d;
    }
    ull sub(ull a, ull b) { return a < b ? a - b + mod : a - b; }
    ull add(ull a, ull b) { return sub(a, mod - b); }
  } reducer(1);
  
  ull gcd(ull a, ull b) { return b ? gcd(b, a % b) : a; }
  ull qpow(ull a, ull b) {
    ull res(1);
    for (; b; b >>= 1, a = reducer.mul(a, a))
      if (b & 1) res = reducer.mul(res, a);
    return res;
  }
  bool is_prime(ull n) {
    if (n <= 1) return false;
    vector<ull> base = {2, 3, 5, 7, 11, 13, 17, 19, 23};
    for (ull p : base) {
      if (n == p) return true;
      if (n % p == 0) return false;
    } 
    reducer = barrett_64(n);
    ull m = (n - 1) >> __builtin_ctz(n - 1);
    for (ull p : base) {
      ull t = m, a = qpow(p, m);
      while (t != n - 1 && a != 1 && a != n - 1)
        a = reducer.mul(a, a), t *= 2;
      if (a != n - 1 && t % 2 == 0) return false;
    }
    return true;
  }
  ull get_factor(ull n) {
    if (n % 2 == 0) return 2;
    reducer = barrett_64(n);
    auto f = [&](ull x) { return reducer.add(reducer.mul(x, x), 1); };
    ull x = 0, y = 0, tot = 0, p = 1, q, g;
    for (ull i = 0; (i & 0xff) || (g = gcd(p, n)) == 1; i++) {
      if (x == y) {
        x = tot, y = f(x);
        if (++tot == n) tot = 0;
      }
      q = reducer.mul(p, reducer.sub(x, y));
      if (q) p = q;
      x = f(x), y = f(f(y));
    }
    return g;
  }
  
  vector<ull> solve(ull n) {
    if (n == 1) return {};
    if (is_prime(n)) return {n};
    ull d = get_factor(n);
    auto v1 = solve(d), v2 = solve(n / d);
    auto i1 = v1.begin(), i2 = v2.begin();
    vector<ull> ans;
    while (i1 != v1.end() || i2 != v2.end()) {
      if (i1 == v1.end()) ans.push_back(*i2++);
      else if (i2 == v2.end()) ans.push_back(*i1++);
      else {
        if (*i1 < *i2) ans.push_back(*i1++);
        else ans.push_back(*i2++);
      }
    }
    return ans;
  }
}
using i64 = long long;

constexpr int P = 998244353;
// assume -P <= x < 2P
int Vnorm(int x) {
    if (x < 0) {
        x += P;
    }
    if (x >= P) {
        x -= P;
    }
    return x;
}
template<class T>
T power(T a, i64 b) {
    T res = 1;
    for (; b; b /= 2, a *= a) {
        if (b % 2) {
            res *= a;
        }
    }
    return res;
}
struct Mint {
    int x;
    Mint(int x = 0) : x(Vnorm(x)) {}
    Mint(i64 x) : x(Vnorm(x % P)) {}
    int val() const {
        return x;
    }
    Mint operator-() const {
        return Mint(Vnorm(P - x));
    }
    Mint inv() const {
        assert(x != 0);
        return power(*this, P - 2);
    }
    Mint &operator*=(const Mint &rhs) {
        x = i64(x) * rhs.x % P;
        return *this;
    }
    Mint &operator+=(const Mint &rhs) {
        x = Vnorm(x + rhs.x);
        return *this;
    }
    Mint &operator-=(const Mint &rhs) {
        x = Vnorm(x - rhs.x);
        return *this;
    }
    Mint &operator/=(const Mint &rhs) {
        return *this *= rhs.inv();
    }
    friend Mint operator*(const Mint &lhs, const Mint &rhs) {
        Mint res = lhs;
        res *= rhs;
        return res;
    }
    friend Mint operator+(const Mint &lhs, const Mint &rhs) {
        Mint res = lhs;
        res += rhs;
        return res;
    }
    friend Mint operator-(const Mint &lhs, const Mint &rhs) {
        Mint res = lhs;
        res -= rhs;
        return res;
    }
    friend Mint operator/(const Mint &lhs, const Mint &rhs) {
        Mint res = lhs;
        res /= rhs;
        return res;
    }
    friend std::istream &operator>>(std::istream &is, Mint &a) {
        i64 v;
        is >> v;
        a = Mint(v);
        return is;
    }
    friend std::ostream &operator<<(std::ostream &os, const Mint &a) {
        return os << a.val();
    }
};
Mint dp[63][63][63];
int have[4];
void solve(){
	ll n;
	cin >> n;
	auto f = pr::solve(n);
	if(f.back() >= 7) {
		cout << 0 << endl;
		return;
	}
	for(auto x : f) {
		if(x == 2) have[1] ++;
		if(x == 3) have[2] ++;
		if(x == 5) have[3] ++;
	}
	dp[have[1]][have[2]][have[3]] = 1;
  	ll tv = ksm(5,P - 2);
  	int a = have[1],b = have[2],c = have[3];
	for(int i = a;i >= 0;i --) {
		for(int j = b;j >= 0;j --) {
			for(int k = c;k >= 0;k --) {
              	if(i == a && j == b && k == c) continue;
				if(i + 1 <= a) dp[i][j][k] += dp[i + 1][j][k];
              	if(j + 1 <= b) dp[i][j][k] += dp[i][j + 1][k]; 
				if(k + 1 <= c) dp[i][j][k] += dp[i][j][k + 1];
				if(i + 2 <= a) dp[i][j][k] += dp[i + 2][j][k];
				if(i + 1 <= a && j + 1 <= b) dp[i][j][k] += dp[i + 1][j + 1][k];
				dp[i][j][k] *= tv;
			}
		}
	}
	cout << dp[0][0][0] << endl;
}

int main()
{
    ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int T = 1;
//	cin >> T;
	while(T --) solve();
}

  F - More Holidays (atcoder.jp)               

             （1）题目大意

                        给你一次长度为N的字符串S，然后复制了M遍，问你可以一定把K个x变成o，问你最大的连续o的长度为多少？   

         （2）解题思路

                考虑前缀和预处理出每一个x的位置，然后枚举在这些x的位置开始改k次，O1即可算出来改了K个之后的位置，以及答案是多少。

         （3）代码实现

#include<bits/stdc++.h>
#define sz(x) (int) x.size()
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 5e5 + 10;
void solve(){
	ll n,m,k;
	string s;
	cin >> n >> m >> k;
	cin >> s;
	vector<int> p;
	for(int i = 0;i < n;i ++) {
		if(s[i] == 'x') p.pb(i);
	}
	auto get = [&](ll k) {
		ll rp = p[k % sz(p)] + k / sz(p) * n;
		return min(rp,n * m);
	};
	ll ans = get(k);
	for(int i = 0;i < sz(p);i ++) ans = max(ans,get(i + k + 1) - p[i] - 1);
	cout << ans << '\n';
}

int main()
{
    ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int T = 1;
//	cin >> T;
	while(T --) solve();
}

G - P-smooth number (atcoder.jp)

        （1）题目大意

         （2）解题思路

                用两个数组存下来前半部分的素数乘和后半部分的素数乘出来的数，然后排个序，枚举第一个数组，然后第二个数组用双指针扫一下计算贡献即可。

         （3）代码实现

#include<bits/stdc++.h>
#define sz(x) (int) x.size()
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 5e5 + 10;
struct Primes {
    bitset <N> st;
    int cnt,primes[N],idx[N],n;
 
    Primes(int n = N - 1) {
        this->n = n;
        init(n);
    }
 
    void init(int n) {
        st[0] = st[1] = 1;
        for(int i = 2;i <= n;i ++) {
            if(!st[i]) {
                primes[++ cnt] = i;
                idx[i] = cnt;
            }
            for(int j = 1;primes[j] <= n / i;j ++) {
                st.flip(primes[j] * i);
                if(i % primes[j] == 0) break;
            }
        }
    }
    
    //判断x是否是质数      
    bool isPrime(int x) {
        assert(x <= n);
        return !st[x];
    }
    
    //求解x在质数表是第几个                    
    bool atIndex(int x) {
        assert(!st[x]);
        assert(x <= n);
        return idx[x];
    }
}pr(100);
ll n,p;
void dfs(vector<ll> &a,int z)
{
	for(int i = 0;i < sz(a);i ++) {
		if(a[i] * z < n) {
			a.pb(a[i] * z);
		}
	}
}
void solve(){
	cin >> n >> p;
	vector<int> f;
	for(int i = 1;i <= p;i ++) {
		if(pr.isPrime(i)) f.pb(i); 
	}
	vector<ll> v1,v2;
	v1.pb(1),v2.pb(1);
	for(int i = 0;i < sz(f);i ++) {
		if(sz(v1) < sz(v2)) dfs(v1,f[i]);
		else dfs(v2,f[i]);
	}
	sort(all(v1));
	sort(all(v2));
	int j = sz(v2) - 1;
	ll ans = 0;
	for(int i = 0;i < sz(v1);i ++) {
		ll pv = n / v1[i];
		while(j >= 0 && v2[j] > pv) j --;
		ans += j + 1;
	}
	cout << ans << endl;
}

int main()
{
    ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int T = 1;
//	cin >> T;
	while(T --) solve();
}

A real Warrior
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AtCoder Beginner Contest 224题解 A-G
10-24 3993
AtCoder Beginner Contest 224 签到题、简单题 A - Tires 判断一个字符串是不是以er或ist结尾。 直接做即可 #include <bits/stdc++.h> using namespace std; int main() { string s; cin >> s; int n = s.size(); if (n >= 2 && s[n-1]=='r' && s[n-2]=
AtCoder Beginner Contest 263D - Left Right Operation
06-16
代码
AtCoder Beginner Contest 356 A-E
2301_80210089的博客
06-01 818
分析：我们可以考虑先将M拆分成二进制， 那么二进制位置上为1的才是有效的， 然后枚举这些位置, 判断0-N上有多少数在这些位置上为1，然后全部加起来。题目大意：给出一个长度为n的数组，求所有的二元组{i， j}满足i<j，的max(a[i], a[j]) / min(a[i], a[j])向下取整的和。赛时cwa了两发， 错在数组开小了，没注意M是偏大的，改了一次后没注意还要一个跟M相关，有点粗心了，f和g还有半小时，有思路但不多，这场感觉还行。时间复杂度：O(2^n * m * c)分析：直接模拟即可。
AtCoder Beginner Contest 258 A-G
qq_56195933的博客
07-04 481
本场感觉EF挺有意思。 B - Number Box C - Rotation 题意： 给定一个字符串S，给定Q个查询。 1 x:把最后x个字符移到S前面。 2 x:输出此时第x个字符。 2
AtCoder Beginner Contest 268G - Random Student ID
qq_53282173的博客
09-13 212
AtCoder Beginner Contest 268 G - Random Student ID 字典树 思维 概率期望
AtCoder Beginner Contest 222 E - Red and Blue Tree（dfs dp）
我们都有光明的未来
10-10 290
linkkkkk 题意： 给出nnn个点的树和长度为mmm的序列aaa。现需要给每条边染成red/bluered/bluered/blue色，要求按照aaa走的路径，经过的边数r−b=kr-b=kr−b=k，问方案数。 思路： 首先可以通过dfsdfsdfs将序列aaa的路径经过每条边的次数cic_ici​统计出来。这样问题就变成了从c1,c2,……cn−1c_1,c_2,……c_{n-1}c1​,c2​,……cn−1​中选择一些数和为rrr，剩余的数和为bbb，满足r−b=kr-b=kr−b=k 假设s
AtCoder Beginner Contest 234 （D-F)
m0_53430148的博客
01-10 662
D、Prefix K-th Max 题目大意：给定一个长度为n的数组和一个k，对于每一个i（i >= k&&i <= n), 求前i个数字中第k大的数字是什么。 题解： 此题可以用优先队列来解决, 我们可以维护一个小根堆，然后维护其里面的size，一旦大于k则进行pop，这样的话每次输出答案时列头就是我们所需的答案，由于每个值只进来一次只出去一次，因此时间复杂度时O(nlogn) ! AC代码： #include <iostream> #include <a
AtCoder Beginner Contest 361（A-G）
qq_67224001的博客
07-08 755
题目给定一颗无根树，先考虑固定一个根起点的情况，由于要走完所有的点，所以如果不在我们的最后一条路径上的话，其余每条路径都要经过两遍，由此对于当前情况的最好结果是 ： 路径和 * 2 - 最长子路径。可以先考虑一维，比如先考虑 z 轴是否相交，如果两个长方体的 z 轴不相交，那么不可能会有交的体积。按照题解的写法，将空白格子划分为 1 * n 的矩形，然后将包含（-1，-1）的矩形放入进行bfs即可。换根时，考虑是子树的两条路径，还是子树一条路径与父节点的路径和哪个最大就可。代码实现有点烂，最好看看别人的。
AtCoder Beginner Contest 300 (A~D)
m0_61923501的博客
05-01 333
直接模拟。
Atcoder Beginner Contest 300 A~E
璃儿安心
04-29 508
Atcoder beginner contest 300 - A~E。
AtCoder Beginner Contest 285（D-G）
scanner
01-19 171
atcoder日常练习
题解：AtCoder Beginner Contest 260 D-Changing Jewels
06-06
代码
题解：AtCoder Beginner Contest 261D - Flipping and Bonus
06-13
代码
题解：AtCoder Beginner Contest 262D - I Hate Non-integer Number
06-15
代码
题解：AtCoder Beginner Contest 262 C - Min Max Pair
06-14
代码，好简单。（请点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞...
小欧吃苹果-OPPO 2024届校招正式批笔试题-数据开发（C卷）
sigd的博客
07-16 500
小欧吃苹果，拓扑排序处理贪心问题。
学懂C语言系列（三）：C语言基本语法
最新发布
martian665的专栏
07-17 547
学懂C语言系列,C语言基本语法
C++ std::thread 管理线程生命周期：join 和 detach
m0_59680769的博客
07-16 995
方法用于同步主线程和子线程。也就是说，当主线程调用子线程的join方法时，主线程会被阻塞，直到子线程完成其执行。这意味着join方法确保主线程等待子线程结束，然后继续执行后续代码。t.join()方法则是让子线程在后台独立运行，与主线程分离。分离后的线程（也称为“游离线程”）不能再被join，它的资源会在该线程完成后自动释放。主线程会继续执行而不会等待该子线程。如果把std::this_thread::sleep_for(std::chrono::seconds(3));
【素养大赛c++复赛题-序列排序题解】图像模糊处理、吉利号码、战胜白蚁题解
qq_56949201的博客
07-16 179
第一行1个整数n,表示序列的大小。( 0 < n ≤ 1000) 第二行n个正整数，表示序列的每个数，每个数不大于100000000。对于给定的正整数序列，按照每个数的各位数和从大到小排序，各位数和相同的按照本身大小排序，大的在前，小的在后。来存储输入的数字序列，排序完成后输出序列，并在最后释放了动态分配的内存。输出按照题目要求排序后的序列。也可以使用动态分配的数组。
atcoder beginner contest 265
12-17
atcoder beginner contest 265 是由日本 Atcoder 组织的一场面向初学者的比赛。这是一场在线编程竞赛，旨在为初学者提供机会锻炼和展示他们的编程技能。 这次比赛包括了多个题目，涉及到算法、数据结构、动态规划等...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值