2020-2021 ICPC - Gran Premio de Mexico - Repechaje

最新推荐文章于 2023-04-24 17:39:27 发布
最新推荐文章于 2023-04-24 17:39:27 发布
阅读量2.7k 收藏 3
点赞数
分类专栏： Three_fruit
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bloom_er/article/details/115030679
版权

A. Atsa’s Checkers Board

  • 给定一个 n ∗ m n * m n∗m大小的矩阵，在该矩阵内放置黑色白色的石头，要保证每个 2 ∗ 2 2 * 2 2∗2的矩阵都有两个黑石头和两个白石头，问有多少种摆放方式
  • 可以发现当有两块颜色相同的石头摆放在一起的时候，整个矩阵的摆放方式就确定了
  • 可以发现第一行至少有一对颜色相同石子相连的方案数是 1 < < m − 2 1 << m - 2 1<<m−2
  • 而剩下两种没有颜色相同的石子相连的情况，黑白…和白黑…
  • 取其中一种情况作计算。可以发现当第一行确定为黑白…的时候，第一列的排列方式数就为 1 < < ( n − 1 ) 1 << (n - 1) 1<<(n−1)。同理可得第一行确定为白黑…的时候也为 1 < < ( n − 1 ) 1 << (n - 1) 1<<(n−1)，两者总和即为 1 < < n 1 << n 1<<n
  • 因此总情况数就是 ( 1 < < m ) + ( 1 < < n ) − 2 (1 << m) + (1 << n) - 2 (1<<m)+(1<<n)−2
#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 3200;
const int INF = 0x3f3f3f3f;
const double pi = acos(-1.0);
const double eps = 1e-8;
inline ll rd() {
    ll x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    return x * f;
}
int main() {
    ll n, m;
    n = rd();
    m = rd();
    if (n < 2 || m < 2) {
        puts("0");
        return 0;
    }
    printf("%lld\n", (1LL << n) + (1LL << m) - 2);
    return 0;
}

C. CLETS Patrols

  • 假设一个1*n的矩阵 ( a 1 , a 2 , a 3 . . . a n ) (a_1,a_2,a_3...a_n) (a1​,a2​,a3​...an​) ， a i a_i ai​ 表示当前守卫在第 i i i 个点的概率

  • 而输入的 n*n 矩阵表示，明显得到以下关系：
    ( a 1 ′ , a 2 ′ , a 3 ′ , . . . , a n ′ ) = ( a 1 , a 2 , a 3 , . . . , a n ) ∗ 输 入 的 n ∗ n 矩 阵 (a_1',a_2',a_3',...,a_n')=(a_1,a_2,a_3,...,a_n)* 输入的n*n矩阵 (a1′​,a2′​,a3′​,...,an′​)=(a1​,a2​,a3​,...,an​)∗输入的n∗n矩阵

  • 所以直接从原始矩阵 ( 1 , 0 , 0 , 0... , 0 ) ∗ ( n ∗ n ) 矩 阵 m (1,0,0,0...,0)*(n*n)矩阵^m (1,0,0,0...,0)∗(n∗n)矩阵m

  • 跑一个矩阵快速幂即可。

#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 1e7 + 10;
const int INF = 0x3f3f3f3f;
inline ll rd() {
    ll x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    return x * f;
}
ll gcd(ll x, ll y) {
    if (y == 0) return x;
    return gcd(y, x % y);
}
int n, m;
struct matrix {
    double a[202][202];
    matrix operator *(const matrix& b) {
        matrix c;
        /* for (int k = 1;k <= n;++k) {
             c.a[1][k] = 0;
             for (int i = 1;i <= n;++i) {
                 c.a[1][k] += this->a[1][i] * b.a[i][k];
             }
         }
         return c;*/
        for (int i = 1;i <= n;++i) {
            for (int j = 1;j <= n;++j) {
                c.a[i][j] = 0;
                for (int k = 1;k <= n;++k) {
                    c.a[i][j] += this->a[i][k] * b.a[k][j];
                }
            }
        }
        return c;
    }
}mp;
matrix fp(matrix a, int y) {
    matrix ans = a;
    while (y) {
        if (y & 1) ans = ans * a;
        a = a * a;
        y >>= 1;
    }
    return ans;
}
int main() {
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    cin >> n >> m;
    for (int i = 1;i <= n;++i) {
        for (int j = 1;j <= n;++j) {
            cin >> mp.a[i][j];
        }
    }
    matrix ans = fp(mp, m - 1);
    for (int i = 1;i <= n;++i) {
        cout << setprecision(10) << ans.a[1][i] << '\n';
    }
    return 0;
}

D. Determine the Winner Marshaland

  • 有题推得，求的是以下条件：
  • x ≡ p i − 2   ( m o d   p i ) x\equiv p_i-2\ (mod\ p_i) x≡pi​−2 (mod pi​)
  • 换过来 x + 2 ≡ p i ≡ 0   ( m o d   p i ) x+2\equiv p_i\equiv0\ (mod\ p_i) x+2≡pi​≡0 (mod pi​)
  • 所以就对 x + 2 x+2 x+2 进行质因数分解即可。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ull, ull> pii;
typedef pair<ll, ll>pll;
template<typename T>
inline void rd(T& x) {
	int tmp = 1;
	char c = getchar();
	x = 0;
	while (c > '9' || c < '0') {
		if (c == '-')tmp = -1;
		c = getchar();
	}
	while (c >= '0' && c <= '9') {
		x = x * 10 + c - '0';
		c = getchar();
	}
	x *= tmp;
}
const int N = 1e3 + 10;
const int M = 2e7 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ull seed = 31;
ll gcd(ll x, ll y) {
	if (y == 0) return x;
	return gcd(y, x % y);
}

int head[N], cntE = 0;
struct edge {
	int next, to;
}e[M];
void add(int u, int v) {
	e[cntE].to = v;
	e[cntE].next = head[u];
	head[u] = cntE++;
}
int n, m, q;
int prime[N], cnt = 0;
bool isprime[N];
void init() {
	for (int i = 2; i <= N - 5; ++i) {
		if (!isprime[i]) prime[++cnt] = i;
		for (int j = 1; j <= cnt && prime[j] * i <= N - 5; ++j) {
			isprime[i * prime[j]] = 1;
			if (i % prime[j] == 0) break;
		}
	}
}
int main() {
#ifdef _DEBUG
	FILE* _INPUT = freopen("input.txt", "r", stdin);
	//	FILE* _OUTPUT = freopen("output.txt", "w", stdout);
#endif
	int T = 1, cas = 0;
	rd(T);
	init();
	while (T--) {
		rd(n);
		n += 2;
		vector<int>ans;
		while (!(n & 1)) n >>= 1;
		for (int i = 2; i <= cnt && prime[i] * prime[i] <= n; ++i) {
			if (n % prime[i] == 0) {
				ans.push_back(prime[i]);
				while (n % prime[i] == 0) n /= prime[i];
			}
		}
		if (n > 1) ans.push_back(n);
		if (ans.empty()) puts("-1");
		else {
			for (int i = 0; i < ans.size(); ++i) {
				printf("%d%s", ans[i], i == ans.size() - 1 ? "\n" : " ");
			}
		}
	}
	return 0;
}

E. Enterprise Recognition Program

  • 给定一个树形图代表一个公司的主从结构，并且公司中有 n n n个员工，老板节点编号为 0 0 0，老板不属于员工
  • 操作 m m m次，并且有两种操作
  • 第一种操作是给员工 e e e发 v v v元的奖金
  • 第二种操作是给员工 e e e及其所有上司发 v v v元的奖金
  • 询问 q q q次，并且有两种询问
  • 第一种询问是询问员工 x x x有多少奖金
  • 第二种询问是询问员工 x x x的下属和员工 x x x共有多少奖金
  • 设置一个 e a r n earn earn数组， e a r n [ i ] [ 0 ] earn[i][0] earn[i][0]表示公司用操作一发给员工 i i i的奖金， e a r n [ i ] [ 1 ] earn[i][1] earn[i][1]表示公司用操作二发给员工 i i i的奖金， e a r n [ i ] [ 2 ] earn[i][2] earn[i][2]表示员工 i i i的下属们的总奖金
  • 从老板节点开始往下 d f s dfs dfs，从叶子节点往上累加奖金即可
  • 以下为两个递推公式， u u u为当前员工， v v v为 u u u的下属
  • e a r n [ u ] [ 1 ] + = e a r n [ v ] [ 1 ] ; earn[u][1] += earn[v][1]; earn[u][1]+=earn[v][1];
  • e a r n [ u ] [ 2 ] + = e a r n [ v ] [ 0 ] + e a r n [ v ] [ 1 ] + e a r n [ v ] [ 2 ] ; earn[u][2] += earn[v][0] + earn[v][1] + earn[v][2]; earn[u][2]+=earn[v][0]+earn[v][1]+earn[v][2];
  • 具体逻辑在代码中体现
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define lowbit(x) ((x) & -(x))
#define endl "\n"
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
typedef unsigned long long ull;
const int N = 1e6 + 10, NN = 2e3 + 10, INF = 0x3f3f3f3f, LEN = 20;
const ll MOD = 1e9 + 7;
const ull seed = 31;
const double pi = acos(-1.0), eps = 1e-8;
inline int read() {
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    return x * f;
}
struct Edge {
    int next, to;
} edge[N];
int num_edge, n, m, q, boss;
int head[N], cha[N];
ll earn[N][3];
void add_edge(int from, int to) {
    edge[num_edge].next = head[from];
    edge[num_edge].to = to;
    head[from] = num_edge++;
}
void init() {
    memset(head, -1, sizeof head);
}
void dfs(int u) {
    for (int i = head[u]; i != -1; i = edge[i].next) {
        int v = edge[i].to;
        dfs(v);
        earn[u][1] += earn[v][1];
        earn[u][2] += earn[v][0] + earn[v][1] + earn[v][2];
    }
}
int main() {
    // ios::sync_with_stdio(false);
    // cin.tie(0);
    // cout.tie(0);
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);
    n = read(), m = read(), q = read();
    init();
    for (int i = 1; i <= n; ++i) {
        int x = read();
        add_edge(x, i);
        if (x == 0)
            boss = i;
    }
    for (int i = 1; i <= m; ++i) {
        int m = read(), e = read(), v = read();
        earn[e][m - 1] += v;
    }
    dfs(boss);
    while (q--) {
        int op = read(), x = read();
        if (op == 1)
            printf("%lld\n", earn[x][0] + earn[x][1]);
        else
            printf("%lld\n", earn[x][2] + earn[x][1] + earn[x][0]);
    }
    return 0;
}

G. Goombas Colliding

  • 无论怎么撞，最终都会有一辆车子走的是他自己的路程或者别人的路程
#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 1e7 + 10;
const int INF = 0x3f3f3f3f;
inline ll rd() {
    ll x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    return x * f;
}
ll n, m;
void solve() {
    scanf("%lld %lld", &m, &n);
    ll ans = 0;
    for (int i = 1;i <= n;++i) {
        ll p, x;
        scanf("%lld %lld", &p, &x);
        if (x) ans = max(ans, m - p);
        else ans = max(ans, p);
    }
    printf("%lld\n", ans);
}
int main() {
    int T = 1;
    while (T--)
        solve();
    return 0;
}

H. Hamsters Training

  • 最后出来的公式是 C 2 n − 1 n C_{2n-1}^n C2n−1n​, 怎么来的真不知道
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ull, ull> pii;
typedef pair<ll, ll>pll;
template<typename T>
inline void rd(T& x) {
	int tmp = 1;
	char c = getchar();
	x = 0;
	while (c > '9' || c < '0') {
		if (c == '-')tmp = -1;
		c = getchar();
	}
	while (c >= '0' && c <= '9') {
		x = x * 10 + c - '0';
		c = getchar();
	}
	x *= tmp;
}
const int N = 2e5 + 10;
const int M = 2e7 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ull seed = 31;
ll gcd(ll x, ll y) {
	if (y == 0) return x;
	return gcd(y, x % y);
}
int n, m, q;
ll fac[N], ifac[N];
ll fp(ll x, ll y) {
	ll ans = 1;
	while (y) {
		if (y & 1) ans = ans * x % mod;
		x = x * x % mod;
		y >>= 1;
	}
	return ans;
}
ll C(int x, int y) {
	ll ans = fac[x];
	ll res = ifac[x - y] * ifac[y] % mod;
	ans = ans * res % mod;
	return ans;
}
int main() {
#ifdef _DEBUG
	FILE* _INPUT = freopen("input.txt", "r", stdin);
	//	FILE* _OUTPUT = freopen("output.txt", "w", stdout);
#endif
	int T = 1, cas = 0;
	rd(T);
	fac[0] = 1;
	for (int i = 1; i <= N - 10; ++i) fac[i] = fac[i - 1] * i % mod;
	ifac[N - 10] = fp(fac[N - 10], mod - 2);
	for (int i = N - 10; i > 0; --i) ifac[i - 1] = ifac[i] * i % mod;
	while (T--) {
		rd(n);
		ll ans = C(2 * n - 1, n);
		printf("%lld\n", ans);
	}
	return 0;
}

J. Just Turn the Wheels!

  • 根据题目意思，首先车轮滚动的距离要大于 s s s ,所以一个首先满足的 t u r n s turns turns 是 s c ∗ 360 30 \frac{s}{c}*\frac{360}{30} cs​∗30360​

  • 剩下的 s 1 = s % c s1=s\%c s1=s%c 的路程：需要满足在 t u r n s turns turns 的情况下还要让两个车轮的边同时平行于地面

  • 首先去求共同转动的角度 α \alpha α 能够两车轮的边同时平行于地面： α = 360 ° / g c d ( f , b ) \alpha=360°/gcd(f,b) α=360°/gcd(f,b) , f , b f,b f,b 为输入的车轮顶点数

  • 随后求 α \alpha α 和 t u r n s turns turns 的最小公倍数 ，即 θ = l c m ( α , 30 ° ) \theta=lcm(\alpha,30°) θ=lcm(α,30°)

  • 对于 s % c s\%c s%c 需要的角度是 β = ⌈ ( s % c ) /   c 360 ° ⌉ \beta=\lceil(s\%c)/\ \frac{c}{360°}\rceil β=⌈(s%c)/ 360°c​⌉

  • 所以最后 s % c s\%c s%c 需要的 t u r n s turns turns 是 ⌈ β θ ⌉ / 30 ° \lceil \frac{\beta}{\theta} \rceil /30° ⌈θβ​⌉/30°

#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 3200;
const int INF = 0x3f3f3f3f;
const double pi = acos(-1.0);
const double eps = 1e-8;
inline ll rd() {
    ll x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    return x * f;
}
int sgn(double x) {
    if (fabs(x) < eps)
        return 0;
    return x < 0 ? -1 : 1;
}
ll gcd(ll x, ll y) {
    if (!y) return x;
    return gcd(y, x % y);
}
ll c, f, b, s;
int main() {
    int T;scanf("%d", &T);
    while (T--) {
        scanf("%lld %lld %lld %lld", &c, &f, &b, &s);
        ll ans = 12LL * (s / c);
        s %= c;
        ll tmp1 = gcd(f, b);
        ll t = gcd(360, tmp1);
        ll x = 1LL * 360 / t;
        ll y = 30 ;
        ll tmp2 = x * y / gcd(x, y);
        ll res = (s * 360 / c);
        if (s * 360 % c != 0) ++res;
        res = res / tmp2 + (res % tmp2 != 0);
        res = res * tmp2 / 30;
        ans += res;
        printf("%lld\n", ans);
    }
}

K. Kitchen Waste

  • 有 n n n个面包， m m m口锅，每口锅中都装了一定体积的汤，要将汤淋在面包上，面包也有体积，一体积汤能淋一体积面包
  • 一次淋面包的操作必须要将整个面包都淋上汤，若锅中剩余汤的体积不足以将整个面包都淋上，则将这个锅中的汤都倒掉
  • 签到题，根据题意直接模拟即可
#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 1e7 + 10;
const int INF = 0x3f3f3f3f;
inline ll read() {
    ll x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    return x * f;
}
int n, m;
int a[N], b[N];
int main() {
    n = read();
    m = read();
    for (int i = 1; i <= n; ++i) 
        a[i] = read();
    for (int i = 1; i <= m; ++i)
        b[i] = read();
    int pos = 1;
    for (int i = 1; i <= m; ++i) {
        while (b[i] >= a[pos]) {
            b[i] -= a[pos];
            ++pos;
            if (pos > n)
                break;
        }
        if (pos > n)
            break;
    }
    int ans = 0;
    for (int i = 1; i <= m; ++i)
        ans += b[i];
    printf("%d\n", ans);
    return 0;
}

L. Lets Count Factors

  • 题意很明确，求 A , B A,B A,B 的共同质因数
  • 这题稍有不慎就会超时，下欧拉筛的范围控制到 1 0 7 \sqrt{10^7} 107 ​ 就可以了
  • 对于共同质因数的标记，使用 u n o r d e r e d _ m a p unordered\_map unordered_map 就万无一失了
#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 3200;
const int INF = 0x3f3f3f3f;
inline ll rd() {
    ll x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    return x * f;
}
int cnt;
int vis[N], pri[N];
void Euler(int n) {
    for (int i = 2; i <= n; i++) {
        if (!vis[i])
            pri[++cnt] = i;
        for (int j = 1; j <= cnt; j++) {
            if (i * pri[j] > n)
                break;
            vis[i * pri[j]] = true;
            if (i % pri[j] == 0)
                break;
        }
    }
}
unordered_map<int, bool>visn;
void cal(int x) {
    for (int i = 1;i <= cnt;++i) {
        if (x % pri[i] == 0) {
            visn[pri[i]] = 1;
            while (x % pri[i] == 0) x /= pri[i];
        }
    }
    if (x > 1) visn[x] = 1;
}
void solve() {
    int a = (int)rd(), b = (int)rd();
    visn.clear();
    cal(a);
    cal(b);
    printf("%d\n", visn.size());
}
int main() {
    int T = (int)rd();
    Euler(N);
    while (T--)
        solve();
    return 0;
}
_lanChe
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
umpt-2020-2021-team-tryout-contest：密歇根大学编程团队2020-2021团队试用比赛
02-14
【标题】：“umpt-2020-2021-team-tryout-contest：密歇根大学编程团队2020-2021团队试用比赛” 这个标题揭示了一个编程竞赛，由密歇根大学主办，目标是选拔优秀的编程团队成员。这可能是一个针对学生或社区成员的...
ACM-ICPC-制备：ACM-ICPC制备指南
02-02
《ACM-ICPC制备：ACM-ICPC制备指南》 在计算机科学领域，ACM国际大学生程序设计竞赛（ACM International Collegiate Programming Contest，简称ACM-ICPC）是一项备受瞩目的赛事，它挑战参赛者的编程技能、算法理解...
2021 ICPC Gran Premio de Mexico 1ra Fecha
Icey_dying的博客
10-04 9152
C,E,F,J,K,L
2021 ICPC Gran Premio de Mexico 2da Fecha(C,D,G,I)
weixin_50935546的博客
10-02 958
题目C. Cut the DeckD. Dislike the RaisinsG. Grid of LettersI. Integer Multiplicative Persistence C. Cut the Deck 链接:link. 思路:找出max(R的数量-B的数量)，从此处开始便利，n/2-d1[ i ] (B的数量)>=max，i即为所求。 int t; char s[1000010]; int d1[1000010],d2[1000010]; int main() { ios:
2022 ICPC Gran Premio de Mexico Repechaje 题解
最新发布
m0_53089164的博客
04-24 4233
BFS搜索，记录终点到起点的距离，搜到挨着终点的第一个点的时候停止这一方向的搜索，其它方向搜到死路为止。给一个长度为n的数组，在接下来m次查询x，x递减，所有大于x的值都会变成x，然后输出元素和。小明每天最多走3000步，一分钟最多走x步，最多走15分钟，问小明能走多少分钟。限制条件：(1)除了没有路可走的情况下，不能走已经走过的路（走到死路原路返回）先把数组排序，前缀和预处理，然后二分查找第一个大于x的数，直接计算即可。给一棵n个点的无根树，任意两点都联通，求从起点到终点最多可以走多少步。
2022 ICPC Gran Premio de Mexico 1ra Fecha 题解
nidhs的博客
07-10 4258
7.11训练
2022 ICPC Gran Premio de Mexico 1ra Fecha（一)
weixin_51934288的博客
09-16 4922
今天大部分时间都花在了上一场沈阳站的L题上了，一个树上背包+容斥原理，看了好久才理解，就不硬敲上了，再想几天在写题解。第一个想法是用二分图去写，看了下时限0.3秒，但还是想用带时间戳的二分图试一下，不出意外，tle了，但是！有一点读错了，低了假题，wa了一次。需要注意的是，浪费是指买多了，如果米买少了，不是浪费，此处理解错了。一个完全背包，预处理出1~50000中的数字，判断每个数能否到达。签到题，stoi可将字符串转化为10进制数，真是个好工具。签到题，考察了基本不等式这个小知识点。
基于C++的ACM-ICPC模板
02-22
【标题】：“基于C++的ACM-ICPC模板” 在计算机编程竞赛中，特别是国际大学生程序设计竞赛（ACM-ICPC）中，拥有一套高效、灵活且经过优化的编程模板是至关重要的。这个“基于C++的ACM-ICPC模板”集合了一套专门为...
ACM-CheatSheet：ACM-ICPC模板
02-03
ACM-ICPC备忘单 ACM-ICPC模板特征维护模板代码，自动生成PDF， 代码高亮，代码中渲染数学公式可直接插入tex文件仅包含一个文件的目录，会引入文件直接作为一个章节已有模板仅作为参考用法模板代码遵循/src目录下的...
TrainACM-ICPC-OLP:来自Kattis和Codeforce的ACM ICPC竞赛解决方案
04-09
与HCMUT OnlyBoys团队一起训练TrainACM-ICPC-OLP团队成员 - -2020年至2021年ACM-ICPC2020年西北欧洲区域竞赛（日期：20/04/2021-8/11问题）2018-2019 ACM-ICPC东南欧区域编程竞赛（SEERC 2018）（日期：31/03/2021-5...
【2021 ICPC Gran Premio de Mexico 2da Fecha F】Flipped Factorization 题解
Four's
11-09 717
题目大意   设 x 的质因数分解为 p1^c1p2^c2⋯pm^cm​，记 f(x)=c1^p1c2^p2⋯cm^pm，给定 n，求 ∑i=1^n f(n) mod 10^9+7。   n≤10^14 10s
2022 ICPC Gran Premio de Mexico 1ra Fecha （B、D、E、F）
weixin_51934288的博客
09-19 1508
差值为4时有2种情况，符合斐波那契，eg：4、8，可行区间为【5，7】从港口1开始，需要初始化一个值为1的矩阵，每次对线路进行选择，即乘上初始化的矩阵。求出由k个字母构成的总方案数减去由c个字母构成的字符串（c
训练记录番外篇（2）：2022 ICPC Gran Premio de Mexico 2da Fecha
qq_54017368的博客
10-18 2955
补的训练记录
hdu 1247 Hat’s Words
我是传奇
10-22 120
点击打开链接hdu 1247 题意：给定一序列的单词按照字典序输入，要求某些单词是由这其中的其它两个单词拼接而成的单词按照字典序输出 思路：把输入的单词建立成一棵字典树，然后顺序枚举这n个单词并判断即可 代码： #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;iostream&gt; #include&lt...
ICPC-2021-台北 Largest Remainder
CM_20030210的博客
11-06 292
名可铭的题解报告
2020-10-21
weixin_44418748的博客
10-21 75
0 2020-9-25 23:30 4983 1 2020-9-28 14:09 -168 4815 2 2020-9-28 21:37 238 5053 3 2020-9-28 22:00 -82 4971 4 2020-9-29 9:27 112 5083 5 2020-9-29 13:31 -102 4981 6 2020-9-29 22:30 137...
2020-2021 icpc southeastern european regional programming contest (seerc 2020)
03-16
202-2021 ICPC 东南欧洲区域编程竞赛（SEERC 202）是一项国际性的编程竞赛，旨在促进全球范围内的计算机科学和编程技能的发展。该竞赛由国际大学生程序设计竞赛（ICPC）组织，吸引了来自世界各地的优秀程序员参加。SEERC 202将在东南欧洲地区的多个城市举行，参赛者将在比赛中展示他们的编程技能和创造力，争夺最高荣誉和奖金。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值