题目大意：

给你n、m、d
n为元素个数,m为数列长度,d为每个元素之间的最短间隔

问最少需要多少个数列可以使得元素都能装进数列，并且满足每个元素之间的间隔大于等于d

核心思想

使用贪心的思想，将元素的大小进行排序，问题出在必须要优化，不能直接模拟，否则会超时

思路1

使用vector和二分进行处理，
用nums记录原数组
维护一个order动态数组记录原数组从小到大的数分别对应的下标是什么
放置策略是按order数组中%k余数相同的元素放到一个数列，即1,2,…,k,1,2,…k
然后用二分假设多少个数组可以满足要求，其中二分的判定条件就是
$nums[order[i]]-nums[order[i-m]]<=d$
m代表二分的中间值，这里是判断原数组中第i大的数-第i-m大的数之间的间隔是否大于等于d
满足后使用map将%k余数相同的元素放到同一组，最后按照顺序从小到大输出即可

// Author: zengyz
// 2025-06-07 10:59

#include <bits/stdc++.h>

using namespace std;
using i64 = long long;

const int N = 2e5 + 10;

void solve()
{
  int n, m, d;
  cin >> n >> m >> d;
  vector<int> nums(n);
  for (auto &v : nums)
    cin >> v;
  vector<int> order(n);
  iota(order.begin(), order.end(), 0);
  sort(order.begin(), order.end(), [&](int i, int j)
       { return nums[i] < nums[j]; });
  int l=1,r=n;
  while(l<=r)
  {
   int m = (l + r) / 2;
    bool flg=true;
    for(int i=m;i<n;i++)
    {
      if(nums[order[i]]-nums[order[i-m]]<=d)
      {
        flg=false;
        break;
      }
    }
    if (flg) r = m - 1;
        else l = m + 1;
  }
  cout<<l<<endl;
  vector<int>ans(n);
for(int i=0;i<n;i++)
ans[order[i]]=i%l+1;
for(auto &x:ans)cout<<x<<" ";
}

int main()
{
  ios::sync_with_stdio(0);
  cin.tie(0), cout.tie(0);
  int _T = 1;
  // cin >> _T;
  while (_T--)
  {
    solve();
  }
  return 0;
}

思路2

使用优先队列

维护一个递增优先队列p，其中维护每一个数列的已经放置的最后一个元素
先将元素排序后将最小的元素放到优先队列，并定义它为第一个队列的元素(ans[b[1]]=1)
每次判断从优先队列中拿出队头元素（最小），如果满足要求可以放置，那么把这个元素从队头中移除，并把这个元素放到和队头元素相同的数列中ans[b[i]]=ans[b[top]]
否则就新开一个队列，最后把这次判断的元素放到优先队列中：
1.满足要求可以放置，那么因为队头元素已经被移除，那么这个元素就代表着队头元素所在队列
2.不可以放置，那么它新开一个队列，它本身就代表了一个新的队列，也把它放到优先队列中

// Author: zengyz
// 2025-06-07 10:59

#include <bits/stdc++.h>

using namespace std;
using i64 = long long;

const int N = 2e5 + 10;
int a[N];
int b[N];
map<int,int>ans;
void solve()
{
  int n, m, d;
  cin >> n >> m >> d;
  priority_queue<int, vector<int>, greater<int>> p;
  for (int i = 1; i <= n; i++)
  {
    cin >> a[i];
    b[i] = a[i];
  }
  sort(b + 1, b + 1 + n);
  int cnt = 1;

  p.push(1);
  ans[b[1]] = 1;
  for (int i = 2; i <= n; i++)
  {
    auto top = p.top();
    if (b[i] - b[top] > d)
    {
      p.pop();
      ans[b[i]] = ans[b[top]];
    }
    else
    {
      ans[b[i]] = ++cnt;
    }
    p.push(i);
  }

  cout << cnt << endl;
  for (int i = 1; i <= n; i++)
  {
    cout << ans[a[i]] << " ";
  }

  return;
}

int main()
{
  ios::sync_with_stdio(0);
  cin.tie(0), cout.tie(0);
  int _T = 1;
  // cin >> _T;
  while (_T--)
  {
    solve();
  }
  return 0;
}

思路3

set+结构体
思路借鉴自：https://www.cnblogs.com/Chen-Jr/p/11007190.html
定义一个结构体，id表示元素的原位置，确定它的排序规则为按val排序
先将数据读取，然后使用set对结构体进行存储
使用lower_bound(其实也是二分)来查询当前集合中有没有满足要求的
定义tmp=当前元素值+间隔，即要放入当前元素所需要的最小值
不满足
$st.lower\_bound(Node(tmp,-1))==st.end()$
即集合中没有找到，那么新开一个数组，tmp清零

否则将满足的元素取出
tmp值更新，b数组记录每个元素未排序之前的位置，并将当前元素对应的位置标记上为第几天，然后将该元素从集合中删除

其实就是在集合中不断找最小的能够满足数，满足就把当前的数接在这个元素之后，并把找到的元素删除

// Author: zengyz
// 2025-06-07 10:59

#include <bits/stdc++.h>

using namespace std;
using i64 = long long;
struct Node
{
  int val, id;
  bool operator<(const Node &b) const
  {
    if (val == b.val)
      return id < b.id;
    else
      return val < b.val;
  }
  Node(int _val, int _id)
  {
    val = _val, id = _id;
  }
};
set<Node> st;

const int N = 2e5 + 10;
int a[N];
int b[N];
map<int, int> ans;
void solve()
{
  int n, m, d;
  cin >> n >> m >> d;
  for (int i = 1; i <= n; i++)
  {
    int num;
    cin >> num;
    st.insert(Node(num, i));
  }
  i64 tmp = 0, day = 1;
  while (!st.empty())
  {
    if (st.lower_bound(Node(tmp, -1)) == st.end())
    {
      tmp = 0;
      day++;
    }
    else
    {
      auto it = *st.lower_bound(Node(tmp, -1));
      tmp = it.val + d + 1;
      b[it.id] = day;
      st.erase(it);
    }
  }
  cout << day << endl;
  for (int i = 1; i <= n; i++)
    cout << b[i] << " ";
  return;
}

int main()
{
  ios::sync_with_stdio(0);
  cin.tie(0), cout.tie(0);
  int _T = 1;
  // cin >> _T;
  while (_T--)
  {
    solve();
  }
  return 0;
}