2023 - 8- 28练习题

已于 2023-08-28 23:01:40 修改
阅读量97 收藏
点赞数
分类专栏： cf ACM练习题集 基础算法学习 文章标签： c++ 算法
于 2023-08-28 22:21:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuyuan12346/article/details/132548340
版权

A - WOW Factor

 

ans += 出现o的位置前的w数量 * o后面的w数量 

// Problem: A - WOW Factor
// Contest: Virtual Judge - 22练习赛
// URL: https://vjudge.net/contest/578163#problem/A
// Memory Limit: 256 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#include<map>
#include<string>
#include<cstring>
#include<cmath>
#include<bitset>
#include<sstream>//切割strtream头文件
#include<climits>//INT_MAX文件
#include <utility>
#include<memory>//for unique_ptr shared_ptr
using i64 = int64_t;
using namespace std;
#define int i64
#define endl '\n'
#define AC return 0;
#define WA(x) cout << x << endl;
#define lowbit(x) x & -x
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
int n, m, k, d, T = 1, A, B;

template<typename T>void read(T &x) {
    T f = 1;x = 0;char s = getchar();
    while(s < '0' || s > '9') {if(s == '-')f = -1;s = getchar();}
    while(s >= '0' && s <= '9') {x = x * 10 + s - '0';s = getchar();}
    x *= f;
}

template<typename T>void print(T x) {
    if(x < 0) putchar('-'),x = -x;
    if(x > 9) print(x / 10);
    putchar(x % 10 + '0');
    putchar('\n');
}
constexpr int Init(int x)
{
	return x * 2;
}

int pre[maxn];//前i个位置有多少个vv
void solve()
{
	auto x = make_unique<int>();
	string s;
	cin >> s;
	int n = s.size();
	s = "*" + s;
	for(int i = 1;i <= n;i++)
	{
		pre[i] = pre[i - 1] + (s[i] == 'v' && s[i - 1] == 'v');
	}
	int ans = 0;
	for(int i = 1;i <= n;i++)
	{
		if(s[i] == 'o')
		ans += (pre[i - 1] * (pre[n] - pre[i]));
	}
	cout << ans << endl;
}
 
signed main() {
    cin.tie(0) -> sync_with_stdio(false);
    int T = 1;
   	//read(T);
    while (T--) solve();
    return 0;
}

B - Mishka and the Last Exam

 

 贪心的想a[i] + a[n - i + 1] == b[i]

通过b数组构造a(非降序)则希望前者尽量小,后者尽量大

对于b[1]可以确定头and尾

则令a[n] = b[1] a[1] = 0

后面的构造也是将b[i]拆分赋值给a[i] and a[n - i + 1]

∵非降序则a[i]至少为a[i - 1]而a[n - i + 1]至少小于等于a[n - i + 2]

可得

又∵ 

很愉快的TIL

先前考虑优先满足前者

∵题目保证至少可以构造一组a,即一定有解

那么我们索性再贪一点让a[n - i  + 1] 赋值为a[n - i + 2]

那么  a[i] = b[i] - a[n - i + 1];

如果此时破坏了a的规则,则我们希望a[i]尽可能小,a[n - i + 1]尽可能大

// Problem: B - Mishka and the Last Exam
// Contest: Virtual Judge - 22练习赛
// URL: https://vjudge.net/contest/578163#problem/B
// Memory Limit: 256 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#include<map>
#include<string>
#include<cstring>
#include<cmath>
#include<bitset>
#include<sstream>//切割strtream头文件
#include<climits>//INT_MAX文件
#include <utility>
#include<memory>//for unique_ptr shared_ptr
using i64 = int64_t;
using namespace std;
#define int i64
#define endl '\n'
#define AC return 0;
#define WA(x) cout << x << endl;
#define lowbit(x) x & -x
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
int n, m, k, d, T = 1, A, B;

template<typename T>void read(T &x) {
    T f = 1;x = 0;char s = getchar();
    while(s < '0' || s > '9') {if(s == '-')f = -1;s = getchar();}
    while(s >= '0' && s <= '9') {x = x * 10 + s - '0';s = getchar();}
    x *= f;
}

template<typename T>void print(T x) {
    if(x < 0) putchar('-'),x = -x;
    if(x > 9) print(x / 10);
    putchar(x % 10 + '0');
    putchar('\n');
}
constexpr int Init(int x)
{
	return x * 2;
}
int a[maxn];
int b[maxn];
void solve()
{
	auto x = make_unique<int>();
	cin >> n;
	for(int i = 1;i <= n / 2;i++)cin >> b[i];
	//b[i] = a[i] + a[n - i + 1];
	//b[1] = a[1] + a[n]
	//b[2] = a[2] + a[n - 1]
	//b[3] = a[3] + a[n - 2]
	a[1] = 0;
	a[n] = b[1];
	for(int i = 2;i <= n / 2;i++)
	{
		a[n - i + 1] = min(a[n - i + 2], b[i]);
		a[i] = b[i] - a[n - i + 1];
		if(a[i] < a[i - 1])
		{
			a[i] = a[i - 1];
			a[n - i + 1] = b[i] - a[i];
		}
	}
	for(int i = 1;i <= n;i++)
	cout << a[i] << " ";
}
 
signed main() {
    cin.tie(0) -> sync_with_stdio(false);
    int T = 1;
   	//read(T);
    while (T--) solve();
    return 0;
}

C - Queen

 

 ∵叶子节点没有儿子节点,那么就不存在儿子节点尊重它(???题目的真理)

∴我们初始化默认每一个节点都不被子节点尊重

每轮输入其子节点编号p及c(1不尊重父节点,0反之) 

其中每一个节点只存在一个父节点则显然 fa[i] = c即可

而p相对i为父节点 == > i是p的子节点

若c == 0 则p被子尊重son[p] = 0;

∵p可以有多个子节点 == >> 一次为0永久为0 && son[p]默认初始化1

则通过son[p] &= c即可

// Problem: C - Queen
// Contest: Virtual Judge - 22练习赛
// URL: https://vjudge.net/contest/578163#problem/C
// Memory Limit: 256 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#include<map>
#include<string>
#include<cstring>
#include<cmath>
#include<bitset>
#include<sstream>//切割strtream头文件
#include<climits>//INT_MAX文件
#include <utility>
#include<memory>//for unique_ptr shared_ptr
using i64 = int64_t;
using namespace std;
#define int i64
#define endl '\n'
#define AC return 0;
#define WA(x) cout << x << endl;
#define lowbit(x) x & -x
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
int n, m, k, d, T = 1, A, B;

template<typename T>void read(T &x) {
    T f = 1;x = 0;char s = getchar();
    while(s < '0' || s > '9') {if(s == '-')f = -1;s = getchar();}
    while(s >= '0' && s <= '9') {x = x * 10 + s - '0';s = getchar();}
    x *= f;
}

template<typename T>void print(T x) {
    if(x < 0) putchar('-'),x = -x;
    if(x > 9) print(x / 10);
    putchar(x % 10 + '0');
    putchar('\n');
}
constexpr int Init(int x)
{
	return x * 2;
}

int fa[maxn];//i 是否尊重父亲
int son[maxn];// 是否被儿子尊重

void solve()
{
	auto x = make_unique<int>();
	cin >> n;
	memset(son, 1, sizeof son);
	for(int i = 1;i <= n;i++)
	{
		int p, c;
		cin >> p >> c;
		if(-1 == p)continue;	
		fa[i] = c;
		son[p] &= c;
		
	}
	
	bool is = false;
	for(int i = 1;i <= n;i++)
	{
		if(fa[i] && son[i])
		{
			is = true;
			cout << i << " ";
		}
	}
	if(!is) cout << -1 << endl;
}
 
signed main() {
    cin.tie(0) -> sync_with_stdio(false);
    int T = 1;
   	//read(T);
    while (T--) solve();
    return 0;
}

D - Zero Quantity Maximization

 

根据公式 任意x = a[i] * d + b[i]

// Problem: D - Zero Quantity Maximization
// Contest: Virtual Judge - 22练习赛
// URL: https://vjudge.net/contest/578163#problem/D
// Memory Limit: 256 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#include<map>
#include<string>
#include<cstring>
#include<cmath>
#include<bitset>
#include<sstream>//切割strtream头文件
#include<climits>//INT_MAX文件
#include <utility>
#include<memory>//for unique_ptr shared_ptr
using i64 = int64_t;
using namespace std;
#define int i64
#define endl '\n'
#define AC return 0;
#define WA(x) cout << x << endl;
#define lowbit(x) x & -x
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
int n, m, k, d, T = 1, A, B;

template<typename T>void read(T &x) {
    T f = 1;x = 0;char s = getchar();
    while(s < '0' || s > '9') {if(s == '-')f = -1;s = getchar();}
    while(s >= '0' && s <= '9') {x = x * 10 + s - '0';s = getchar();}
    x *= f;
}

template<typename T>void print(T x) {
    if(x < 0) putchar('-'),x = -x;
    if(x > 9) print(x / 10);
    putchar(x % 10 + '0');
    putchar('\n');
}
constexpr int Init(int x)
{
	return x * 2;
}
int a[maxn], b[maxn];
map<long double,int>Mod;
void solve()
{
	auto x = make_unique<int>();
	cin >> n;
	int z = 0;
	// c - b[i] = a[i] * d
	// 令 c = 0
	// d = -b[i] / a[i] ==>> 出现最多的d的次数 + 一定为0的个数即 a[i] == b[i] == 0
	for(int i = 1;i <= n;i++)cin >> a[i];
	for(int i = 1;i <= n;i++)cin >> b[i];
	for(int i = 1;i <= n;i++)
	{
		if(a[i] == 0){z += (b[i] == 0);continue;}
		Mod[(long double)-b[i] / a[i]]++;
	}
	int ans = 0;
	for(auto x : Mod)
	ans = max(ans, x.second);
	cout << ans + z << endl;
}
 
signed main() {
    cin.tie(0) -> sync_with_stdio(false);
    int T = 1;
   	//read(T);
    while (T--) solve();
    return 0;
}

 E - Banh-mi

 根据题意可以知道一个情况

每次吃xi ,其余 + xi,若xi == 0则sum最终为0(x1 = 0 | 1)

 那么贪心的将,希望sum最大,我们希望 + xi最大,每次吃掉的xi就为最大

统计1的个数,若1的个数为0 == >> ans = 0

else

对于1的变化一定为 1 2 4 8 ……(每次吃最大,第一次一定吃1,则最大变为2,吃2,变为4……)

num1 个 1的贡献等于 pow(2,num1) - 1

对于num0 个0 前num1个操作使得此时的0变成pow(2,num1) - 1

num0个操作后面0的贡献为(pow(2,num1) - 1) * (pow(2,num0) - 1)

ans = pow(2,num1) - 1 + (pow(2,num1) - 1) * (pow(2,num0) - 1)  = (pow(2,num1) - 1) * (pow(2,num0) )

我们用线段树维护区间[l,r]中间1的个数(写完发现前缀和即可,看到区间就想线段树了%……) 

// Problem: E - Banh-mi
// Contest: Virtual Judge - 22练习赛
// URL: https://vjudge.net/contest/578163#problem/E
// Memory Limit: 256 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#include<map>
#include<string>
#include<cstring>
#include<cmath>
#include<bitset>
#include<sstream>//切割strtream头文件
#include<climits>//INT_MAX文件
#include <utility>
#include<memory>//for unique_ptr shared_ptr
using i64 = int64_t;
using namespace std;
#define int i64
#define endl '\n'
#define AC return 0;
#define WA(x) cout << x << endl;
#define lowbit(x) x & -x
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
int n, m, k, d, T = 1, A, B;

template<typename T>void read(T &x) {
    T f = 1;x = 0;char s = getchar();
    while(s < '0' || s > '9') {if(s == '-')f = -1;s = getchar();}
    while(s >= '0' && s <= '9') {x = x * 10 + s - '0';s = getchar();}
    x *= f;
}

template<typename T>void print(T x) {
    if(x < 0) putchar('-'),x = -x;
    if(x > 9) print(x / 10);
    putchar(x % 10 + '0');
    putchar('\n');
}
constexpr int Init(int x)
{
	return x * 2;
}
string s;
struct node
{
	int l, r, w;
}tr[maxn];

void pushup(int u)
{
	tr[u].w = tr[u << 1].w + tr[u << 1 | 1].w;
}

int mypow(int a, int n)
{
	int ans = 1;
	while (n)
	{
		if (n & 1)
		{
			n -= 1;
			ans = ans * a % mod;
		}
		else
		{
			n /= 2;
			a = a * a % mod;
		}
	}
	return ans;
}

void built(int u, int l, int r)
{
	tr[u] = {l, r};
	if(l == r)tr[u].w = (s[l] == '1');
	else
	{
		int mid = (l + r) >> 1;
		built(u << 1,l, mid);
		built(u << 1 | 1,mid + 1, r);
		pushup(u);
	}
}

int query(int u ,int l, int r)
{
	if(tr[u].l >= l && tr[u].r <= r)return tr[u].w;
	int mid = (tr[u].l + tr[u].r) >> 1;
	int res = 0;
	if(l <= mid)res += query(u << 1, l, r);
	if(r > mid)res += query(u << 1 | 1, l, r);
	return res;
}

void solve()
{
	auto x = make_unique<int>();
	cin >> n >> m >> s;
	s = "*" + s;
	built(1, 1, n);
	//cout  << tr[1].l << " " << tr[1].r << " " << tr[1].w << endl;
	while(m--)
	{
		int l, r;
		cin >> l >> r;
		int num1 = query(1, l, r);
		int num0 = (r - l + 1) - num1;
		if(num1 == 0)cout << 0 << endl;
		else
		{
			int ans = (mypow(2, num1) - 1) * mypow(2, num0);
			cout << ans % mod << endl;
		}
	}
}
 
signed main() {
    cin.tie(0) -> sync_with_stdio(false);
    int T = 1;
   	//read(T);
    while (T--) solve();
    return 0;
}

F - The Number Of Good Substrings

 

 

首先暴力先行 

 枚举1到n的数字

将数字转换为二进制串

if(t.size() > n)break;后续不可能出现 == 的情况

else k = i - t.size();//前补0

只需要查找s中间t出现的次数累加即可

// Problem: F - The Number Of Good Substrings
// Contest: Virtual Judge - 22练习赛
// URL: https://vjudge.net/contest/578163#problem/F
// Memory Limit: 256 MB
// Time Limit: 4000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#include<map>
#include<string>
#include<cstring>
#include<cmath>
#include<bitset>
#include<sstream>//切割strtream头文件
#include<climits>//INT_MAX文件
#include <utility>
#include<memory>//for unique_ptr shared_ptr
using i64 = int64_t;
using namespace std;
#define int i64
#define endl '\n'
#define AC return 0;
#define WA(x) cout << x << endl;
#define lowbit(x) x & -x
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
int n, m, k, d, T = 1, A, B;

template<typename T>void read(T &x) {
    T f = 1;x = 0;char s = getchar();
    while(s < '0' || s > '9') {if(s == '-')f = -1;s = getchar();}
    while(s >= '0' && s <= '9') {x = x * 10 + s - '0';s = getchar();}
    x *= f;
}

template<typename T>void print(T x) {
    if(x < 0) putchar('-'),x = -x;
    if(x > 9) print(x / 10);
    putchar(x % 10 + '0');
    putchar('\n');
}

constexpr int Init(int x)
{
	return x * 2;
}

int check(const std::string& s, const std::string& t) {
	int count = 0;
    size_t pos = s.find(t);
    while (pos != std::string::npos) {
        count++;
        pos = s.find(t, pos + 1);
    }
    return count;
}

void solve()
{
	auto x = make_unique<int>();
	string s;
	cin >> s;
	int n = s.size();
	int ans = 0;
	for(int i = 1;i <= n; i++)
	{
		string t = bitset<32>(i).to_string();
		t = t.substr(t.find('1'));
		if(t.size() > i)break;
		if(t.size() < i)
		{
			int k = i - t.size();
			for(int j = 1;j <= k;j++)
			t = "0" + t;
		}
		//cout << i  << " " << t << endl;
		ans += check(s, t);
	}
	cout << ans << endl;
}
 
signed main() {
    cin.tie(0) -> sync_with_stdio(false);
    int T = 1;
  	cin >> T;
    while (T--) solve();
    return 0;
}

然后 很愉快的TIL

不难想 二进制下出现0(前往后)数字num的变化 == num << 1 = num * 2

若出现1(再末尾)num += 1

从前往后枚举(0 -> n)

∵前置0对num没有任何作用

∴我们直接先跳到距离i最近的1的位置(用a[i]保存)

 和先前讲解的一样若次数 num == j(尾) - i(头) + 1满足答案条件ans++

若 > break;

// Problem: F - The Number Of Good Substrings
// Contest: Virtual Judge - 22练习赛
// URL: https://vjudge.net/contest/578163#problem/F
// Memory Limit: 256 MB
// Time Limit: 4000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#include<map>
#include<string>
#include<cstring>
#include<cmath>
#include<bitset>
#include<sstream>//切割strtream头文件
#include<climits>//INT_MAX文件
#include <utility>
#include<memory>//for unique_ptr shared_ptr
using i64 = int64_t;
using namespace std;
#define int i64
#define endl '\n'
#define AC return 0;
#define WA(x) cout << x << endl;
#define lowbit(x) x & -x
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
int n, m, k, d, T = 1, A, B;

template<typename T>void read(T &x) {
    T f = 1;x = 0;char s = getchar();
    while(s < '0' || s > '9') {if(s == '-')f = -1;s = getchar();}
    while(s >= '0' && s <= '9') {x = x * 10 + s - '0';s = getchar();}
    x *= f;
}

template<typename T>void print(T x) {
    if(x < 0) putchar('-'),x = -x;
    if(x > 9) print(x / 10);
    putchar(x % 10 + '0');
    putchar('\n');
}

constexpr int Init(int x)
{
	return x * 2;
}
int a[maxn];//记录最近的一个1
void solve()
{
	string s;
	cin >> s;
    int n = s.size(), pre = n;
    int ans = 0;
    for(int i = n - 1;i >= 0;i--)
    {
    	if(s[i] == '1')
    	pre = i;
    	a[i] = pre;
    }
    for(int i = 0; i < n;i++)
    {
    	int num = 0;
    	for(int j = a[i];j < n;j++)
    	{
    		num *= 2;
    		if(s[j] == '1')num++;
    		if(num == j - i + 1)ans++;`
    		if(num > n) break;
    	}
    }
    cout << ans << endl;
}

signed main() {
    cin.tie(0) -> sync_with_stdio(false);
    int T = 1;
  	cin >> T;
    while (T--) solve();
    return 0;
}

QYB_书鸢
关注
专栏目录
Java程序设计2023-第二次上机练习
sylviiiiiia的博客
10-03 669
编写一个复数类，可以进行复数加法和减法运算。编写一个包含main方法的类测试该复数类。要求该复数类至少包含一个无参的构造方法和一个带参的构造方法；数据成员包括复数的实部和虚部，为double类型；包括两个方法，分别实现复数的加法和减法运算。输入格式:输入两个复数。输入为两行，每一行为一个复数的实部和虚部，用空格隔开。输出格式:输出复数加法和减法结果。输出为4行，第一行和第二行输出两个复数，第三行为两个复数的加法运算结果，第四行为减法运算结果。输入样例:在这里给出两组输入。1 2。
java教程(2023-3-21)
qq_66274152的博客
03-21 635
第一章：HelloWorld 1.java语言介绍 public class MainTest { public static void main(String[] args) { //软件分为系统软件和应用软件 //人机交互方式： 图形化界面 命令行方式 /* 常用的DOS命令： 1.切换盘符： 盘符 : 2.创建文件夹 md 文件名 3.查看目录 dir 4.进入文件夹 cd 文件夹名 5.删除文件
2023年CSP-J入门级第一轮初赛真题
m0_46192147的博客
05-26 1108
return 0;②;} else {③;return ④;int n;cin >> n;i < n;
Java基础之集合框架的学习 2023-4-28
weixin_47184716的博客
04-29 160
内存层面需要针对于多个数据进行存储。此时，可以考虑的容器有：集合Collection 和 数组add(Object obj) addAll(Collection coll) clear() isEmpty() size() contains(Object obj) containsAll(Collection coll) retainAll(Collection coll) //只保留交集，及两个集合中相同的部分!!!
2023-09-16 CSP-J 第一轮初赛真题解析
艾科叮
09-16 2453
(1)(寻找被移除的元素)问题:原有长度为 n+1公差为1等升数列，将数列输到程序的数组时移除了一个元素，导致长度为 n 的开序数组可能不再连续，除非被移除的是第一个或最后之个元素。12.考虑一个有向无环图，该图包含4条有向边：（1, 2）,（1, 3）,（2, 4）和（3, 4）以下哪个选项是这个有向无环图的一个有效的拓扑排序？除特殊说明外，判断题1.5分，选择题3分，共计40分）17. 将第7行中的"（s-b）*（s-c）"改为"（s-c）*（s-b）"不会影响程序运行的结果（ 对）（2分）
2023年CSP-J组初赛真题及答案
february_的博客
08-26 1452
2023年CSP-J组初赛真题及答案
Java程序设计2023-第三次上机练习
weixin_61133168的博客
11-04 1045
前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。定义接口，用于声明一个存放Integer元素的栈的常见方法://如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。//出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null public Integer peek();
华为高级路由技术笔记 2023-2024
ZiminLi的博客
02-26 1048
③ 同一种协议学到 且 度量值相同，同时放入路由表（ECMP多路径等值路由），路由器 同时使用 这几条路由转发数据（负载分担）目的IP 和 掩码 使用 逻辑或 计算，算出的结果 和 IP地址 相同就是 所谓的 匹配路由。IPv4网：RIPv1，RIPv2（v1和v2 不兼容）IPv6网：RIPng(Next generation)路由器 转发数据 看 IP路由表！路由器 如何 判断 目的IP 匹配 某条 路由？① 不同协议学到，比较 协议优先级。② 同一种协议学到，比较度量。IPv6网：OSPFv3。
PTA 2023-2024-1-数据结构练习题重现(递归+二叉树)
weixin_52686512的博客
01-06 894
该函数对于传入的正整数n返回1+2+3+…+n的和；若n不是正整数则返回0。题目保证输入输出在长整型范围内。建议尝试写成递归函数。函数f应返回第n个Fabonacci数。题目保证输入输出在长整型范围内。建议用递归实现。函数应将n的每一位数字从高位到低位顺序打印出来，每位数字占一行。L是不带头结点的单链表的头指针，即单链表首元素结点指针。L是不带头结点的单链表的头指针，函数MaxP返回表中最大元素的地址。如果单链表为空，返回空指针。n为台阶数，函数须返回 n级台阶的跳法总数。
BallTest学生练习模板(2023-09-28 1228).zip
10-03
"BallTest学生练习模板(2023-09-28 1228)"，这可能是一个包含所有练习题目的文档，比如一个Excel表格，其中包含了不同难度级别的题目，或者是HTML、PDF或者XML文件，用于在网页上展示练习题。这样的模板通常会包含...
2023年Python题库练习题完整版.doc
11-06
28. 假设有列表 a = ['name', 'age', 'sex'] 和 b = ['Dong', 38, 'Male']，请使用一个语句将这两个列表的内容转换为字典，并且以列表 a 中的元素为“键”，以列表 b 中的元素为“值”，这个语句可以写为 c = dict...
浙大翁恺pat练习题,PAT|中国大学MOOC-翁恺-C语言程序设计习题集25-28
weixin_29231263的博客
03-27 1427
07-1. 换个格式输出整数 (15)让我们用字母B来表示“百”、字母S表示“十”，用“12…n”来表示个位数字n(<10)，换个格式来输出任一个不超过3位的正整数。例如234应该被输出为BBSSS1234，因为它有2个“百”、3个“十”、以及个位的4。输入格式：每个测试输入包含1个测试用例，给出正整数n(<1000)。输出格式：每个测试用例的输出占一行，用规定的格式输出n。输入样例1...
武汉轻工大学2023-2024年软件工程毕业设计选题推荐50例
回明毕设项目
08-14 1676
之前有武汉轻工大学的童鞋在后台找我们，最近要准备毕业设计了，不会选题，希望可以帮忙给一些毕业设计题目，我整整花了一周把之前做的答辩通过的毕业设计成品进行整理，并精选一些容易实现且不会刷下来的题目列举下。
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 254
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
第八天: C语言深度探索：指针与函数的奥秘
qq_57484399的博客
10-31 597
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
C++之指针和引用
weixin_42300449的博客
11-04 175
在C++中，指针和引用是两种不同的机制，它们都可以用来间接访问变量。
力扣——另一个的子树（C语言）
2401_83456040的博客
10-30 199
原理：这里调用前面比较两颗树是否相同的函数（小编之前文章里面有：相同的树），将节点与subRoot传入函数，向下递归，左右节点，只要找到一个返回true，说明存在子树，即最后返回true。具有相同结构和节点值的子树。的某个节点和这个节点的所有后代节点。也可以看做它自身的一棵子树。
c++之 stack(栈)和queue(队列)
2301_80028974的博客
11-04 630
文档stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行 元素的插入与提取操作。stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定 的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器， 默认情况下使用deque。
算法|牛客网华为机试31-40C++
最新发布
奇树谦的博客
11-04 517
计算第5次落地后球经过的距离，除了第一次只经过一次，所以距离最后在减去初始长度，高度每次减去一半。for循环遍历一次，从后往前，如果是字符组成单词等遇到空格或者非字母输出。直接用sort函数就是按着ASCII码从小到大排序的。找每行每列的相加差1的数学规律，再每行输出。
2023-2024年度大学英语第二题库汇总
这个题库文件通常包含了各种类型的练习题和模拟试题，旨在帮助学生巩固所学知识点，提高英语应用能力和考试技巧。题库的内容可能涵盖听力、阅读、写作、翻译等多个部分，每一部分都旨在训练学生在各个方面的英语能力...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值