2023牛客寒假算法基础集训营2个人补题 A B C D E F H J L K

已于 2023-01-19 18:22:00 修改
阅读量202 收藏
点赞数
分类专栏： 2023寒假牛客 文章标签： 算法 c语言 深度优先
于 2023-01-19 00:23:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61126523/article/details/128731774
版权

2023牛客寒假算法基础集训营2个人补题 A B C D E F H J L

A B

题意

给一个n，两个区间，问区间内各取一个数加起来为n的对数有多少。

思路

直接说通解O（1）的做法，我们对于两个区间a，A，可以对每个区间对应的求出一个区间，使得在a区间内的任意一个数都可以在b区间内找到一个数，最终，我们只需要求出b与A的交集和B与a交集的最大值即可。

代码

#include<bits/stdc++.h>
#define int long long
#define endl '\n'
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
using namespace std;
const int INF = 0x3f3f3f3f3f3f3f3f;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
typedef pair<int, int> PII;
int n;
int a[N];

void solve() {
	int l1, r1, l2, r2;
	int res1=0,res2=0;
	cin >> n >> l1 >> r1 >> l2 >> r2;
	int l=n-r1,r=n-l1;
	if(l<l2) {
		if(r<l2) {
			res1=0;
		}
		else if(r==l2){
			res1=1;
		}
		else {
			if(r<=r2) res1=r-l2+1;
			else res1=r2-l2+1;
		}
	}
	else if(l==l2) {
		if(r==l2) res1=1;
		else{
			res1=min(r-l2+1,r2-l2+1);
		}
	}
	else {
		if(l<r2) {
			res1=min(r2-l+1,r-l+1);
		}
		else if(l==r2) {
			res1=1;
		}
		else {
			res1=0;
		}
	}
	l=n-r2,r=n-l2;
	if(l<l1) {
		if(r<l1) {
			res2=0;
		}
		else if(r==l1){
			res2=1;
		}
		else {
			if(r<=r1) res2=r-l1+1;
			else res2=r1-l1+1;
		}
	}
	else if(l==l1) {
		if(r==l1) res1=1;
		else{
			res2=min(r-l1+1,r1-l1+1);
		}
	}
	else {
		if(l<r1) {
			res2=min(r1-l+1,r-l+1);
		}
		else if(l==r1) {
			res2=1;
		}
		else {
			res2=0;
		}
	}
	cout<<max(res1,res2)<<"\n";
}

signed main() {
	IOS;
	int t = 1;
	cin >> t;
	for (int i = 1; i <= t; i++) {
		solve();
	}
}

C

题意

给m个区间，询问是否能在给定m个区间（区间不能相同），有多少对数能够满足相加等于给定n。

思路

直接通过差分+前缀和的方式统计在m个区间内每个数出现的次数，然后再直接枚举每个数求和，最后去重时就相当于是B题，只是给定的区间是相同的，减掉之后就是答案。

代码

#include<bits/stdc++.h>
#define int long long
#define endl '\n'
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
using namespace std;
const int INF = 0x3f3f3f3f3f3f3f3f;
const int N = 1e6 + 10;
const int mod = 998244353;
typedef pair<int, int> PII;
int n,m;
int a[N];

int d[N+10];
int sum[N+10];
vector<PII>v;
void solve() {
	cin>>n>>m;
	for(int i=1;i<=m;i++) {
		int l,r;
		cin>>l>>r;
		v.push_back({l,r});
		d[l]++;
		d[r+1]--;
	}
	for(int i=1;i<=N;i++) {
		sum[i]=sum[i-1]+d[i];
	}
	int res=0;
	for(int i=1;i<=2e5;i++) {
		res=(res+sum[i]*sum[n-i]%mod)%mod;
	}
	for(int i=0;i<m;i++) {
		int l1=v[i].first,r1=v[i].second;
		int l2=l1, r2=r1;
		int res1=0,res2=0;
		int l=n-r1,r=n-l1;
		if(l<l2) {
			if(r<l2) {
				res1=0;
			}
			else if(r==l2){
				res1=1;
			}
			else {
				if(r<=r2) res1=r-l2+1;
				else res1=r2-l2+1;
			}
		}
		else if(l==l2) {
			if(r==l2) res1=1;
			else{
				res1=min(r-l2+1,r2-l2+1);
			}
		}
		else {
			if(l<r2) {
				res1=min(r2-l+1,r-l+1);
			}
			else if(l==r2) {
				res1=1;
			}
			else {
				res1=0;
			}
		}
		l=n-r2,r=n-l2;
		if(l<l1) {
			if(r<l1) {
				res2=0;
			}
			else if(r==l1){
				res2=1;
			}
			else {
				if(r<=r1) res2=r-l1+1;
				else res2=r1-l1+1;
			}
		}
		else if(l==l1) {
			if(r==l1) res1=1;
			else{
				res2=min(r-l1+1,r1-l1+1);
			}
		}
		else {
			if(l<r1) {
				res2=min(r1-l+1,r-l+1);
			}
			else if(l==r1) {
				res2=1;
			}
			else {
				res2=0;
			}
		}
		res=(res+mod-max(res1,res2))%mod;
	}
	cout<<res<<"\n";
}

signed main() {
	IOS;
	int t = 1;
	//cin >> t;
	for (int i = 1; i <= t; i++) {
		solve();
	}
}

D

题意

给一棵树，给n个能量，每个能量只能放在一个节点上，选择一个能量，再选择一个没有能量球树节点 x，把刚刚选择的能量放置在节点 x上。在这之后，能获得以 x 为根的子树中的所有能量球的能量 (包括节点 x 的能量球能量)。在放置完所有能量球后，可能获得的总能量最多是多少？

思路

稍微看一下就会发现其实就是按照深度排序放置一定最大。

代码

#include<bits/stdc++.h>
#define int long long
#define endl '\n'
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
using namespace std;
const int INF = 0x3f3f3f3f3f3f3f3f;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
typedef pair<int, int> PII;
int n;
int a[N];

vector<int>g[N];
map<int,vector<int>>dep;
void dfs(int u,int d) {
	dep[d].push_back(u);
	for(auto v:g[u]) {
		dfs(v,d+1);
	}
}
void solve() {
	cin>>n;
	for(int i=2;i<=n;i++) {
		int u,v=i;
		cin>>u;
		g[u].push_back(v);
	}
	for(int i=1;i<=n;i++) {
		cin>>a[i];
	}
	dfs(1,1);
	sort(a+1,a+n+1);
	int res=0;
	int id=1;
	for(auto [i,_]:dep) {
		for(int j=id;j<id+_.size();j++) {
			//cout<<a[id]<<" "<<i<<"\n";
			res+=a[j]*i;
		}
		id=id+_.size();
		//cout<<id<<"\n";
	}
	cout<<res<<"\n";
}

signed main() {
	IOS;
	int t = 1;
//	cin >> t;
	for (int i = 1; i <= t; i++) {
		solve();
	}
}

E

题意

f ( x ) = ⌊ n x ⌋ + x − 1 f(x)=\lfloor \frac{n}{x} \rfloor+x−1 f(x)=⌊xn​⌋+x−1她想在区间 [L,R] 中找到一个最小的整数 t，使函数 f(t) 的值最小。

思路

其实是一个诈骗题，因为只能取整数，函数其实就变成了 f ( x ) = ⌊ n x + x − 1 ⌋ f(x)=\lfloor \frac{n}{x} +x-1 \rfloor f(x)=⌊xn​+x−1⌋，那么画图就会发现，其实极值就是在 s q r t ( n ) sqrt(n) sqrt(n)附近取，更细一点就会发现值不是向下取整就是向上取整，所以只需要讨论给定区间和最值区间的关系，最终二分就行了，训练时错的地方在讨论一类的时候忘记了其实其他位置有可能更小，不一定就是右值。

代码

#include <bits/stdc++.h>
#define int long long
#define endl '\n'
#define IOS ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
using namespace std;
const int INF = 0x3f3f3f3f3f3f3f3f;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
typedef pair<int, int> PII;
int n, k;
int a[N];

int f(int x) { return  n / x + x - 1; }
void solve() {
  int l, r;
  cin >> n >> l >> r;
  int mi = sqrt(1.0 * n);
  if (f(mi + 1) < f(mi)) mi++;
  if (mi > r) {
      int ll = l, rr = r;
    while (ll < rr) {
      int mid = ll + rr >> 1;
      if (f(mid) > f(r))
        ll = mid + 1;
      else
        rr = mid;
    }
    cout << ll<< "\n";
  } else if (mi < l) {
    cout << l << "\n";
  } else {
    int ll = l, rr = mi;
    while (ll < rr) {
      int mid = ll + rr >> 1;
      if (f(mid) > f(mi))
        ll = mid + 1;
      else
        rr = mid;
    }
    cout << ll<< "\n";
  }
}

signed main() {
  IOS;
  int t = 1;
  cin >> t;
  for (int i = 1; i <= t; i++) {
    solve();
  }
}

F

题意

给一个地图，有些地方有障碍物，其他地方都放着一枚金币，问反复走最多可以拿到多少枚。

思路

很典的题，就只要找到从起点开始和从终点开始能到达的点有哪些，dfs有可能超时，bfs完美解决（）

代码

#include<bits/stdc++.h>
#define int long long
#define endl '\n'
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
using namespace std;
const int INF = 0x3f3f3f3f3f3f3f3f;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
typedef pair<int, int> PII;
int n,k;
int a[N];

int g[N][5];
int dx[]={1,0};
int dy[]={0,1};
int dx1[]={-1,0};
int dy1[]={0,-1};
bool f;
void bfs1(int x,int y) {
	queue<PII>q;
	q.push({x,y});
	while(q.size()) {
		int xx=q.front().first;
		int yy=q.front().second;
		q.pop();
		if(g[xx][yy]!=0) {
			if(g[xx][yy]!=2) {
				g[xx][yy]=2;
				for(int i=0;i<2;i++) {
					q.push({xx+dx[i],yy+dy[i]});
				}
			}
		}
	}
}
int vis[N][5];
void bfs2(int x,int y) {
	queue<PII>q;
	q.push({x,y});
	while(q.size()) {
		int xx=q.front().first;
		int yy=q.front().second;
		q.pop();
		if(vis[xx][yy]!=0) {
			if(vis[xx][yy]!=2) {
				vis[xx][yy]=2;
				for(int i=0;i<2;i++) {
					q.push({xx+dx1[i],yy+dy1[i]});
				}
			}
		}
	}
}
void solve() {
	cin>>n>>k;
	f=0;
	for(int i=1;i<=n;i++) {
		g[i][1]=g[i][2]=g[i][3]=1;
		vis[i][1]=vis[i][2]=vis[i][3]=1;
	}
	for(int i=1;i<=k;i++) {
		int x,y;
		cin>>x>>y;
		g[x][y]^=1;
		vis[x][y]^=1;
	}
	bfs1(1,1);
	bfs2(n,3);
	int res=0;
	for(int i=1;i<=n;i++) {
		for(int j=1;j<=3;j++) {
			if(g[i][j]==2&&vis[i][j]==2) res++;
		}
	}
//	  cout<<"##############\n";
//	  for(int i=1;i<=n;i++) {
//	      for(int j=1;j<=3;j++) {
//	          cout<<g[i][j]<<" ";
//	      }
//	      cout<<"\n";
//	  }
//	  cout<<"##############\n";
//	  cout<<"##############\n";
//	  for(int i=1;i<=n;i++) {
//		  for(int j=1;j<=3;j++) {
//			  cout<<vis[i][j]<<" ";
//		  }
//		  cout<<"\n";
//	  }
//	  cout<<"##############\n";
	cout<<max(0LL,res-1)<<"\n";
}

signed main() {
	IOS;
	int t = 1;
	cin >> t;
	for (int i = 1; i <= t; i++) {
		solve();
	}
}

H

题意

有一个长度为 n 的序列 a，把这个序列划分成 k 个非空子序列。定义序列的值为这个序列中只出现一次的数字的个数。对于 k = 1 … n k=1 \ldots n k=1…n，把序列 a 划分成 k 个非空子序列后，所有子序列的值的和最大是多少。

思路

统计一下每个数字出现的次数，然后排个序，先写个暴力程序就会发现，当分成i段的时候出现次数小于i的贡献为i-1，否则就是出现的次数，故可以直接用二分做复杂度 O ( n l o g n ) O(nlogn) O(nlogn)

代码

#include<bits/stdc++.h>
#define int long long
#define endl '\n'
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
using namespace std;
const int INF = 0x3f3f3f3f3f3f3f3f;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
typedef pair<int, int> PII;
int n;
int a[N];
int sum[N];
void solve() {
	cin>>n;
	map<int,int>mp;
	for(int i=1;i<=n;i++) {
		cin>>a[i];
		mp[a[i]]++;
	}
	vector<int>v;
	for(auto [i,j]:mp) {
		v.push_back(j);
	}
	sort(v.begin(),v.end());
	for(int i=1;i<=v.size();i++) {
		sum[i]=sum[i-1]+v[i-1];
	}
	vector<int>res;
	res.resize(n+10);
	//for(int i=mp.size();i<=n;i++) res[i]=n;
	for(int i=1;i<=n;i++) {
		//		for(auto j:v) {
		//			if(i>=j)res[i]+=j;
		//			else {
		//				res[i]+=i-1; 
		//			}
		//		}
		auto k=upper_bound(v.begin(),v.end(),i);
		//cout<<v.end()-k<<' '<<k-v.begin()<<"*********************\n";
        res[i]=(i-1)*(v.end()-k)+sum[k-v.begin()]-sum[0];
        //cout<<sum[1]<<" "<<sum[2]<<"\n";
	}
	for(int i=1;i<=n;i++) cout<<res[i]<<"\n";
}

signed main() {
	IOS;
	int t = 1;
	cin >> t;
	for (int i = 1; i <= t; i++) {
		solve();
	}
}

J

题意

定义 M x A b ( i , j ) = m a x ( ∣ a i − a j ∣ , ∣ a i + a j ∣ ) MxAb(i,j)=max(∣ai−aj∣,∣ai+aj∣) MxAb(i,j)=max(∣ai−aj∣,∣ai+aj∣)，求下列式子 ∑ i = 1 n ∑ j = 1 n M x A b ( i , j ) \sum_{i=1}^{n} \sum_{j=1}^{n} MxAb(i,j) ∑i=1n​∑j=1n​MxAb(i,j)

思路

稍微分类讨论一下就发现其实是一个固定结论，答案就是 2 n ˙ ∑ ˙ i = 1 n ∣ a i ∣ 2 \dot n \dot \sum_ {i=1}^n |ai| 2n˙∑˙​i=1n​∣ai∣

代码

#include<bits/stdc++.h>
#define int long long
#define endl '\n'
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
using namespace std;
const int INF = 0x3f3f3f3f3f3f3f3f;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
typedef pair<int, int> PII;
int n;
int a[N];

void solve() {
	cin>>n;
	for(int i=1;i<=n;i++) cin>>a[i];
	int res=0;
	for(int i=1;i<=n;i++) {
		res+=2*n*abs(a[i]);
	}
	cout<<res<<"\n";
}

signed main() {
	IOS;
	int t = 1;
	cin >> t;
	for (int i = 1; i <= t; i++) {
		solve();
	}
}

L

题意

有一个长度为 n 的序列 a 和一个正整数 p 。

对于所有 x = 0 … p − 1 x=0 \ldots p-1 x=0…p−1，求三元组 [i,j,k] 的数量，满足：

  • ** i ≠ j i \ne j i=j and i ≠ k i \ne k i=k and j ≠ k j \ne k j=k **

  • ** ( a i ⋅ a j + a k ) ≡ x  (mod  p ) (a_i \cdot a_j + a_k) \equiv x \text{ (mod } p) (ai​⋅aj​+ak​)≡x (mod p) **

思路

预处理一下所有 a i a ˙ j a_i \dot a_j ai​a˙j​模p的数字，然后统计一下，最终再根据这个去枚举k的值，最后去个重就结束了。

代码

#include<bits/stdc++.h>
#define endl '\n'
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
using namespace std;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
typedef pair<int, int> PII;
int n,m;
int a[5050];
int num[5050];
int res[5050];
void solve() {
	int p;
	cin>>n>>p;
	for(int i=1;i<=n;i++) {
		cin>>a[i];
		a[i]=a[i]%p;
	}
	for(int i=1;i<=n;i++) {
		for(int j=1;j<=n;j++) {
			if(i!=j) {
				num[a[i]*a[j]%p]++;
				res[(a[i]*a[j]%p+a[i])%p]--;
				res[(a[i]*a[j]%p+a[j])%p]--;
			}
		}
	}
	for(int i=0;i<p;i++) {
		for(int j=1;j<=n;j++) {
			res[(i+a[j])%p]+=num[i];
		}
	}
    for(int i=0;i<p;i++) assert(res[i]>=0);
	for(int i=0;i<p;i++) cout<<res[i]<<" \n"[i==p-1];
}

signed main() {
	IOS;
	int t = 1;
	//cin >> t;
	for (int i = 1; i <= t; i++) {
		solve();
	}
}

K

题意

给一个图，有q次询问，每次给一个点集，问点集中有多少条边是存在于给定图中。

思路

难点在于想到复杂度是 n s q r t ( n ) nsqrt(n) nsqrt(n)，想到之后就可以发现就可以用根号分治来分类讨论，或者直接将无向图根据度数大小关系重新变成一个有向图，暴力即可，两种方法本质其实一样，难的在于想到根据 s q r t ( n ) sqrt(n) sqrt(n)分类讨论。

代码

根号分治

#include <bits/stdc++.h>
#define int long long
#define endl '\n'
#define IOS ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define fi first
#define sc second
using namespace std;
const int INF = 0x3f3f3f3f3f3f3f3f;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
typedef pair<int, int> PII;
int n, m, q;
int a[N];

vector<int> g[N], g1[N];
vector<PII> ed;
vector<int> s(N);
void solve() {
  cin >> n >> m >> q;
  for (int i = 1; i <= m; i++) {
    int u, v;
    cin >> u >> v;
    ed.push_back({u, v});
    g[v].push_back(u);
    g[u].push_back(v);
  }
  int st = sqrt(n);
  for (int i = 0; i < m; i++) {
    int u = ed[i].fi, v = ed[i].sc;
    if (g[u].size() > st && g[v].size() > st) {
      g1[u].push_back(v);
      g1[v].push_back(u);
    }
  }
  while (q--) {
    int k;
    cin >> k;
    int ans = 0;
    vector<int> v[2];
    for (int i = 1; i <= k; i++) {
      int u;
      cin >> u;
      s[u] = 1;
      if (g[u].size() > st)
        v[1].push_back(u);
      else
        v[0].push_back(u);
    }
    for (auto u : v[0]) {
      for (auto x : g[u]) {
        if (s[x]) {
          if (g[x].size() <= st) {
            if (x > u) ans++;
          } else
            ans++;
        }
      }
    }
    for (auto u : v[1]) {
      for (auto x : g1[u]) {
        if (s[x]) if (x > u) ans++;
      }
    }
    for (auto u : v[0]) {
      s[u] = 0;
    }
    for (auto u : v[1]) {
      s[u] = 0;
    }
    cout << ans << "\n";
  }
}

signed main() {
  IOS;
  int t = 1;
  // cin >> t;
  for (int i = 1; i <= t; i++) {
    solve();
  }
}

重新建图

#include <bits/stdc++.h>
#define int long long
#define endl '\n'
#define IOS ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define fi first
#define sc second
using namespace std;
const int INF = 0x3f3f3f3f3f3f3f3f;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
typedef pair<int, int> PII;
int n, m, q;
int a[N];

vector<int> g[N];
int d[N];
vector<PII> ed;
vector<int> st(N);
void solve() {
  cin >> n >> m >> q;
  for (int i = 1; i <= m; i++) {
    int u, v;
    cin >> u >> v;
    ed.push_back({u, v});
    d[u]++;
    d[v]++;
  }
  for (int i = 0; i < m; i++) {
    int u = ed[i].fi, v = ed[i].sc;
    if (d[u] > d[v])
      g[v].push_back(u);
    else
      g[u].push_back(v);
  }
  while (q--) {
    int k;
    cin >> k;
    int ans = 0;
    vector<int> v;
    for (int i = 1; i <= k; i++) {
      int u;
      cin >> u;
      st[u] = 1;
      v.push_back(u);
    }
    for (int i = 0; i < k; i++) {
      for (auto j : g[v[i]]) {
        if (st[j]) ans++;
      }
    }
    for (auto u : v) {
      st[u] = 0;
    }
    cout << ans << "\n";
  }
}

signed main() {
  IOS;
  int t = 1;
  // cin >> t;
  for (int i = 1; i <= t; i++) {
    solve();
  }
}
ablity_66
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2023牛客OI赛前集训营-提高组（第三场）题解
10-14
2023牛客OI赛前集训营-提高组（第三场）题解 本资源摘要信息是关于2023牛客OI赛前集训营-提高组（第三场）题解的详细解读。下面将对每道题的解法进行详细的解释。 T1-填数游戏 这一题的思路是贪心算法。由于大数...
2020牛客暑期多校集训营第三场题解.pdf
01-20
题解
针对piix4_smbus**host smbus controller not enabled的解决办法（详细步骤总结）
qq_28319939的博客
08-02 6923
第一次装ubuntu16.04遇到了piix4_smbus**host smbus controller not enabled这个问题，导致一直无法进入ubuntu desktop。在网上查询了各种解决办法之后发现同一种解决方法写法各异，对于新手来说缺少一个步骤，就很难理解，因此自己把详细的解决流程总结下来，希望与诸君共同学习进步吧，第一次写，就按照自己的格式来吧。 难点：初学Linux的时候对vim命令不了解，是这个方法的最大难点。 步骤1：无法进入桌面操作，就按ctrl+alt+F1~F6进入命令
2023牛客寒假算法基础集训营1个人补题 A C D H K L M E F G B
m0_61126523的博客
01-16 127
【代码】2023牛客寒假算法基础集训营1个人补题 A C D H K L M E F G B。
2023牛客寒假算法基础集训营2 赛时思路+正解
qq_52358098的博客
01-18 1961
青大的一个娱乐训练赛罢了
2023牛客寒假算法基础集训营5题解 4/12
Hey1_的博客
02-01 306
2023牛客寒假算法基础集训营5题解 < 已写：A 、B 、H 、 K >
2023牛客寒假算法基础集训营3个人补题 A B C D E F G I K
m0_61126523的博客
01-20 164
【代码】2023牛客寒假算法基础集训营3个人补题 A B C D E F G I K。
2021牛客寒假算法基础集训营1（A B C D E F H I J）
Tan_Yuu的博客
02-03 470
比赛链接：这里 OP 个人能力有限，有的题目实在知识点欠缺太多，可以参照一下其他大佬的全题解。 &感谢ph大佬的全程指导。 A 串 递推。 思路 我们可以先算出长度为 1,2,…,n 的合法串的数量，再进行累加。 介于数据量（2 < n <= 106)，通过排列组合来求几乎不可能，单纯打表可能就需要几十分钟。 接下来就是具体的递推过程： 假设长度为 n 的合法字符串有 An 个。长度为 n + 1 的字符串中的前 n 项可以分为两种情况：合法的与非法的。 ——对于前 n 项为合法字符串的
2023牛客寒假算法基础集训营4 赛时思路+正解
qq_52358098的博客
01-30 903
也许是qdu acmer写的最后一篇寒假训练营题解。
2023牛客寒假算法基础集训营4-无HIK
m0_63289912的博客
02-25 210
A：清楚姐姐学信息论结论是越靠近e进制效率越高（第一次知道）当时现场推的，证明如下即证x^y>y^x两边同时取对数，移位得即证lnx/x的单调性求导即可发现是在e处对整数讨论23附近发现是3,1不参与讨论，3以后是递减。故取3。
2023牛客寒假算法基础集训营1(11/13)
eyuhaobanga的博客
01-16 639
2023牛客寒假算法基础集训营1
2020牛客多校暑期集训营第一场题解.pdf
01-20
2020牛客多校暑期集训营第一场题解.pdf
offer_牛客_剑指offer_剑指Offer算法题编程代码解析汇总_
10-02
实现了牛客凭条上的所有剑指offer的算法题，并且在每个算法中进行了详尽的解释和说明。
算法力扣刷题记录六【203移除链表元素】
danaaaa的博客
06-21 1071
删除链表节点
189.二叉树：将有序数组转换为二叉搜索树（力扣）
weixin_63779802的博客
06-21 207
代码使用了递归的方法。主要思路是首先找到数组的中间元素，然后以这个中间元素作为根节点，递归地在数组中构建左右子树。左子树包含数组中所有小于中间元素的元素，右子树包含所有大于中间元素的元素。这个算法的时间复杂度是 O(n)，其中 n 是数组中元素的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。
【算法】二叉树 - 理论基础
最新发布
Nanki_的博客
06-23 1116
int val;
面试+算法之回文(Java)：验证回文串、回文数、最长回文子串、回文链表、分割成回文串、最短回文串、
lonelymanontheway的博客
06-20 520
验证回文串、回文数、最长回文子串、分割成回文串、最短回文串、回文链表
牛客竞赛算法入门班怎么样
01-14
牛客竞赛算法入门班是一个针对算法竞赛初学者的培训班。它提供了系统的课程和习题，帮助学员掌握算法竞赛中常用的算法和数据结构，并提高解题能力。通过参加这个培训班，学员可以学到以下内容： 1. 算法基础知识：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值