2023年ICPC合肥站 补题记录

已于 2024-08-26 14:20:13 修改
阅读量971 收藏 19
点赞数 29
分类专栏： 2024暑假训练记录 xcpc题解 文章标签： 算法
于 2024-08-18 22:15:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dhxbshbdjzxy/article/details/141291686
版权

文章目录

B. Queue Sorting（计数dp）

#include <bits/stdc++.h>

using namespace std;

// #define int long long
#define double long double
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<PII, int> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 2e5 + 10;
const int maxn = 1e6;
const int MAXN = 100;
const int mod = 998244353;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int n; cin >> n;
	vector<int> a(n + 1), pre(n + 1);
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i];
		pre[i] = pre[i - 1] + a[i];
	}

	vector<vector<int>> c(pre[n] + 1, vector<int>(pre[n] + 1));
	c[0][0] = 1;
	for (int i = 1; i <= pre[n]; i++)
	{
		c[i][0] = 1;
		for (int j = 1; j <= i; j++)
		{
			c[i][j] = (c[i][j] + c[i - 1][j - 1] + c[i - 1][j]) % mod;
		}
	}

	vector<vector<int>> dp(n + 1, vector<int>(pre[n] + 1));
	dp[0][0] = 1;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j <= pre[i]; j++) // 第i个位置最末的下降子序列开头
		{
			if (dp[i][j])
			{
				dp[i + 1][j] = (dp[i + 1][j] + dp[i][j]) % mod;
				for (int k = j + 1; k < pre[i + 1]; k++) // 把i+1都放在[j+1,k]
				{
					// 枚举多少i+1放在末尾
					int minn = max(0, a[i + 1] - (k - j));
					int maxx = min(a[i + 1] - 1, pre[i + 1] - k - 1);
					for (int x = minn; x <= maxx; x++)
						dp[i + 1][k] = (dp[i + 1][k] + (1ll * dp[i][j] * c[k - j - 1][a[i + 1] - x - 1] % mod)) % mod;
				}
			}
		}
	}

	int ans = 0;
	for (int i = 0; i <= pre[n]; i++) ans = (ans + dp[n][i]) % mod;
	cout << ans << '\n';
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	// cin >> t;
	while (t--)
	{
		solve();
	}
	return 0;
}

C. Cyclic Substrings（回文自动机）

  • 将原字符串复制一遍，防止重复，结尾大于 n n n 的才加入cnt中
  • 之后就是回文自动机的板子
#include <bits/stdc++.h>

using namespace std;

// #define int long long
#define double long double
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<PII, int> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 6e6 + 10;
const int maxn = 1e6;
const int MAXN = 100;
const int mod = 998244353;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

	int ans = 0;
/*
---------------回文自动机PAM---------------

- 传入字符串下标从0开始
- 本质不同的回文子串个数
- 所有回文子串个数
- 每种回文串出现的次数 cnt（需要get_cnt）
- 每种回文串的长度 len
- 以下标 i 为结尾的回文串的个数 sed
- 每个回文串在原串中出现的起始位置 record
*/

struct PAM {
	string s;
	int n;
	int nxt[N][10];
	int fail[N]; // 当前节点最长回文后缀的节点
	int len[N]; // 当前节点表示的回文串的长度
	int cnt[N]; // 当前节点回文串的个数， 在getcnt后可得到全部
	// int sed[N]; // 以当前节点为后缀的回文串的个数
	// int record[N]; // 每个回文串在原串中出现的位置
	int tot; // 节点个数
	int last; // 上一个节点
	void init()
	{
		tot = 0;
		for (int i = 0; i < N; i ++ )
		{
			fail[i] = cnt[i] = len[i] = 0;
			for (int j = 0; j < 10; j ++ ) nxt[i][j] = 0;
		}
	}
	int newnode(int lenx)
	{
		for (int i = 0; i < 26; i++)
		nxt[tot][i] = 0;
		cnt[tot] = 0;
		len[tot] = lenx;
		return tot;
	}
	void build(string ss)
	{
		tot = 0;
		newnode(0);
		tot = 1, last = 0;
		newnode(-1);
		fail[0] = 1;
		n = ss.size();
		s = " " + ss;
	}
	int getfail(int x, int n)
	{
		while (n - len[x] - 1 <= 0 || s[n - len[x] - 1] != s[n])
			x = fail[x];
		return x;
	}
	void insert(char cc, int pos, int op)
	{
		int c = cc - '0';
		int p = getfail(last, pos);
		if (!nxt[p][c])
		{
			tot++;
			newnode(len[p] + 2);
			fail[tot] = nxt[getfail(fail[p], pos)][c];
			len[tot] = len[p] + 2;
			// sed[tot] = sed[fail[tot]] + 1;
			nxt[p][c] = tot;
		}
		last = nxt[p][c];
		cnt[last] += op;
		// record[last] = pos;
	}
	void insert()
	{
		for (int i = 1; i <= n; i++)
		{
			if (i <= n / 2) insert(s[i], i, 0);
			else insert(s[i], i, 1);
		}
	}
	void get_cnt()
	{
		for (int i = tot; i > 0; i -- )
		{
			cnt[fail[i]] += cnt[i];
			if (i >= 2 && len[i] <= n / 2)
			{
				ans = (ans + 1ll * cnt[i] * cnt[i] % mod * len[i] % mod) % mod;
			}
		}
	}
	int get_diff_cnt() // 本质不同的回文子串个数
	{
		return tot - 1;
	}
	int get_all_cnt() // 所有回文子串个数（本质相同的多次计算）
	{
		int sum = 0;
		get_cnt();
		for (int i = 2; i <= tot; i ++ ) sum += cnt[i];
		return sum;
	}
} pam;
//------------------------------------

void solve()
{
	int n; cin >> n;
	string s; cin >> s;
	s = s + s;
	pam.init();
	pam.build(s);
	pam.insert();
	pam.get_cnt();
	cout << ans << '\n';
}

signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    int t = 1;
    // cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

E. Matrix Distances（前缀和）

  • 分别统计横坐标和纵坐标的贡献，统计方式是用前缀和
  • 坑点是需要离散化，直接map会T
#include <bits/stdc++.h>

using namespace std;

#define int long long
#define double long double
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e3 + 10;
const int maxn = 1e6;
const int MAXN = 100;
const int mod = 998244353;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

int idx;
int g[N][N];

void solve()
{
	int n, m; cin >> n >> m;
	vector<int> tt;
	map<int, int> mp;
	for (int i = 1; i <= n; i ++ )
	{
		for (int j = 1; j <= m; j ++ )
		{
			cin >> g[i][j];
			tt.push_back(g[i][j]);
		}
	}
	sort(tt.begin(), tt.end());
	tt.erase(unique(tt.begin(), tt.end()), tt.end());
	for (int i = 0; i < tt.size(); i ++ )
	{
		mp[tt[i]] = i + 1;
	}
	vector<vector<int>> x(tt.size() + 10), y(tt.size() + 10);
	for (int i = 1; i <= n; i ++ )
	{
		for (int j = 1; j <= m; j ++ )
		{
			int tmp = mp[g[i][j]];
			x[tmp].push_back(i);
			y[tmp].push_back(j);
		}
	}

	int ans = 0;
	for (auto t : x)
	{
		if (t.size() <= 1) continue;
		sort(t.begin(), t.end());
		vector<int> pre(t.size() + 2);
		pre[0] = t[0];
		for (int i = 1; i < t.size(); i ++ )
		{
			pre[i] = pre[i - 1] + t[i];
			ans += t[i] * (i + 1) - pre[i];
		}
	}
	for (auto t : y)
	{
		if (t.size() <= 1) continue;
		sort(t.begin(), t.end());
		vector<int> pre(t.size() + 2);
		pre[0] = t[0];
		for (int i = 1; i < t.size(); i ++ )
		{
			pre[i] = pre[i - 1] + t[i];
			ans += t[i] * (i + 1) - pre[i];
		}
	}
	cout << ans * 2 << '\n';
}

signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    int t = 1;
    // cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

F. Colorful Balloons（签到）

  • 没看题，偷一下队友的码
#include<iostream>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<vector>
#include<map>
#include<algorithm>
#include<queue>
#include <iomanip>
#include<random>
#include<set>

using namespace std;
typedef long long LL;
typedef __int128 i128;
typedef unsigned long long ULL;
typedef double db;

void Asuka()
{
	int n;
	map<string , int>mp;
	cin >> n;
	for(int i = 1 ; i <= n ; i ++){
		string s;
		cin >> s;
		mp[s] ++;
	}
	for(auto t : mp){
		if(t.second > n / 2){
			cout << t.first << '\n';
			return;
		}
	}
	cout << "uh-oh\n";
	return;
}	

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);

	int t = 1;
	// cin >> t;
	while(t --){
		Asuka();
	}
	return 0;
}

G. Streak Manipulation（二分+dp）

  • 首先这种最大最小值的问题很容易想到二分，我们二分最终答案，也就是第 k 长连续 1 子段的最大长度
  • 怎么实现 check 函数呢，看到 k 最大为 5 ，考虑能不能用dp
  • dp[i][j][0/1] 表示前 i 个字符中有 j 段长度大于等于 mid 的连续 1 子串且第 i 位为 0/1 的最小操作数
  • 更新方式：
    • 若 s [ i ] = ′ 0 ′ s[i]='0' s[i]=′0′
      d p [ i ] [ j ] [ 0 ] = min ⁡ ( d p [ i ] [ j ] [ 0 ] , d p [ i − 1 ] [ j ] [ 0 ] , d p [ i − 1 ] [ j ] [ 1 ] ) d p [ i ] [ j ] [ 1 ] = min ⁡ ( d p [ i ] [ j ] [ 1 ] , d p [ i − 1 ] [ j ] [ 1 ] + 1 ) dp[i][j][0]=\min(dp[i][j][0],dp[i-1][j][0], dp[i-1][j][1])\\ dp[i][j][1]=\min(dp[i][j][1],dp[i-1][j][1]+1) dp[i][j][0]=min(dp[i][j][0],dp[i−1][j][0],dp[i−1][j][1])dp[i][j][1]=min(dp[i][j][1],dp[i−1][j][1]+1)
    • 若 s [ i ] = ′ 1 ′ s[i]='1' s[i]=′1′
      d p [ i ] [ j ] [ 0 ] = min ⁡ ( d p [ i ] [ j ] [ 0 ] , d p [ i − 1 ] [ j ] [ 0 ] ) d p [ i ] [ j ] [ 1 ] = min ⁡ ( d p [ i ] [ j ] [ 1 ] , d p [ i − 1 ] [ j ] [ 1 ] ) dp[i][j][0]=\min(dp[i][j][0],dp[i-1][j][0])\\ dp[i][j][1]=\min(dp[i][j][1],dp[i-1][j][1]) dp[i][j][0]=min(dp[i][j][0],dp[i−1][j][0])dp[i][j][1]=min(dp[i][j][1],dp[i−1][j][1])
    • 同时，如果 i ≥ m i d i\geq mid i≥mid 且 j ≥ 0 j\geq 0 j≥0
      d p [ i ] [ j ] [ 1 ] = min ⁡ ( d p [ i ] [ j ] [ 1 ] , d p [ i − m i d ] [ j − 1 ] [ 0 ] + p r e [ i ] − p r e [ i − m i d ] ) dp[i][j][1]=\min(dp[i][j][1],dp[i-mid][j-1][0]+pre[i]-pre[i-mid]) dp[i][j][1]=min(dp[i][j][1],dp[i−mid][j−1][0]+pre[i]−pre[i−mid])
  • 其中， p r e pre pre 是 0 个数的前缀和
#include <bits/stdc++.h>

using namespace std;

#define int long long
#define double long double
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<PII, int> PIII;
typedef pair<int, pair<int, bool>> PIIB;
typedef pair<PII, PII> PIIII;

const int N = 1e5 + 10;
const int maxn = 1e6;
const int MAXN = 100;
const int mod = 998244353;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int n, m, k; cin >> n >> m >> k;
	string s; cin >> s;
	s = " " + s;
	vector<int> pre(n + 1);
	for (int i = 1; i <= n; i ++ ) pre[i] = pre[i - 1] + (s[i] == '0');
	vector<vector<vector<int>>> dp(n + 1, vector<vector<int>>(k + 1, vector<int>(2, INF)));
	auto check = [&](int x)
	{
		for (int i = 0; i <= n; i ++ )
		{
			for (int j = 0; j <= k; j ++ )
			{
				dp[i][j][0] = dp[i][j][1] = INF;
			}
		}
		dp[0][0][0] = dp[0][0][1] = 0;
		for (int i = 1; i <= n; i ++ )
		{
			for (int j = 0; j <= k; j ++ )
			{
				if (s[i] == '0')
				{
					dp[i][j][0] = min({dp[i][j][0], dp[i - 1][j][0], dp[i - 1][j][1]});
					dp[i][j][1] = min(dp[i][j][1], dp[i - 1][j][1] + 1);
				}
				else
				{
					dp[i][j][0] = min(dp[i][j][0], dp[i - 1][j][0]);
					dp[i][j][1] = min(dp[i][j][1], dp[i - 1][j][1]);
				}
				if (i >= x && j >= 1)
				{
					dp[i][j][1] = min(dp[i][j][1], dp[i - x][j - 1][0] + pre[i] - pre[i - x]);
				}
			}
		}
		return (min(dp[n][k][0], dp[n][k][1]) <= m);
	};
	int l = 0, r = n;
	while (l < r)
	{
		int mid = l + r + 1 >> 1;
		if (check(mid)) l = mid;
		else r = mid - 1;
	}
	if (r > 0) cout << r << '\n';
	else cout << -1 << '\n';
}

signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    int t = 1;
    // cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

J. Takeout Delivering（dijkstra+思维）

  • 枚举每一条边作为最终答案的边，然后看它的两个端点到 1 和 n 的距离更新最终答案
#include <bits/stdc++.h>

using namespace std;

#define int long long
#define double long double
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<PII, int> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e3 + 10;
const int maxn = 1e6;
const int MAXN = 100;
const int mod = 998244353;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

struct edge {
	int a, b, c;
};

void solve()
{
	int n, m; cin >> n >> m;
	vector<vector<PII>> g(n + 1);
	vector<struct edge> e(m);
	for (int i = 0; i < m; i ++ )
	{
		int a, b, c; cin >> a >> b >> c;
		e[i] = {a, b, c};
		
		g[a].push_back({b, c});
		g[b].push_back({a, c});
	}
	vector<int> dist1(n + 1, INF), dist2(n + 1, INF);
	auto dijkstra = [&](int rt, vector<int>&dist)
	{
		vector<bool> st(n + 1);
		priority_queue<PII, vector<PII>, greater<PII>> pq;
		pq.push({0, rt});
		dist[rt] = 0;
		while (pq.size())
		{
			auto t = pq.top();
			pq.pop();

			int v = t.second, maxx = t.first;

			if (st[v]) continue;
			st[v] = true;

			for (int i = 0; i < g[v].size(); i ++ )
			{
				int j = g[v][i].first, w = g[v][i].second;
				if (st[j]) continue;
				if (dist[j] > max(dist[v], w))
				{
					dist[j] = max(dist[v], w);
					pq.push({dist[j], j});
				}
			}
		}
	};
	dijkstra(1, dist1);
	dijkstra(n, dist2);
	int ans = INF;
	for (int i = 0; i < m; i ++ )
	{
		auto [a, b, c] = e[i];
		int tmp = min(max(dist1[a], dist2[b]), max(dist1[b], dist2[a]));
		if (tmp <= c) ans = min(ans, tmp + c);
	}
	
	cout << ans << '\n';
}

signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    int t = 1;
    // cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}
Texcavator
关注
专栏目录
2022 ICPC 亚洲区域赛（合肥）赛后总结
m0_55733023的博客
11-21 1608
G题也是WA一次调一个bug，到了最后10分钟的时候，已经无法通过造样例来找bug了，这题也没办法暴力对拍，这时候我灵光乍现，发现队友造的样例总是包含1~n的所有点，于是我造了一个漏掉某些数的样例，居然成功找到bug。我其实已经意识到这题是概率dp，但是正好在前天，从codeforce div2某期做了一个概率dp+逆元取模，2400分的水平，我当时直接弃了，结果比赛时看到这题的时候我也下意识认为搞不出来，并且两个队友对于概率dp和期望这一块也没有学习，于是我告诉大家这是咱们的思维盲区，可以换题。
2023ICPC亚洲区域赛(合肥)VP补题题解(48th)
ChuanhuaYu的博客
07-03 2127
2023ICPC亚洲区域赛(合肥)VP补题题解记录。已更新 E F G J，待更新 B I C。
ICPC2023合肥站：D. Balanced Array
zsyzClb的博客
07-16 341
考虑一段数，我们把它复制成三份，第一份不变，第二份往左边移动k个位置，第三份往右边移动k个位置，那很明显就是上下的和等于中间的两倍。基本都很大（相对于(n-1)/2)，因此我们维护最大的20个满足条件的k即可。显然，对于每个k，它所满足要求的i肯定是一个区间。这道题我也没有想到正解，用了一个奇技淫巧过了。后面看到题解居然能够用哈希进行快速的判断。我们不难发现，满足条件的。
2022 ICPC 亚洲区域赛 合肥站 题解 ABGH
m0_55733023的博客
11-21 2117
2022 ICPC 亚洲区域赛 合肥站 题解 ABGH
2015 ACM/ICPC 合肥赛区网络赛——吐槽向
Last Order
10-11 1762
1001. Monitor the Alpacas 几何。。。。嗯，就这样吧 1002. The Relationship in Club 连通块，dp什么的。。。嗯，好的 1003. Difference of Clustering 题意很扯淡，主要是要搞清楚拆分就是1对n，合并就是n对1，就好了。。。 做法就是暴力……就做法来说应该是本场最水的题
2023年，ICPC比赛、CCPC比赛、CCF-CSP考试、蓝桥杯比赛、天梯赛日程
海岛Blog
09-10 3万+
国赛日期：2023年6月10日 报名：2023年4月24日-5月12日。女生专场 重庆 2023年10月21-22日 重庆对外经贸大学。高职专场 嘉兴 2023年10月21-22日 嘉兴职业技术学院。院校报名时间：2022年10月10日——2022年12月16日。港澳站 2023年11月11-12日 香港理工大学、澳门大学。哈尔滨分站赛 2023年11月4-5日 哈尔滨工程大学。深圳分站赛 2023年11月11-12日 深圳技术大学。西安站 2023年10月21-22日 西北工业大学。
91 . B. Queue (灵茶每日一题 : 01-23)
ros275229的博客
01-23 418
91 . B. Queue
2022 ICPC 47 合肥 AHGB（JM）
qq_62817228的博客
11-21 1532
2022 ICPC 47 合肥 AHGB（JM）
2019-2020 ICPC SEERC D - Cycle String?（思维+模拟）
WayJasy的博客
11-12 816
传送门 题意： 给定长度为2∗n2*n2∗n的循环字符串，对其重新排列使得新字符串中不存在两个及以上长度为nnn的相同子串，问能否构造成功并输出任意新字符串。 思路： 首先容易发现新串是否合法与出现最多字符的数量有关，稍微打个表发现：出现次数最多的字符（一下称chchch）出现了xxx次. ①①①如果x<=nx <= nx<=n，那么我们直接输出原串就好了。 ②②②如果字符种类数...
The 2023 ICPC Asia Hefei Regional Contest
m0_74315028的博客
05-11 538
B. Queue Sorting I. Linguistics Puzzle D. Balanced Array
二分+DP The 2023 ICPC Asia Hefei Regional Contest Problem G Streak Manipulation
m0_73738728的博客
02-04 1316
给定一个长度为n的01串，最多可以将m个0变成1，要求使01串中第k长连续1串的长度最大。输出最大值，如果无法得到第k长的连续1串，输出-1。
LeetCode按照怎样的顺序来刷题比较好
zhf的博客
03-07 821
1. Pattern: Sliding window，滑动窗口类型滑动窗口类型的题目经常是用来执行数组或是链表上某个区间（窗口）上的操作。比如找最长的全为1的子数组长度。滑动窗口一般从第一个元素开始，一直往右边一个一个元素挪动。当然了，根据题目要求，我们可能有固定窗口大小的情况，也有窗口的大小变化的情况。该图中，我们的窗子不断往右一格一个移动下面是一些我们用来判断我们可能需要上滑动窗口策略的方法：...
2022年，ICPC比赛、CCPC比赛、CCF-CSP考试、蓝桥杯比赛、天梯赛日程
热门推荐
海岛Blog
03-18 5万+
**ICPC比赛日程（第４7届，２０２2年）：** 第一次网络选拔赛 2022年9月18日 第二次网络选拔赛 2022年9月25日 沈阳站 2022年11月5-6日 东北大学 西安站 2022年11月12-13日 西北工业大学
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1287
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
二叉树最小深度
2301_80161204的博客
09-27 475
25[0, 105]
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1104
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
最新发布
wnm23的专栏
10-02 578
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1295
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Texcavator

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值