YACS2022年8月丙组

T1：角谷猜想

模拟

代码实现

 n = int(input())
while n > 1:
    if n%2 == 1:
        n = n*3+1
    else:
        n //= 2
    print(n, end=' ')

T2：屏幕比例

约分

代码实现

 // py
import math
x, y = map(int, input().split('*'))
g = math.gcd(x, y)
x //= g
y //= g 
print('%d:%d' % (x, y))
 
// C++
#include <bits/extc++.h>
 
using std::cin;
using std::cout;
using std::gcd;
 
int read() {
    int x = 0;
    char c;
    while (c < '0' or c > '9') c = getchar();
    while ('0' <= c and c <= '9') {
        x = x*10+(c-'0');
        c = getchar();
    }
    return x;
}
 
int main() {
    int x = read(), y = read();
    
    int g = gcd(x, y);
    x /= g;
    y /= g;
    
    cout << x << ':' << y << '\n';
    
    return 0;
}

T3：最大子串

方法一：

枚举起点和终点，有 $O(n^2)$ 种可能性。对于每个序列我们可以遍历其所有数，求出序列的数字和。总复杂度： $O(n^3)$

方法二：

引入 $s$ 数组，表示前缀和，s[i] 表示前 $i$ 个数之和。于是起点为 $i$ ，终点为 $j$ 的数字和就是 $s[j] - s[i-1]$ 。总复杂度： $O(n^2)$

方法三：

定下终点，因为我们求的是最大子段和，其实只需要考虑 $i \leqslant j$ 的情况下最小的 $s[i-1]$ 。总复杂度: $O(n)$

代码实现

 #include <bits/extc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
 
using std::cin;
using std::cout;
using std::min;
using std::max;
using std::vector;
 
int main() {
    int n;
    cin >> n;
    
    vector<int> a(n);
    rep(i, n) cin >> a[i];
    
    vector<int> s(n+1);
    rep(i, n) s[i+1] = s[i]+a[i];
    
    int ans = 0;
    int mn = 0;
    for (int i = 1; i <= n; ++i) {
        int now = s[i]-mn;
        ans = max(ans, now);
        mn = min(mn, s[i]);
    }
    
    cout << ans << '\n';
    
    return 0;
}

T4：独特数

50分暴力做法：

任给一个正整数 $x$ ，我们可以 $\log(x)$ 地判断出这个 $x$ 是不是独特数

遍历 $1 \sim N$ ，检查每个数是否是独特数

优化1：

借助估算，我们找一个比较接近的位置再做遍历

优化2：

当我们遍历遇到一个非独特数的时候，我们可以大步前进，而不是一直 i++，具体跨越的步数和第一次出现重复的位置相关

代码实现

 #include <bits/extc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
 
using std::cin;
using std::cout;
 
int n;
int rMax, total;
int cnt[10];
void getrMax() { // 给出一个上界，保证第 n 大的独特数小于等于 rMax；total 表示 1~rMax 一共有多少个独特数
    for (int i = 1, x = 1; i <= 10; ++i) { // 考虑 i 位的数
        // x 表示任意一个数开头的 i 位数存在多少个独特数
        if (i > 1) x *= 11-i;
        for (int l = 1; l <= 9; ++l) { // 首位
            total += x;
            if (total >= n) {
                rMax = (l+1)*pow(10, i-1)-1;
                return;
            }
        }
    }
}
 
int main() {
    cin >> n;
    
    getrMax();
    
    for (int i = rMax; i >= 1; --i) {
        memset(cnt, 0, sizeof cnt);
        // 1. 判断 i 是不是独特数
        int x = i;
        int b = 10, s = 1; // b 和 s 都是 10 的幂次，保证 b>i>=s，为了确定有几位数 
        while (b <= x) {
            b *= 10;
            s *= 10;
        }
        bool ok = true;
        while (s) {
            if (cnt[x%b/s] > 0) { // 表示 i 不是独特数，并且此时遇到的第一个重复
            // 2. 如果步数，步幅大步前进
                i -= s-1;
                ok = false;
                break;
            }
            cnt[x%b/s]++;
            b /= 10; s /= 10;
        }
        // 如果是，计数
        if (ok and total == n) {
            cout << i << '\n';
            return 0;
        }
        if (ok) total--;
    }
    
    return 0;
}

T5：匹配括号（四）

本题对栈的理解比较深

结论：括号有效---匹配完

引入深度的概念。从左往右扫，遇到左括号就深度+1，遇到右括号就深度-1
当我们讨论左括号的深度的时候，就是这个位置的深度（会把自己的+1算上）
当我们讨论右括号的深度的时候，不会算上自己的-1

其实我们最后要求的整个序列的值，就是所有深度为 1 的括号的值的和
当我们考虑一对深度为 $k$ 的括号的值得时候，其实就是它内部所有深度为 $k+1$ 的值的和，然后乘 2
唯一的特殊情况是，内部如果为空，则值直接等于 $1$

代码实现

 #include <bits/extc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
 
using namespace std;
using ll = long long;
 
//const int mod = 998244353;
const int mod = 1000000007;
struct mint {
    ll x;
    mint(ll x=0):x((x%mod+mod)%mod) {}
    mint operator-() const {
        return mint(-x);
    }
    mint& operator+=(const mint a) {
        if ((x += a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator-=(const mint a) {
        if ((x += mod-a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator*=(const mint a) {
        (x *= a.x) %= mod;
        return *this;
    }
    mint operator+(const mint a) const {
        return mint(*this) += a;
    }
    mint operator-(const mint a) const {
        return mint(*this) -= a;
    }
    mint operator*(const mint a) const {
        return mint(*this) *= a;
    }
    mint pow(ll t) const {
        if (!t) return 1;
        mint a = pow(t>>1);
        a *= a;
        if (t&1) a *= *this;
        return a;
    }
 
    // for prime mod
    mint inv() const {
        return pow(mod-2);
    }
    mint& operator/=(const mint a) {
        return *this *= a.inv();
    }
    mint operator/(const mint a) const {
        return mint(*this) /= a;
    }
};
istream& operator>>(istream& is, mint& a) {
    return is >> a.x;
}
ostream& operator<<(ostream& os, const mint& a) {
    return os << a.x;
}
 
const int MX = 200005;
 
mint val[MX/2]; // dp[k] 表示所有深度为 k 的括号的和
 
int main() {
    string s;
    cin >> s;
    
    int depth = 0;
    rep(i, s.size()) {
        if (s[i] == '(') {
            depth++;
        }
        else {
            if (s[i-1] == '(') val[depth] += 1;
            val[depth] += mint(2)*val[depth+1];
            val[depth+1] = 0;
            depth--;
        }
    }
    
    cout << val[1] << '\n';
    
    return 0;
}

解法2：栈
具体细节见 LC856

代码实现

 #include <bits/extc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
 
using namespace std;
using ll = long long;
 
//const int mod = 998244353;
const int mod = 1000000007;
struct mint {
    ll x;
    mint(ll x=0):x((x%mod+mod)%mod) {}
    mint operator-() const {
        return mint(-x);
    }
    mint& operator+=(const mint a) {
        if ((x += a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator-=(const mint a) {
        if ((x += mod-a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator*=(const mint a) {
        (x *= a.x) %= mod;
        return *this;
    }
    mint operator+(const mint a) const {
        return mint(*this) += a;
    }
    mint operator-(const mint a) const {
        return mint(*this) -= a;
    }
    mint operator*(const mint a) const {
        return mint(*this) *= a;
    }
    mint pow(ll t) const {
        if (!t) return 1;
        mint a = pow(t>>1);
        a *= a;
        if (t&1) a *= *this;
        return a;
    }
 
    // for prime mod
    mint inv() const {
        return pow(mod-2);
    }
    mint& operator/=(const mint a) {
        return *this *= a.inv();
    }
    mint operator/(const mint a) const {
        return mint(*this) /= a;
    }
};
istream& operator>>(istream& is, mint& a) {
    return is >> a.x;
}
ostream& operator<<(ostream& os, const mint& a) {
    return os << a.x;
}
 
int main() {
    string s;
    cin >> s;
    
    stack<mint> st;
    st.push(0);
    for (char c : s) {
        if (c == '(') st.push(0);
        else {
            mint v = st.top(); st.pop();
            st.top() += max(2*v.x, 1ll);
        }
    }
    
    cout << st.top() << '\n';
    
    return 0;
}

posted on 2022-09-02 08:33 V_Melville 阅读(106) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· YACS2022年7月丙组

· YACS2022年9月丙组

· 241116 noip 模拟赛

· 【YACS 2022年 1 月月赛丙组】平衡括号

· 代码随想录day9-栈和队列1

阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 使用C#创建一个MCP客户端
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· ollama系列1：轻松3步本地部署deepseek，普通电脑可用
· 按钮权限的设计及实现

导航

统计

公告

搜索

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

YACS2022年8月丙组

T1：角谷猜想

T2：屏幕比例

T3：最大子串

T4：独特数

T5：匹配括号（四）

	n = int(input())
	while n > 1:
	if n%2 == 1:
	n = n*3+1
	else:
	n //= 2
	print(n, end=' ')

	// py
	import math
	x, y = map(int, input().split('*'))
	g = math.gcd(x, y)
	x //= g
	y //= g
	print('%d:%d' % (x, y))

	// C++
	#include <bits/extc++.h>

	using std::cin;
	using std::cout;
	using std::gcd;

	int read() {
	int x = 0;
	char c;
	while (c < '0' or c > '9') c = getchar();
	while ('0' <= c and c <= '9') {
	x = x*10+(c-'0');
	c = getchar();
	}
	return x;
	}

	int main() {
	int x = read(), y = read();

	int g = gcd(x, y);
	x /= g;
	y /= g;

	cout << x << ':' << y << '\n';

	return 0;
	}

	#include <bits/extc++.h>
	#define rep(i, n) for (int i = 0; i < (n); ++i)

	using std::cin;
	using std::cout;
	using std::min;
	using std::max;
	using std::vector;

	int main() {
	int n;
	cin >> n;

	vector<int> a(n);
	rep(i, n) cin >> a[i];

	vector<int> s(n+1);
	rep(i, n) s[i+1] = s[i]+a[i];

	int ans = 0;
	int mn = 0;
	for (int i = 1; i <= n; ++i) {
	int now = s[i]-mn;
	ans = max(ans, now);
	mn = min(mn, s[i]);
	}

	cout << ans << '\n';

	return 0;
	}

	#include <bits/extc++.h>
	#define rep(i, n) for (int i = 0; i < (n); ++i)

	using namespace std;
	using ll = long long;

	//const int mod = 998244353;
	const int mod = 1000000007;
	struct mint {
	ll x;
	mint(ll x=0):x((x%mod+mod)%mod) {}
	mint operator-() const {
	return mint(-x);
	}
	mint& operator+=(const mint a) {
	if ((x += a.x) >= mod) x -= mod;
	return *this;
	}
	mint& operator-=(const mint a) {
	if ((x += mod-a.x) >= mod) x -= mod;
	return *this;
	}
	mint& operator*=(const mint a) {
	(x *= a.x) %= mod;
	return *this;
	}
	mint operator+(const mint a) const {
	return mint(*this) += a;
	}
	mint operator-(const mint a) const {
	return mint(*this) -= a;
	}
	mint operator*(const mint a) const {
	return mint(this) = a;
	}
	mint pow(ll t) const {
	if (!t) return 1;
	mint a = pow(t>>1);
	a *= a;
	if (t&1) a = this;
	return a;
	}

	// for prime mod
	mint inv() const {
	return pow(mod-2);
	}
	mint& operator/=(const mint a) {
	return this = a.inv();
	}
	mint operator/(const mint a) const {
	return mint(*this) /= a;
	}
	};
	istream& operator>>(istream& is, mint& a) {
	return is >> a.x;
	}
	ostream& operator<<(ostream& os, const mint& a) {
	return os << a.x;
	}

	const int MX = 200005;

	mint val[MX/2]; // dp[k] 表示所有深度为 k 的括号的和

	int main() {
	string s;
	cin >> s;

	int depth = 0;
	rep(i, s.size()) {
	if (s[i] == '(') {
	depth++;
	}
	else {
	if (s[i-1] == '(') val[depth] += 1;
	val[depth] += mint(2)*val[depth+1];
	val[depth+1] = 0;
	depth--;
	}
	}

	cout << val[1] << '\n';

	return 0;
	}