2025-01-22 00:33阅读: 50评论: 0推荐: 0

2025牛客寒假算法基础集训营1补题笔记

合集 - 2025牛客寒假算法基础集训营补题(3)

1.2025牛客寒假算法基础集训营1补题笔记01-22

2.2025牛客寒假算法基础集训营2补题笔记02-17 3.2025牛客寒假算法基础集训营3补题笔记02-26

题目难度顺序大致为：A D B G M H E J C F L K I

头疼的思维+模拟。

前 $4$ 题写得挺顺，但 $D$ 题没看清是两种元素出现次数相同wa了一发，$M$ 题其实一开始没有思路但暴力写了一波奇迹的过了，赛后果然被hack数据太水，$H$ 卡了4个钟。。。$E$ 题明显的贪心结论没有套上，歪到平均数去了，然后就一直在 $H$ 钻牛角尖。

A.茕茕孑立之影

题意

给定一个数组，找到一个正整数 $x$，使得 $x$ 和数组中的元素互不为倍数关系。

思路

首先 $1$ 是任何数的因数，所以有 $1$ 的时候没有答案。
然后考虑没有 $1$ 的情况，可以发现只需要找到一个比数组中的元素都大的质数就可以，因为数组元素都不超过 $10^9$ ，直接输出 $1000000007$ 即可。

代码

点击查看代码

 #include <iostream>
 
using namespace std;
 
const int P = 1e9 + 7;
 
int n;
 
void solve()
{
  bool flag = 0;
  cin >> n;
  for (int i = 1; i <= n; i ++) {
  	int x;
  	cin >> x;
  	if (x == 1) flag = 1;
  }
  if (flag) cout << -1 << '\n';
  else cout << P << '\n';
}
 
int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
 
  int t = 1;
  cin >> t;
 
  while (t --) solve();
 
  return 0;
}

D.双生双宿之决

题意

给定一个数组，判断是否为双生数组，即元素种类数为 $2$、且出现次数相同。

思路

按题意模拟即可。用 $set$ 来筛选种类个数，用 $map$ 来记录每个数出现次数。
也可以排序，检查前半部分和后半部分数是否相等即可。

代码

点击查看代码

 #include <iostream>
#include <algorithm>
#include <map>
#include <set>
 
#define si(x)       int(x.size())
#define fi          first
#define se          second
 
using namespace std;
 
int n;
 
void solve()
{
  cin >> n;
  set<int> v;
  map<int, int> mp;
  for (int i = 0; i < n; i ++) {
  	int x;
  	cin >> x;
  	mp[x] ++;
  	v.insert(x);
  }
  
  if (n % 2 || si(v) != 2) cout << "No" << '\n';
  else {
  	int num = 0;
  	for (auto it : mp) {
  		if (num == 0) num = it.se;
  		else if (num != it.se) {
  			cout << "No" << '\n';
  			return ;
  		}
  	}
  	cout << "Yes" << '\n';
  }
}
 
int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
 
  int t = 1;
  cin >> t;
 
  while (t --) solve();
 
  return 0;
}

代码2

点击查看代码

 void solve()
{
    cin >> n;
    for (int i = 1; i <= n; i ++) cin >> a[i];
    sort(a + 1, a + 1 + n);
    if (n % 2 || a[1] == a[n]) return void(cout << "No" << '\n');
    if (a[1] == a[n / 2] && a[n / 2 + 1] == a[n]) cout << "Yes" << '\n';
    else  cout << "No" << '\n';
}

B.一气贯通之刃

题意

给一棵树，找到一条路径经过所有节点。

思路

自己手动画几棵树可以发现：如果一棵树的某个节点出度超过 $2$ ，即这个节点与至少 $3$ 个节点有连边，那么就不存在有简单路径是经过所有节点的，所以我们只需要去遍历一遍所有节点的出度就可以了。而起点、终点，则明显是两个叶子节点，出度为 $1$。

题外知识：一颗树的最长简单路径就是这棵树的直径。可以用树形 $dp$ 来解决。

代码

点击查看代码

 #include <iostream>
 
using namespace std;
 
const int N = 1e6 + 10;
 
int n, u, v;
int a[N];
 
void solve()
{
  cin >> n;
  for (int i = 1; i < n; i ++) {
  	cin >> u >> v;
  	a[u] ++, a[v] ++;
  }
  
  int sd = -1, ed = -1;
  for (int i = 1 ; i <= n; i ++) {
  	if (a[i] > 2) return void(cout << -1 << '\n');
  	if (a[i] == 1) 
  		if (sd == -1) sd = i;
  		else ed = i;
  }
  
  cout << sd << ' ' << ed;
}
 
int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
 
  int t = 1;
 
  while (t --) solve();
 
  return 0;
}

G.井然有序之衡

题意

给一个数组，每次操作可以使一个元素加 $1$，另一个元素减 $1$ ，问变成排列的最小操作次数。

思路

首先，一个元素加 $1$, 一个元素减 $1$，对于数组总和是不变，所以数组是否可以构造成排列，在于数组总和和排列总和是否相等。然后是计算最小操作数。

贪心的方法解决最小操作数。
将数组进行升序排序，然后按 $1 \sim n$ 的排列顺序计算操作个数。

代码

点击查看代码

 #include <iostream>
#include <algorithm>
 
#define ll  long long
 
using namespace std;
 
const int N = 1e6 + 10;
 
ll n;
ll a[N];
 
void solve()
{
  cin >> n;
  ll sum = 0;
  for (int i = 1; i <= n; i ++) {
  	cin >> a[i];
  	sum += a[i];
  }
  
  ll num = (n + 1) * n / 2;
  if (num != sum) cout << -1;
  else {
  	sort(a + 1, a + 1 + n);
  	ll res = 0;
  	for (int i = 1; i <= n; i ++) 
        res += abs(i - a[i]);
  	cout << res / 2;
  }
}
 
int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
 
  int t = 1;
  while (t --) solve();
 
  return 0;
}

M.数值膨胀之美

题意

给定一个数组，可以选择一个区间将所有元素乘 $2$，问操作后的最小极差。

思路

赛后重新思考，想到可以从第一个最小值开始维护区间，到最后包括所有最小值。

如何维护呢？

首先存下所有元素的值和下标，升序排序。
然后从第一个最小值下标开始，按区间右端点增大方向操作，到达下一个最小值的位置，区间内的数都要乘2，直到包括所有的最小值后结束。

最后这个思路只过了86.11%，看完题解才知道还要继续考虑次小值直到最大值。
（其实赛时已经发现假设选取所有元素乘2可能比选取子区间要更优，但赛后忘了。。。）

代码

点击查看代码

 #include <iostream>
#include <algorithm>
 
#define fi first
#define se second
 
using namespace std;
 
typedef pair<int, int> PII;
 
const int N = 1e5 + 10;
 
int n, b[N];
PII a[N];
 
int main()
{
    cin >> n;
    for (int i = 1; i <= n; i ++) {
        cin >> b[i];
        a[i] = {b[i], i};
    }
    sort(a + 1, a + 1 + n);
    
    int res = 0x3f3f3f3f;
    a[n + 1].fi = res;
    int maxv = a[n].fi, l = a[1].se, r = a[1].se;
    for (int i = 1; i <= n; i ++) {
        while (a[i].se <= l) maxv = max(maxv, b[l --] * 2);
        while (a[i].se >= r) maxv = max(maxv, b[r ++] * 2);
        res = min(res, maxv - min(a[1].fi * 2, a[i + 1].fi));
    }
    cout << res;
    
    return 0;
}

H.井然有序之窗

题意

构造一个排列，满足每个元素都在一个指定的区间内。

思路

一个经典的贪心题吧，居然在这跑dfs，感觉我赛时一定是脑子抽风了。

先说结论：第 $i$ 个位置如果多个选择，那么选择区间右端点最小的那个数，结果一定不会更劣。

为什么呢？可以自己模拟一下：

假设现在要选择一个数填入第5的位置，有3种选择：3[3, 7]、6[4, 5]、8[5, 6]。

首先我们得知道既然已经到填入第5的位置了，那么 $1\sim4$ 的位置都已经完成填入了，所以对于这4种选择，可以发现3和6的区间是要更小的：3[5, 7]、6[5, 5]。

所以这个位置如果先选3或8填入，那么6就无法填入了，而如果每个位置的多种选案都选右端点最小的填入，那么对后面的位置影响是最小的。

实现用优先队列来维护右端点的小根堆，枚举 $1 \sim n$的位置，将在这个位置下的所有未选区间放入队列中，如果没有或队首的右端点小于当前位置，就没有方案可行。

代码

点击查看代码

 #include <iostream>
#include <algorithm>
#include <queue>
 
using namespace std;
 
const int N = 1e6 + 10;
 
int n;
struct node {
	int val;
	int l, r;
    
    bool operator < (const node& b) const {
        return r > b.r;
    }
} a[N];
priority_queue<node> pq;
int ans[N];
 
bool cmp(node aa, node bb) {
	if (aa.l == bb.l) return aa.r < bb.r;
    return aa.l < bb.l;
}
 
void solve()
{
  cin >> n;
  for (int i = 1; i <= n; i ++) {
  	int l, r;
  	cin >> l >> r;
  	a[i] = {i, l, r};
  }
  
  sort(a + 1, a + 1 + n, cmp);
  for (int i = 1, j = 1; i <= n; i ++) {
      while (j <= n && a[j].l <= i) pq.push(a[j ++]);
      if (pq.empty() || pq.top().r < i) return void(cout << -1);
      ans[pq.top().val] = i;
      pq.pop();
  }
    
    for (int i = 1; i <= n; i ++) cout << ans[i] << ' ';
}
 
int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
 
  solve();
 
  return 0;
}

E.双生双宿之错

题意

给定一个数组，每次操作可以使得一个元素加1或者减1，问最小操作几次可以变成双生数组，即元素种类数为2、且出现次数相同。

思路

$D$ 题的扩展，其实是一个贪心结论题，参考货仓选址。叫中位数定理，这个今天才知道。

先说结论：求一个数 $x$，让一组元素与 $x$ 的差的绝对值的和最小，那么 $x$ 是这组元素的中位数，结果不会更劣。

我们依旧先举例模拟：有两个数3、5，中位数可以是3或5，那么差值和就是2，假如我们在大于5或小于3的范围内选一个数，比如7，那么差值和就是4+2=6比2大。

其实我们可以发现选择的那个数可以让大于它和小于它的数相抵消，如果某方有多出的数就会多增加差值，就上面的例子：5 - 3 = （4 - 3） + （5 - 4）= |3 - 5|，中间的|3 - 4| + （5 - 4）其实就是5-3，-4和+4相抵消了，如果是7变为：|3 - 7| + |5 - 7|相对于4多加了两个（7 - 5）。

有了上面的结论，解决这道题就很容易了，先将数组排序，找出前后两部分的中位数，然后求差的绝对值之和。但要处理两个中位数相等的特殊情况，可以枚举四种情况：假设前半部分的中位数为lmid，后半部分中位数为rmid，那么算出（lmid-1，rmid）、（lmid+1，rmid）、（lmid，rmid-1）、（lmid，rmid+1）的结果然后取最小值。

代码

点击查看代码

 #include <iostream>
#include <algorithm>
 
using namespace std;
 
typedef long long ll;
 
const int N = 1e5 + 10;
 
int n;
int a[N];
 
void solve()
{
    cin >> n;
    int m = n / 2;
    for (int i = 1; i <= n; i ++) cin >> a[i];
    
    sort(a + 1, a + 1 + n);
    
    if (a[1] == a[n]) return void(cout << m << '\n');
    
    int midl = a[(m + 1) >> 1], midr = a[(m + 1 + n) >> 1];
    bool flag = 0;
    if (midl == midr) midl --, flag = 1;
    ll ans = 0;
    for (int i = 1; i <= m; i ++) ans += abs(a[i] - midl);
    for (int i = m + 1; i <= n; i ++) ans += abs(a[i] - midr);
    
    if (flag) {
        midl ++, midr ++;
        ll sum = 0;
        for (int i = 1; i <= m; i ++) sum += abs(a[i] - midl);
        for (int i = m + 1; i <= n; i ++) sum += abs(a[i] - midr);
        ans = min(ans, sum);
        
        midl ++, midr --;
        sum = 0;
        for (int i = 1; i <= m; i ++) sum += abs(a[i] - midl);
        for (int i = m + 1; i <= n; i ++) sum += abs(a[i] - midr);
        ans = min(ans, sum);
        
        midl --, midr ++;
        sum = 0;
        for (int i = 1; i <= m; i ++) sum += abs(a[i] - midl);
        for (int i = m + 1; i <= n; i ++) sum += abs(a[i] - midr);
        ans = min(ans, sum);
    }
    
    cout << ans << '\n';
}
 
int main()
{
    int t;
    cin >> t;
    while (t --) solve();
    
    return 0;
}

\[\frac{N}{1} + \frac{N}{2} + \frac{N}{3} + \dots + \frac{N}{N - 1} + \frac{N}{N} \\ \Rightarrow N \times(\frac{1}{1} + \frac{1}{2} + \frac{1}{3} + \dots + \frac{1}{N - 1} + \frac{1}{N}) \\ 而 ~ \frac{1}{1} + \frac{1}{2} + \frac{1}{3} + \dots + \frac{1}{N - 1} + \frac{1}{N}就是调和级数，当N无穷大时结果约等于ln(N) \\ 所以上面的双重循环的时间复杂度可以看作是N倍调和级数即O(N \times ln(N))。 \]

代码

点击查看代码

 #include <iostream>
#include <algorithm>
 
using namespace std;
 
typedef long long ll;
 
const int N = 2e5 + 10;
 
int n, x;
ll cnt[N];
 
int main()
{
    cin >> n;
    for (int i = 0; i < n; i ++) {
        cin >> x;
        cnt[x] ++;
    }
    
    ll ans = 0;
    for (int i = 1; i < N; i ++)
        for (int j = i; j < N; j += i) 
             if ((i ^ j) < N && __gcd(i ^ j, j) == i) 
                 ans += cnt[i ^ j] * cnt[j];
    cout << ans / 2;
    
    return 0;
}

C.兢兢业业之移

题意

01矩阵，将所有1移动到矩阵左上角的四分之一区域。

思路

一道模拟题。

首先，我们可以从 $(0, 0)$开始向y轴正方向枚举，到边界后回到下行首即 $(1, 0)$ 重新向y轴正方向枚举。
然后枚举中遇到1就将它移动到目标位置，目标位置用 $(x, y)$ 来表示。
移动过程中，注意移动的顺序，假设要移动的点在目标位置的上方，我们就要先移动x轴，再移动y轴，因为我这默认目标位置是一行行完成放置的，就意味着小于x的位置都已经放置了1，如果先移动y轴就会导致已放置好的1会被移出目标位置。

如下图，红色1为已放置完成的1，深蓝色线为先移动y轴的情况，会导致同行红色的1被整体向右移动一格，而橙色路线则不会对左上角目标区域造成影响。

接着，再考虑一个问题，如果上图的蓝色的1下一格刚好存在一个1，那么会导致这个1被移动到蓝色的1的位置上，所以，枚举时要判定这个格子在移动后是变为0的。

这个思路在最坏情况下，假设 $ \frac{n^2}{4} $ 个 1 都移动步数为 $2n$，即 $\frac{n^2}{4} \times 2n = \frac{n^3}{2}$，所以一定是可行的。

代码

点击查看代码

 #include <iostream>
#include <cstring>
#include <vector>
#include <array>
 
using namespace std;
 
const int N = 100 + 10;
 
int n;
string g[N];
vector<array<int, 4>> ans;
 
void to_x(int i, int j, int x, int y)
{
    while (i < x) {
        ans.push_back({i, j, i + 1, j});
        swap(g[i][j], g[i + 1][j]);
        i ++;
    }
    while (i > x) {
        ans.push_back({i, j, i - 1, j});
        swap(g[i][j], g[i - 1][j]);
        i --;
    }
}
 
void to_y(int i, int j, int x, int y) {
    while (j < y) {
        ans.push_back({i, j, i, j + 1});
        swap(g[i][j], g[i][j + 1]);
        j ++;
    }
    while (j > y) {
        ans.push_back({i, j, i, j - 1});
        swap(g[i][j], g[i][j - 1]);
        j --;
    }
}
 
void move(int i, int j, int x, int y)
{
    if (i < x) {
        to_x(i, j, x, y);
        to_y(x, j, x, y);
    }
    else if (i > x) {
        to_y(i, j, x, y);
        to_x(i, y, x, y);
    }
    else {
        to_y(i, j, x, y);
    }
}
 
void solve()
{
    ans.clear();
    cin >> n;
    for (int i = 0; i < n; i ++) cin >> g[i];
    
    int x = 0, y = 0;
    for (int i = 0; i < n; i ++)
        for (int j = 0; j < n; j ++)
            while (g[i][j] == '1') {
                move(i, j, x, y);
                g[x][y] = '2';
                y ++;
                if (y == n / 2) x ++, y = 0;
            }
    
    cout << ans.size() << '\n';
    for (auto [i, j, x, y] : ans) 
        cout << i + 1 << ' ' << j + 1 << ' ' << x + 1 << ' ' << y + 1 << '\n';
}
 
int main()
{
    int t;
    cin >> t;
    while (t --) solve();
    return 0;
}

F.双生双宿之探

题意

给定一个数组，问有多少连续子数组是双生数组，即元素种类数为2、且出现次数相同。

思路

求连续子数组的题一般会涉及到双指针、前缀和、差分之类的算法。

首先，我们可以用双指针来维护选择的子数组区间，维护的标准是最长的恰好包含两个元素的子数组区间，我称为类双生数组。

有了上面的选择，我们接下只需要确定这个类双生数组里面有多少个双生数组。

根据双生数组的定义，我们只需要找到类双生数组中有多少个元素x和元素y的个数相等的子区间即可。

求解方法就是做前缀和：让元素x贡献为+1，元素y贡献为-1，然后做前缀和。那么怎么确定子区间是双生数组呢？就是前缀和的值相等的区间就是双生数组。

比如：

\[数组：x ~ x ~ y ~ x ~ y ~ y ~ x ~ y \\ 贡献：1 ~ 2 ~ 1 ~ 2 ~ 1 ~ 0 ~ 1 ~ 0 \\ \]

你会发现，第一个1和第二个1之间存在一个双生数组“x y”，第一个1和第二个1之间存在一个双生数组“x y x y”，第一个2和第二个2之间存在一个双生数组“y x”等等。

由此就可以得到，遍历前缀和数组，统计每个数出现次数，将每个数在此之前出现次数求和就是答案。特殊的前缀和为0时就是一个双生数组，所以要再加上本身出现的次数。

代码

点击查看代码

 #include <iostream>
#include <set>
#include <map>
 
using namespace std;
 
typedef long long ll;
 
const int N = 1e5 + 10;
 
int n;
int a[N];
 
ll get(int l, int r, int x, int y)
{
    ll res = 0, sum = 0;
    map<int, ll> s;
    for (int i = l; i <= r; i ++) {
        if (a[i] == x) sum ++;
        else sum --;
        s[sum] ++;
        if (sum == 0) res += s[sum];
        else res += s[sum] - 1;
    }
    return res;
}
 
void solve()
{
    cin >> n;
    for (int i = 1; i <= n; i ++) cin >> a[i];
    a[n + 1] = -1;
    
    set<int> v;
    map<int, ll> mp;
    ll ans = 0;
    for (int i = 1, j = 1; i <= n; i ++)
    {
        v.insert(a[i]);
        mp[a[i]] ++;
        while (v.size() > 2 && j <= i) {
            mp[a[j]] --;
            if (mp[a[j]] == 0) v.erase(a[j]);
            j ++;
        }
        
        while (v.size() <= 2 && i <= n) {
            i ++;
            v.insert(a[i]);
            mp[a[i]] ++;
        }
        if (v.size() > 2 || i > n) {
            v.erase(a[i]);
            mp[a[i]] --;
            i --;
        }
        
        if (v.size() != 2) break;
        
        int x = -1, y = -1;
        for (auto it : v) 
            if (x == -1) x = it;
            else y = it;
        ans += get(j, i, x, y);
    }
    
    cout << ans << '\n';
}
 
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    
    int t;
    cin >> t;
    
    while (t --) solve();
    
    return 0;
}

上一篇JYUACM新生训练周赛2

下一篇2025牛客寒假算法基础集训营2补题笔记

本文作者：Natural-TLP

本文链接：https://www.cnblogs.com/Natural-TLP/p/18684517

posted @ 2025-01-22 00:33 Natural_TLP 阅读(50) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

	#include <iostream>

	using namespace std;

	const int P = 1e9 + 7;

	int n;

	void solve()
	{
	bool flag = 0;
	cin >> n;
	for (int i = 1; i <= n; i ++) {
	int x;
	cin >> x;
	if (x == 1) flag = 1;
	}
	if (flag) cout << -1 << '\n';
	else cout << P << '\n';
	}

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

	int t = 1;
	cin >> t;

	while (t --) solve();

	return 0;
	}

	#include <iostream>
	#include <algorithm>
	#include <map>
	#include <set>

	#define si(x) int(x.size())
	#define fi first
	#define se second

	using namespace std;

	int n;

	void solve()
	{
	cin >> n;
	set<int> v;
	map<int, int> mp;
	for (int i = 0; i < n; i ++) {
	int x;
	cin >> x;
	mp[x] ++;
	v.insert(x);
	}

	if (n % 2 \|\| si(v) != 2) cout << "No" << '\n';
	else {
	int num = 0;
	for (auto it : mp) {
	if (num == 0) num = it.se;
	else if (num != it.se) {
	cout << "No" << '\n';
	return ;
	}
	}
	cout << "Yes" << '\n';
	}
	}

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

	int t = 1;
	cin >> t;

	while (t --) solve();

	return 0;
	}

	void solve()
	{
	cin >> n;
	for (int i = 1; i <= n; i ++) cin >> a[i];
	sort(a + 1, a + 1 + n);
	if (n % 2 \|\| a[1] == a[n]) return void(cout << "No" << '\n');
	if (a[1] == a[n / 2] && a[n / 2 + 1] == a[n]) cout << "Yes" << '\n';
	else cout << "No" << '\n';
	}

	#include <iostream>

	using namespace std;

	const int N = 1e6 + 10;

	int n, u, v;
	int a[N];

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

	int sd = -1, ed = -1;
	for (int i = 1 ; i <= n; i ++) {
	if (a[i] > 2) return void(cout << -1 << '\n');
	if (a[i] == 1)
	if (sd == -1) sd = i;
	else ed = i;
	}

	cout << sd << ' ' << ed;
	}

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

	int t = 1;

	while (t --) solve();

	return 0;
	}

	#include <iostream>
	#include <algorithm>

	#define ll long long

	using namespace std;

	const int N = 1e6 + 10;

	ll n;
	ll a[N];

	void solve()
	{
	cin >> n;
	ll sum = 0;
	for (int i = 1; i <= n; i ++) {
	cin >> a[i];
	sum += a[i];
	}

	ll num = (n + 1) * n / 2;
	if (num != sum) cout << -1;
	else {
	sort(a + 1, a + 1 + n);
	ll res = 0;
	for (int i = 1; i <= n; i ++)
	res += abs(i - a[i]);
	cout << res / 2;
	}
	}

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

	int t = 1;
	while (t --) solve();

	return 0;
	}

	#include <iostream>
	#include <algorithm>
	#include <queue>

	using namespace std;

	const int N = 1e6 + 10;

	int n;
	struct node {
	int val;
	int l, r;

	bool operator < (const node& b) const {
	return r > b.r;
	}
	} a[N];
	priority_queue<node> pq;
	int ans[N];

	bool cmp(node aa, node bb) {
	if (aa.l == bb.l) return aa.r < bb.r;
	return aa.l < bb.l;
	}

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

	sort(a + 1, a + 1 + n, cmp);
	for (int i = 1, j = 1; i <= n; i ++) {
	while (j <= n && a[j].l <= i) pq.push(a[j ++]);
	if (pq.empty() \|\| pq.top().r < i) return void(cout << -1);
	ans[pq.top().val] = i;
	pq.pop();
	}

	for (int i = 1; i <= n; i ++) cout << ans[i] << ' ';
	}

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

	solve();

	return 0;
	}

	#include <iostream>
	#include <cstring>
	#include <vector>
	#include <array>

	using namespace std;

	const int N = 100 + 10;

	int n;
	string g[N];
	vector<array<int, 4>> ans;

	void to_x(int i, int j, int x, int y)
	{
	while (i < x) {
	ans.push_back({i, j, i + 1, j});
	swap(g[i][j], g[i + 1][j]);
	i ++;
	}
	while (i > x) {
	ans.push_back({i, j, i - 1, j});
	swap(g[i][j], g[i - 1][j]);
	i --;
	}
	}

	void to_y(int i, int j, int x, int y) {
	while (j < y) {
	ans.push_back({i, j, i, j + 1});
	swap(g[i][j], g[i][j + 1]);
	j ++;
	}
	while (j > y) {
	ans.push_back({i, j, i, j - 1});
	swap(g[i][j], g[i][j - 1]);
	j --;
	}
	}

	void move(int i, int j, int x, int y)
	{
	if (i < x) {
	to_x(i, j, x, y);
	to_y(x, j, x, y);
	}
	else if (i > x) {
	to_y(i, j, x, y);
	to_x(i, y, x, y);
	}
	else {
	to_y(i, j, x, y);
	}
	}

	void solve()
	{
	ans.clear();
	cin >> n;
	for (int i = 0; i < n; i ++) cin >> g[i];

	int x = 0, y = 0;
	for (int i = 0; i < n; i ++)
	for (int j = 0; j < n; j ++)
	while (g[i][j] == '1') {
	move(i, j, x, y);
	g[x][y] = '2';
	y ++;
	if (y == n / 2) x ++, y = 0;
	}

	cout << ans.size() << '\n';
	for (auto [i, j, x, y] : ans)
	cout << i + 1 << ' ' << j + 1 << ' ' << x + 1 << ' ' << y + 1 << '\n';
	}

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

题意

思路

代码

题意

思路

代码

题意

思路

代码

题意

思路

代码

题意

思路

代码

题意

思路

代码

题意

思路

代码

题意

思路

代码

题意

思路

代码

题意

思路

代码

公告

搜索

常用链接

随笔档案