2023年ICPC南京站 补题记录

已于 2024-08-16 11:58:42 修改
阅读量499 收藏 9
点赞数 4
分类专栏： xcpc题解 文章标签： 算法
于 2024-08-15 22:57:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dhxbshbdjzxy/article/details/141231760
版权

A - 酷，昨日四次重现（bfs）

  • 可以发现，一个连通块中，只要有一个点可以战胜其余连通块中的所有点，那这一个连通块中的点都是获胜点
  • 所以直接暴力，对一个点bfs找到同一个连通块中的所有点，记录相对位移，然后判断其他点能不能在某些相对位移时输即可
#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 = 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 dx[] = {0, 0, -1, 1}, dy[] = {1, -1, 0, 0};

void solve()
{
	int n, m; cin >> n >> m;
	vector<string> g(n + 1);
	for (int i = 1; i <= n; i ++ )
	{
		string s; cin >> s;
		s = " " + s;
		g[i] = s;
	}
	int ans = 0, idx = 0;
	vector<vector<int>> st(n + 1, vector<int>(m + 1));
	vector<PII> pos;
	auto bfs = [&](int x, int y)
	{
		queue<PII> q;
		q.push({x, y});
		st[x][y] = ++ idx;
		while (q.size())
		{
			auto t = q.front();
			q.pop();
			int xx = t.first, yy = t.second;
			pos.push_back({xx - x, yy - y});
			for (int i = 0; i < 4; i ++ )
			{
				int nx = xx + dx[i], ny = yy + dy[i];
				if (nx <= 0 || nx > n || ny <= 0 || ny > m) continue;
				if (st[nx][ny] || g[nx][ny] != '.') continue;
				st[nx][ny] = idx;
				q.push({nx, ny});
			}
		}
	};
	for (int i = 1; i <= n; i ++ )
	{
		for (int j = 1; j <= m; j ++ )
		{
			if (st[i][j] || g[i][j] != '.') continue;
			pos.clear();
			bfs(i, j);
			bool flag = true;
			for (int r = 1; r <= n && flag; r ++ )
			{
				for (int c = 1; c <= m && flag; c ++ )
				{
					if (st[r][c] == idx || g[r][c] != '.') continue;
					bool ok = true;
					for (auto t : pos)
					{
						int nx = r + t.first, ny = c + t.second;
						if (nx <= 0 || nx > n || ny <= 0 || ny > m || g[nx][ny] != '.')
						{
							ok = false;
							break;
						}
					}
					if (ok) flag = false;
				}
			}
			if (flag) ans += pos.size();
		}
	}
	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 - 原根（数论）

  • 不会数学，抄一下队友的码
#include<iostream>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<vector>
#include<map>
#include<algorithm>
#include<queue>
#include <iomanip>
#include<random>

using namespace std;
typedef long long LL;
typedef __int128 i128;
typedef unsigned long long ULL;
typedef double db;
#define int long long
int n , m , p;

void Asuka()
{
	cin >> p >> m;
	if(m < p){
		int res = 0;
		if((1 ^ (p - 1)) <= m){
			res ++;
		}
		if(((p + 1) ^ (p - 1)) <= m)res ++;
		if(((p*2+1) ^ (p - 1)) <= m)res ++;
		cout << res << '\n';
		return;
	}
	int res = (m - p + 1 - 2) / p + 1;
	// cout << res << '\n';
	int ans = res;
	for(int num = res * p + 1;num < (res + 3) * p + 1;num += p){
		if((num ^ (p - 1)) <= m)ans ++;
	}
	cout << ans << endl;
	return;
}	

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

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

F - 等价重写（思维）

  • 一开始提出一种很蠢的拓扑建图做法，然后队友说判断一下相邻两个能不能交换就好了，于是直接过了
#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 = 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; cin >> n >> m;
	vector<vector<int>> op(n + 1);
	for (int i = 1; i <= n; i ++ )
	{
		int x; cin >> x;
		while (x -- )
		{
			int pos; cin >> pos;
			op[i].push_back(pos);
		}
	}
    vector<bool> st(m + 1);
    vector<int> cnt(m + 1);

    for (auto t : op[n]) cnt[t] ++ ;

    bool flag = false;
	for (int i = n - 1; i >= 1; i -- )
    {
        bool flag = true;
        for (auto t : op[i])
        {
            if (st[t]) continue;
            cnt[t] ++ ;
            if (cnt[t] > 1) flag = false;
        }
        for (auto t : op[i + 1])
        {
            if (st[t]) continue;
            cnt[t] -- ;
            st[t] = true;
        }
        if (flag)
        {
            cout << "Yes\n";
            for (int j = 1; j <= i - 1; j ++ ) cout << j << ' ';
            cout << i + 1 << ' ' << i;
            for (int j = i + 2; j <= n; j ++ ) cout << ' ' << j;
            cout << '\n';
            return;
        }
    }
    cout << "No\n";
}

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

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

G - 背包（思维+01背包）

  • 依次考虑前 i i i 个位置，对前 i i i 个位置 01背包，后面的免费取 k k k 个美丽值最大的
#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 = 1010;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int n, m, k; cin >> n >> m >> k;
	vector<PII> a(n + 1);
	for (int i = 1; i <= n; i ++ ) cin >> a[i].first >> a[i].second;
	sort(a.begin() + 1, a.end());
	priority_queue<int, vector<int>, greater<int>> pq;
	vector<int> g(n + 2);
	g[n + 1] = 0;
	int sum = 0;
	for (int i = n; i >= 1; i -- )
	{
		sum += a[i].second;
		pq.push(a[i].second);
		if (pq.size() > k)
		{
			sum -= pq.top();
			pq.pop();
		}
		g[i] = sum;
	}
	vector<int> dp(m + 1);
	int ans = g[1];
	for (int i = 1; i <= n; i ++ )
	{
		for (int j = m; j >= a[i].first; j -- )
		{
			dp[j] = max(dp[j], dp[j - a[i].first] + a[i].second);
			ans = max(ans, dp[j] + g[i + 1]);
		}
	}
	cout << ans << '\n';
}

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

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

I - 计数器（签到）

#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 = 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; cin >> n >> m;
	vector<PII> a(m + 1);
	for (int i = 1; i <= m; i ++ ) cin >> a[i].first >> a[i].second;
	sort(a.begin() + 1, a.end());
	int num = 0, op = 0;
	for (int i = 1; i <= m; i ++ )
	{
		int cnt = a[i].first - op;
		if (cnt == 0)
		{
			if (num == a[i].second) continue;
			else
			{
				cout << "No\n";
				return;
			}
		}
		if (a[i].second == 0)
		{
			num = 0;
			op = a[i].first;
		}
		else if (a[i].second <= cnt - 1)
		{
			num = a[i].second;
			op = a[i].first;
		}
		else
		{
			if (num + cnt == a[i].second)
			{
				num = a[i].second;
				op = a[i].first;
			}
			else
			{
				cout << "No\n";
				return;
			}
		}
	} 
	cout << "Yes\n";
}

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

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

L - 电梯（贪心+模拟）

  • 从高楼层往低楼层考虑，先放2的，放完了就放1的，放不满就考虑低楼层
#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 = 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;

int mp[N], ump[N];

void solve()
{
    int n, k; cin >> n >> k;
    vector<int> c(n + 1), w(n + 1), f(n + 1), tt;
    int maxx = 0;
    for (int i = 1; i <= n; i ++ )
    {
        cin >> c[i] >> w[i] >> f[i];
        tt.push_back(f[i]);
    }
    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;
        ump[i + 1] = tt[i];
    }
    for (int i = 1; i <= n; i ++ )
    {
        f[i] = mp[f[i]];
        maxx = max(maxx, f[i]);
    }
    vector<vector<int>> cnt(maxx + 1, vector<int>(3));
    for (int i = 1; i <= n; i ++ ) cnt[f[i]][w[i]] += c[i];
    int ans = 0, yu = 0;
    bool flag = false;
    for (int i = maxx; i >= 1; i -- )
    {
        if (flag && cnt[i][1] != 0)
        {
            flag = false;
            cnt[i][1] -- ;
        }
        if (yu != 0)
        {
            int t1 = yu / 2; // 放多少重量为2的
            if (cnt[i][2] >= t1)
            {
                cnt[i][2] -= t1;
                yu %= 2;
            }
            else
            {
                yu -= cnt[i][2] * 2;
                cnt[i][2] = 0;
            }
            if (yu != 0)
            {
                if (cnt[i][1] >= yu)
                {
                    cnt[i][1] -= yu;
                    yu = 0;
                }
                else
                {
                    yu -= cnt[i][1];
                    cnt[i][1] = 0;
                }
            }
            if (yu == 1)
            {
                yu = 0;
                flag = true;
            }
        }
        if (cnt[i][2] != 0) // 本楼层还有重量为2的
        {
            int tmp2 = k / 2; // 一趟能运多少重量为2

            // 全是本楼层重量为2的
            int c1 = cnt[i][2] / tmp2;
            ans += c1 * ump[i];
            cnt[i][2] %= tmp2;

            if (cnt[i][2] != 0)
            {
                int wei = k - cnt[i][2] * 2; // 还能装多少重量
                cnt[i][2] = 0;
                if (wei != 0)
                {
                    if (cnt[i][1] >= wei) // 剩下的部分全装本楼层重量为1的
                    {
                        cnt[i][1] -= wei;
                        ans += ump[i];
                    }
                    else
                    {
                        wei -= cnt[i][1];
                        cnt[i][1] = 0;
                        yu += wei;
                        ans += ump[i];
                        if (yu == 1)
                        {
                            yu = 0;
                            flag = true;
                        }
                    }
                }
            }
        }
        if (cnt[i][1] != 0)
        {
            int t = cnt[i][1] / k;
            ans += t * ump[i];
            cnt[i][1] %= k;
            if (cnt[i][1] != 0)
            {
                ans += ump[i];
                yu += k - cnt[i][1];
                cnt[i][1] = 0;
            }
        }
    }
    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;
}

M - 接雨水（思维）

  • 题目将原问题转化成了
    ∑ i = 1 n ( min ⁡ ( f i , g i ) − a i ) \sum\limits_{i = 1}^n \left( \min(f_i, g_i) - a_i \right) i=1∑n​(min(fi​,gi​)−ai​)
    我们知道 min ⁡ ( f i , g i ) \min(f_i, g_i) min(fi​,gi​) 可以转化成 f i + g i − max ⁡ a i f_i+g_i-\max{a_i} fi​+gi​−maxai​
    所以我们要求的答案就是
    ∑ i = 1 n f i + ∑ i = 1 n g i − n × max ⁡ a i − ∑ i = 1 n a i \sum\limits_{i = 1}^nf_i+\sum\limits_{i = 1}^ng_i-n\times \max{a_i-}\sum\limits_{i = 1}^na_i i=1∑n​fi​+i=1∑n​gi​−n×maxai​−i=1∑n​ai​
  • n × max ⁡ a i n\times \max{a_i} n×maxai​ 和 ∑ i = 1 n a i \sum\limits_{i = 1}^na_i i=1∑n​ai​ 很好求，问题就转化成了求 f i f_i fi​ 和 g i g_i gi​
  • f i f_i fi​ 被分成若干段，每一段的值都相同，且从左往右单调不减，所以我们可以用 set 维护，set 中记录每一段的开头下标和值，每次增加 a i a_i ai​ 的值时，将 a i a_i ai​ 后面小于 a i a_i ai​ 的都删掉， 维护一下这个结构就可以了
#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 = 1010;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int n; cin >> n;
	vector<int> a(n + 1);
	vector<int> ff(n + 1), gg(n + 1);
	int sum = 0, maxx = 0;
	for (int i = 1; i <= n; i ++ )
	{
		cin >> a[i];
		maxx = max(maxx, a[i]);
		sum += a[i];
	}

	auto add = [&](int pos, int x, set<PII>& st, int &sm, vector<int> &v)
	{
		v[pos] += x;
		auto it = prev(st.upper_bound({pos, INF}));
		if ((*it).second >= v[pos]) return;
		sm -= ((*next(it)).first - (*it).first) * (*it).second;
		sm += (pos - (*it).first) * (*it).second + ((*next(it)).first - pos) * v[pos];
		it = st.insert({pos, v[pos]}).first;
		while ((*next(it)).second <= v[pos])
		{
			sm -= ((*next(it)).first - pos) * v[pos] + ((*next(next(it))).first - (*next(it)).first) * (*next(it)).second;
			st.erase(next(it));
			sm += ((*next(it)).first - pos) * v[pos];
		}
	};
	int smf = 0, smg = 0;
	set<PII> f, g;
	f.insert({1, 0}), f.insert({n + 1, INF});
	g.insert({1, 0}), g.insert({n + 1, INF});
	for (int i = 1; i <= n; i ++ ) add(i, a[i], f, smf, ff), add(n - i + 1, a[i], g, smg, gg);

	int q; cin >> q;
	while (q -- )
	{
		int pos, x; cin >> pos >> x;
		a[pos] += x;
		maxx = max(maxx, a[pos]);
		sum += x;
		add(pos, x, f, smf, ff), add(n - pos + 1, x, g, smg, gg);
		cout << smf + smg - n * maxx - sum << '\n';
	}
}

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

	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}
Texcavator
关注
专栏目录
ACM模板(从小白到ACMer的学习笔记)
m0_52186223的博客
11-13 4169
这一个弱校大二，从小白到ACMer的学习笔记，主要时用于自己的理解和记录一些自己的模板，基本上囊括了铜牌水准的知识点。
【LittleXi】ICPC2023 南京站 总结
qq_68591679的博客
11-08 1436
【LittleXi】ICPC2023 南京站 总结
2023 ICPC 南京题解（L）
梅子酒的博客
12-06 710
我们可以按楼层排序，将同楼层的货物存在一起（只要楼层和重量相同，那么可以直接将数量相加看做同一种货物）从高楼层开始三指针遍历。的货物需要运送到某一楼层，一次运送的代价为本次运送楼层最高的层数（总重量不能超过电梯载重）。货物来弥补高楼层的空缺（当高楼层的运完时，可能某一趟电梯没有填满，此时就可以用低楼层的货物来填），第三个指针。做题对拍过程中发现一组hack样例，能hackCF很多代码，甚至是ucup前排队伍的代码。的形式给出，分别代表货物的数量，重量，需要送到的楼层。代表当前需要用该楼层的重量为。
ICPC2023 南京 比赛报告
weixin_50011798的博客
01-14 674
ICPC2023 南京；正式赛日期：2023-11-05周日；奖项：银牌
2022 ICPC 亚洲区域赛南京站（A，B，D，G，M）
m0_73687532的博客
07-25 4167
3.在面对3的情况时，我们只要可以，就选第二种，如果不行再选第一种，并且记录下选第二种的次数，第二种情况是决定生死的情况，所以如果自身的不够，可以反悔之前对于情况三的选择，当时我们是将野兽数目-1，那么现在反悔就是野兽数目加二，同时献祭一个，也就是野兽数目+1。1.要求第k大值的最大值，第k大值意味着这个数组经过操作后中有k-1个数字比这个数字大，所以考虑二分，二分这个第k大数的值，然后统计经过最优操作后，能比这个k值大的数的个数，如果这个个数大于k，说明我们的x取小了，反之，x取大了。
2022icpc南京站A.停停，昨日请不要再重现
qq_36834063的博客
02-01 1210
2022南京站A题，考查了差分的运用
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日 西北工业大学。
2023 ICPC 亚洲区域赛南京站计算几何 —— Problem B.交并比(源代码出炉+解析）
Zz_0913的博客
01-03 1359
2.两个矩形的相交面积比上面积并就是所谓的交并比（IOU）；1.给定一个矩形（OBB），要求找到一个坐标轴平行矩形（AABB）；3.我们需要求出这个矩形使IOU最大。博客👆中，我们通过非常复杂的代数方法证明关于IOU的这个函数是。三分法，爬山法，梯度下降法。
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日 西北工业大学
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
qq_61936886的博客
09-12 529
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
输出一个三位数
2301_77501988的博客
09-13 433
本题要求编写程序，输入一个三位数，输出其个位数字、十位数字和百位数字。
算法知识点——常用输入输出数据的方式
5233的博客
09-12 313
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1217
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
【Hot100】LeetCode—64. 最小路径和
weixin_44382896的博客
09-12 505
64. 最小路径和。
拥塞控制算法为何失效，网络为何难以测量？
Netfilter
09-14 4468
所以你知道实验室仿真的宇宙第一算法为啥拉了吧，也就不用再问为什么部署了 bbr 却还不如 cubic 了吧，如果你还希望研发一个精准的，普适的端到端算法，我劝你改行去卖皮鞋，至少还有很多经理市场。这和上一篇说的测量系统容量的方法并不矛盾，因为对于网络传输系统而言，系统是动态变化的，在流量部署到系统上并开始传输时，没有全局视图，就不能指望全局公平，留下的 gap 是固有的，没法靠算法弥补。，超级经典的一篇论文，我推荐过不止一次，因此我本文不谈异构问题，说点别的，比如拓扑。对，就是要砸，因为我不干了。
算法练习题24——查找杨辉三角中的组合数
hello77的blogggg 祝你得偿所愿
09-12 611
逐项递推法适合处理较小的数据量，计算较为直观，但当杨辉三角行数较大时，效率较低。 二分查找法利用组合数的单调性，显著提高查找效率，适合处理较大的数据范围。这两种解法在不同场景下都可以使用，二分查找法尤其适合大规模数据下的查找问题。
【例题】lanqiao4425 咖啡馆订单系统
最新发布
m0_73676887的博客
09-17 208
样例输入样例输出3 2样例说明输入的数组为：【3，1，2】增量序列为：【2，1】当增量 h=2：对于每一个索引 i，我们会将数组元素 arr[i] 与 arr[i−h] 进行比较，并进行可能的交换。当增量 h=1：这就是一个普通的插入排序。总结：总共进行了 3 次比较，2 次交换。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Texcavator

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

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

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

打赏作者

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

抵扣说明：

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

余额充值