Codeforces Round #744 (Div. 3)题解 【A~F】

最新推荐文章于 2024-07-23 17:36:37 发布
最新推荐文章于 2024-07-23 17:36:37 发布
阅读量186 收藏 1
点赞数 4
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50554695/article/details/120556021
版权

目录

A

题意：

给出一个由 A、B、C 三个字母组成的字符串，每次可以删掉一个‘A’一个‘B’，或者一个‘B’一个‘C’，是否能把这个字符串全部删完

题解：

要全部删完，‘A’的数量+‘C’的数量要等于‘B’的数量

#include<iostream>
#include<sstream>
#include<string>
#include<queue>
#include<map>
#include<unordered_map>
#include<set>
#include<vector>
#include<stack>
#include <utility>
#include<list>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<iomanip>
#include<time.h>
#include<random>
using namespace std;
#include<ext/pb_ds/priority_queue.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/hash_policy.hpp>
using namespace __gnu_pbds;
#include<ext/rope>
using namespace __gnu_cxx;

#define int long long
#define PI acos(-1.0)
#define eps 1e-9
#define lowbit(a) ((a)&-(a))

const int mod = 1e9+7;
int qpow(int a,int b){
	int ans=1;
	while(b){
		if(b&1)ans=(ans*a)%mod;
		a=(a*a)%mod;
		b>>=1;
	}
	return ans;
}
const int INF = 0x3f3f3f3f;
const int N = 1e6+10;

#define endl '\n'
signed main(){
	std::ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int _; cin>>_;
	while(_--){
		string s; cin>>s;
		int cnta=0,cntb=0,cntc=0,n=s.length();
		for(int i=0;i<n;i++){
			if(s[i]=='A')cnta++;
			else if(s[i]=='B')cntb++;
			else cntc++;
		}
		if(cntb==cnta+cntc)cout<<"YES"<<endl;
		else cout<<"NO"<<endl;
	}
}

B

题意：

给出一个数组a[1…n]，每次可以选择一个区间 [ l , r ] [l,r] [l,r] ，将这个区间的元素都往左移 d d d 位，这种操作最多执行 n n n 次，找到一种方案，使数组最后非递减

题解：

既然不需要最小化操作数，那就操作 n n n 次，第 i i i 次在区间 [ i . . n ] [i..n] [i..n] 找到最小值的位置 P，然后把区间 [ i . . P ] [i..P] [i..P] 往左移 P-i 个（其实就相当于往右移一个，往右移更好写），即每次都找到剩余元素的最小值并把它放在左边

#include<iostream>
#include<sstream>
#include<string>
#include<queue>
#include<map>
#include<unordered_map>
#include<set>
#include<vector>
#include<stack>
#include <utility>
#include<list>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<iomanip>
#include<time.h>
#include<random>
using namespace std;
#include<ext/pb_ds/priority_queue.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/hash_policy.hpp>
using namespace __gnu_pbds;
#include<ext/rope>
using namespace __gnu_cxx;

#define int long long
#define PI acos(-1.0)
#define eps 1e-9
#define lowbit(a) ((a)&-(a))

const int mod = 1e9+7;
int qpow(int a,int b){
	int ans=1;
	while(b){
		if(b&1)ans=(ans*a)%mod;
		a=(a*a)%mod;
		b>>=1;
	}
	return ans;
}
const int INF = 0x3f3f3f3f;
const int N = 1e6+10;
int a[100],b[100];
#define endl '\n'
signed main(){
	std::ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int _; cin>>_;
	while(_--){
		int n; cin>>n;
		vector<pair<int,int>>v;
		for(int i=1;i<=n;i++)cin>>a[i];
		int ans=0;
		for(int i=1;i<=n;i++){
			int p=-1,mi=INF;
			for(int j=i;j<=n;j++)if(a[j]<mi)mi=a[j],p=j;
			if(p==i)continue;//第i位已经是最小的就不用移了
			ans++,v.push_back(make_pair(i,p));
			int tmp=a[p];
			for(int j=p;j>=i;j--)a[j]=a[j-1];
			a[i]=tmp;
		}
		cout<<ans<<endl;
		for(int i=0;i<v.size();i++){
			cout<<v[i].first<<" "<<v[i].second<<" "<<v[i].second-v[i].first<<endl;
		}
	}
}

C

题意：

一个n*m的网格，每次可以选择一个点 ( i , j ) (i,j) (i,j) 和一个边长 d d d ，以 ( i , j ) (i,j) (i,j) 为底部，涂黑一个 V 形，现在给出一个终状态的图和一个边长最小限制K，问这个终状态是否能达到

题解：

枚举终状态每一个被涂黑的点，一直往上找边长的最大延伸，如下图所示
在这里插入图片描述

#include<iostream>
#include<sstream>
#include<string>
#include<queue>
#include<map>
#include<unordered_map>
#include<set>
#include<vector>
#include<stack>
#include <utility>
#include<list>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<iomanip>
#include<time.h>
#include<random>
using namespace std;
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/hash_policy.hpp>
using namespace __gnu_pbds;
#include<ext/rope>
using namespace __gnu_cxx;

#define int long long
#define PI acos(-1.0)
#define eps 1e-9
#define lowbit(a) ((a)&-(a))

const int mod = 1e9+7;
int qpow(int a,int b){
	int ans=1;
	while(b){
		if(b&1)ans=(ans*a)%mod;
		a=(a*a)%mod;
		b>>=1;
	}
	return ans;
}
const int INF = 0x3f3f3f3f;
const int N = 1e6+10;
string s[100];
int vis[100][100];
int n,m,k;
#define endl '\n'
signed main(){
	std::ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int _; cin>>_;
	while(_--){
		memset(vis,0,sizeof vis);
		cin>>n>>m>>k;
		for(int i=0;i<n;i++)cin>>s[i];
		for(int i=0;i<n;i++){
			for(int j=0;j<m;j++){
				if(s[i][j]=='*'){
					int len=0;
					//i,j往上延伸，但是要保证坐标合法，判断左上和右上是不是'*'
					while(i-len>=0&&j-len>=0&&j+len<m&&s[i-len][j-len]=='*'&&s[i-len][j+len]=='*')
						len++;
					len--;//因为(i,j)不计入长度，所以 len要-1
					if(len<k)continue;//往上延伸的距离没达到最小限制就不标记
					for(int u=0;u<=len;u++)
						vis[i-u][j-u]=vis[i-u][j+u]=1;
				}
			}
		}
		int flag=1;
		//如果有涂黑的点但是没被标记过，说明到达不了
		for(int i=0;i<n;i++)
			for(int j=0;j<m;j++)
				if(s[i][j]=='*'&&!vis[i][j])flag=0;
		cout<<(flag?"YES":"NO")<<endl;
	}
}

D

题意：

有 n n n 个人，第 i i i 个人的可谈话次数为 a i a_i ai​，谈话在两个人之间进行，进行一次对应的可谈话次数 − 1 -1 −1，求所有人谈话次数总和的最大值，并输出一种方案

题解：
每次必须选a最大的和其他的进行一次谈话，可以从反面想：
假如选的其中一个不是最大的，那么谈到最后，最大值可能有很多次剩余，因为能和最大值谈的都内部消化了，所以最大值必选
这里给两种写法：
优先队列选最大、次大

#include<iostream>
#include<sstream>
#include<string>
#include<queue>
#include<map>
#include<unordered_map>
#include<set>
#include<vector>
#include<stack>
#include <utility>
#include<list>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<iomanip>
#include<time.h>
#include<random>
using namespace std;
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/hash_policy.hpp>
using namespace __gnu_pbds;
#include<ext/rope>
using namespace __gnu_cxx;

#define int long long
#define PI acos(-1.0)
#define eps 1e-9
#define lowbit(a) ((a)&-(a))

const int mod = 1e9+7;
int qpow(int a,int b){
	int ans=1;
	while(b){
		if(b&1)ans=(ans*a)%mod;
		a=(a*a)%mod;
		b>>=1;
	}
	return ans;
}
const int INF = 0x3f3f3f3f;
const int N = 1e6+10;

#define endl '\n'
signed main(){
	std::ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int _; cin>>_;
	while(_--){
		int n; cin>>n;
		priority_queue<pair<int,int>>q;
		for(int i=1;i<=n;i++){
			int x; cin>>x;
			q.push(make_pair(x,i));
		}
		vector<pair<int,int>>v;
		while(1){
			pair<int,int>x=q.top(); q.pop();
			pair<int,int>y=q.top(); q.pop();
			if(x.first==0||y.first==0)break;
			x.first--,y.first--;
			v.push_back(make_pair(x.second,y.second));
			q.push(x); q.push(y);
		}
		cout<<v.size()<<endl;
		for(auto i:v)
			cout<<i.first<<" "<<i.second<<endl;
	}
}

set选最大、最小（显然没第一种好写）

#include<iostream>
#include<sstream>
#include<string>
#include<queue>
#include<map>
#include<unordered_map>
#include<set>
#include<vector>
#include<stack>
#include <utility>
#include<list>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<iomanip>
#include<time.h>
#include<random>
using namespace std;
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/hash_policy.hpp>
using namespace __gnu_pbds;
#include<ext/rope>
using namespace __gnu_cxx;

#define int long long
#define PI acos(-1.0)
#define eps 1e-9
#define lowbit(a) ((a)&-(a))

const int mod = 1e9+7;
int qpow(int a,int b){
	int ans=1;
	while(b){
		if(b&1)ans=(ans*a)%mod;
		a=(a*a)%mod;
		b>>=1;
	}
	return ans;
}
const int INF = 0x3f3f3f3f;
const int N = 1e6+10;

#define endl '\n'
signed main(){
	std::ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	srand(time(0));
	int _; cin>>_;
	while(_--){
		int n; cin>>n;
		vector<pair<int,int>>v;
		set<pair<int,int>>s;
		for(int i=1;i<=n;i++){
			int x; cin>>x;
			if(x)s.insert(make_pair(x,i));
		}
		while(s.size()>1){
			set<pair<int,int>>::iterator it=s.end();it--;
			pair<int,int>x=*s.begin();
			pair<int,int>y=*it;
			if(x.second==0||y.second==0)break;
			v.push_back(make_pair(x.second,y.second));
			x.first--,y.first--;
			s.erase(s.begin());s.erase(it);
			if(x.first>0)s.insert(x);
			if(y.first>0)s.insert(y);
		} 
		cout<<v.size()<<endl;
		for(auto i:v)cout<<i.first<<" "<<i.second<<endl;
	}
}

E1

题意：

给出1~n的排列，模仿deque，只能在头部或者尾部插入元素，求最后字典序最小的序列

题解：

比头部小放头部，否则放尾部

#include<iostream>
#include<sstream>
#include<string>
#include<queue>
#include<map>
#include<unordered_map>
#include<set>
#include<vector>
#include<stack>
#include <utility>
#include<list>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<iomanip>
#include<time.h>
#include<random>
using namespace std;
#include<ext/pb_ds/priority_queue.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/hash_policy.hpp>
using namespace __gnu_pbds;
#include<ext/rope>
using namespace __gnu_cxx;

#define int long long
#define PI acos(-1.0)
#define eps 1e-9
#define lowbit(a) ((a)&-(a))

const int mod = 1e9+7;
int qpow(int a,int b){
	int ans=1;
	while(b){
		if(b&1)ans=(ans*a)%mod;
		a=(a*a)%mod;
		b>>=1;
	}
	return ans;
}
const int INF = 0x3f3f3f3f;
const int N = 1e6+10;

#define endl '\n'
signed main(){
	std::ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int _; cin>>_;
	while(_--){
		int n; cin>>n;
		deque<int>q;
		for(int i=1;i<=n;i++){
			int x; cin>>x;
			if(i==1) q.push_front(x);
			else{
				if(x<q.front())q.push_front(x);
				else q.push_back(x);
			}
		}
		while(!q.empty()){
			cout<<q.front()<<" "; q.pop_front();
		}
		cout<<endl;
	}
}

E2

题意：

给出一个序列 a [ 1... n ] a[1...n] a[1...n] ，构造一个序列使逆序对最小（插入方式和deque一样）

题解：

为啥会有这么板子的题。。显然局部最优解就是全局最优解，用树状数组计算当前元素放头部增加的逆序对和放尾部增加的逆序对，选最小的地方插入

#include<iostream>
#include<sstream>
#include<string>
#include<queue>
#include<map>
#include<unordered_map>
#include<set>
#include<vector>
#include<stack>
#include <utility>
#include<list>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<iomanip>
#include<time.h>
#include<random>
using namespace std;
#include<ext/pb_ds/priority_queue.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/hash_policy.hpp>
using namespace __gnu_pbds;
#include<ext/rope>
using namespace __gnu_cxx;

#define int long long
#define PI acos(-1.0)
#define eps 1e-9
#define lowbit(a) ((a)&-(a))

const int mod = 1e9+7;
int qpow(int a,int b){
	int ans=1;
	while(b){
		if(b&1)ans=(ans*a)%mod;
		a=(a*a)%mod;
		b>>=1;
	}
	return ans;
}
const int INF = 0x3f3f3f3f;
const int N = 1e6+10;
int a[N],lsh[N];
int c[N],n;
void update(int x,int val){
	for(int i=x;i<=n;i+=lowbit(i)) c[i]+=val;
}
int query(int x){
	int ans=0;
	for(int i=x;i;i-=lowbit(i)) ans+=c[i];
	return ans;
}
#define endl '\n'
signed main(){
	std::ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int _; cin>>_;
	while(_--){
		cin>>n; for(int i=1;i<=n;i++)cin>>a[i],lsh[i]=a[i],c[i]=0;
		sort(lsh+1,lsh+1+n); int m=unique(lsh+1,lsh+1+n)-lsh-1;//离散化
		int ans=0;
		for(int i=1;i<=n;i++){
			int p=lower_bound(lsh+1,lsh+1+m,a[i])-lsh;
			int f=query(p-1),e=query(m)-query(p);
			//f:放头部增加的逆序对 e:放尾部增加的逆序对
			ans+=min(f,e); 
			update(p,1);
		}
		cout<<ans<<endl;
	}
}

F

题意：

给出一个01序列 a [ 1... n ] a[1...n] a[1...n] 和每次右移的距离 d d d ，每次操作把序列往右移 d d d 的距离（和B题一样），移完之后 a [ i + d ] ( 新 ) = a [ i ] ( 原 )   &   a [ i + d ] ( 原 ) a[i+d](新)= a[i](原)\ \& \ a[i+d](原) a[i+d](新)=a[i](原) & a[i+d](原)，即一个数往右移了d个距离后，它的值会变为它的原值 & 这个地方原来的值
求最小需要几次才能让整个序列为0，若无解输出-1

题解：

首先显然，对于一个点，在移动一定的次数后会回到它最初的位置，即它是在一个圈上的
在这里插入图片描述

n=5，d=2时，只有一个圈 1–>3–>5–>2–>4–>1…
在这里插入图片描述

而n=6，d=2时，有两个圈
① 1–>3–>5–>1…
② 2–>4–>6–>2…

显然，当圈里的数有0的时候，圈内的1 & 0 之后会变成 0，到一定次数都会变成 0；
圈里没有0的时候，一直循环下去，圈内的1互相 & ，到最后还是1

所以只要枚举 1 的位置，看它离所在的圈里的 0 需要移动几次就好了

注意，要加个vis数组标记圈内被走过的点，如果每个点都跑一圈会超时，如果一个点被走过，说明之前有个点经过它且比它离 0 更远，它就没必要找了

#include<iostream>
#include<sstream>
#include<string>
#include<queue>
#include<map>
#include<unordered_map>
#include<set>
#include<vector>
#include<stack>
#include <utility>
#include<list>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<iomanip>
#include<time.h>
#include<random>
using namespace std;
#include<ext/pb_ds/priority_queue.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/hash_policy.hpp>
using namespace __gnu_pbds;
#include<ext/rope>
using namespace __gnu_cxx;

#define int long long
#define PI acos(-1.0)
#define eps 1e-9
#define lowbit(a) ((a)&-(a))

const int mod = 1e9+7;
int qpow(int a,int b){
	int ans=1;
	while(b){
		if(b&1)ans=(ans*a)%mod;
		a=(a*a)%mod;
		b>>=1;
	}
	return ans;
}
const int INF = 0x3f3f3f3f;
const int N = 1e6+10;
int a[N],vis[N];
#define endl '\n'
signed main(){
	std::ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int _; cin>>_;
	while(_--){
		int n,d; cin>>n>>d;
		int ans=0,res=1;
		for(int i=0;i<n;i++)cin>>a[i],vis[i]=0;
		for(int i=0;i<n;i++){
			if(vis[i])continue;
			if(a[i]==1){
				int j=(i+d)%n,flag=1,cnt=1;
				while(a[j]==1){
					if(i==j){flag=0; break;}
					//回到了起点还没找到0，说明整个圈都是1
					vis[j]=1,cnt++,j=(j+d)%n;
				}
				if(!flag){res=0;break;}
				else ans=max(ans,cnt);
			}
		}
		if(!res){cout<<-1<<endl; continue;}
		cout<<ans<<endl;
	}
}
学不会dp QAQ
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Codeforces Round #628 (Div. 2) A~~D
01-03
A #include using namespace std; typedef long long ll; int main(){ int t; cin>>t; while(t--){ ll x; cin>>x; cout<<1>>t; while(t--){ st.clear(); ll n; cin >>n; ll re
Codeforces Round #834 (Div. 3) A~E题解
weixin_63927680的博客
11-19 1505
题目：D. Make It Round 题意： 给定一个n和m，k的取值范围在1~m,求出最大的n*k并满足有最多的末尾0。首先10 = 2*5,所以要有末尾0，首先必须出现2和5，所以我们先分解n，看一下n有多少个5，多少个2，假设n分解之后有4个2，1个5，它本身1个2和1个5相乘等于10，所以剩下3个2，那么此时，k就先补3个5，既5*5*5 = 125，如果此时k还没有超出范围的话，就继续乘10，如果乘10后超出范围了，就在1~9之间相乘，找到最大的那个k。如果k在补5的时候超出
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
一个长度为n的数组，为删除一些数后，剩下的数能否构成长度大于3的回文数组 思路： 只要能找到两个相等的数，且他们的间距大于2即可 o(n^2)的暴力就能过 比赛时写了一个o(n)的 就是把所有相等的数放到一个vector里，...
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 ...#define rep(i,a,b) for(int i=a;i=b;i--) typedef long long l
Codeforces Round #479 (Div. 3) E. Cyclic Components
01-03
E. Cyclic Components 题目链接-E. Cyclic Components 题目大意 给你nnn个点和mmm条边，求所构成图中单圈环的个数 ...并查集并查集并查集 很明显单圈环每个点的度都为222，所以我们可以用数组cnt[]记录每个点的度，...
【18】输出字符菱形
2301_78786609的博客
07-19 403
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 352
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 578
AtCoder Beginner Contest 363 ABCDE
算法题目整合5
最新发布
qq_62571233的博客
07-23 657
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 166
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
插入和选择排序
c23856的博客
07-20 469
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
2024.7.19 刷题总结
TheJustice_的博客
07-19 260
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 275
完全二叉树的节点个数-递归
python实现图像缩放算法
qq_42568323的博客
07-20 357
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
傻瓜图解 -- 算法刷题之路之链表初探（八 ）旋转链表
aoyuanyuan0921的博客
07-19 196
今天来学习的算法题是leecode61旋转链表，是一道简单的入门题，话不多说！原子本来写了一大推书面解释！我直接上图，如果有疑问的话私信我交流一下！
算法第十一天：leetcode707.设计链表
m0_75068978的博客
07-19 1459
的链接如下表所示，您可直接复制下面网址进入力扣学习，在观看下面的内容之前一定要先做一遍哦，这样才能印象深刻！题目描述：你可以选择使用单链表或者双链表，设计并实现自己的链表。val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果是双向链表，则还需要属性prev以指示链表中的上一个节点。假设链表中的所有节点下标从开始。实现index-1valvalvalindexindexindexindex// 链表变为 1->2->3// 返回 2。
【刷题汇总 -- 压缩字符串(一)、chika和蜜柑、 01背包】
m0_69455439的博客
07-19 1145
今日刷题汇总day018 -- 压缩字符串(一)、chika和蜜柑、 01背包
算法——滑动窗口（day5）
fax_player的博客
07-20 832
（上一题是通过缩小窗口来求长度最小，所以每一次缩小都有可能得到最小长度）（而本题是求最大连续长度，只需要在去除所有重复项后计算就行了）
codeforces round #828 (div. 3)
06-06
好的，以下是关于Codeforces Round #828 (Div. 3)的一些信息： Codeforces Round #828 (Div. 3)是Codeforces网站上的一场编程竞赛，属于Div. 3级别的比赛。该比赛于2022年3月1日 15:35 (UTC)开始，比赛时长为2个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值