Joseph sequence
At present, the most common Joseph solutions are implemented through violent simulation . Even python The complexity of array slicing is far less than O(nlogn) If the situation is bad enough , Then the complexity of slicing can reach O(n^2) It's no different from violence .
Then we use the line segment tree to count the number , To record the subscript . In this way, you can quickly query .

Accepted Code

//#include<unordered_map>
#include<algorithm>
#include<iostream>
#include<string.h>
#include <iomanip>
#include<stdio.h>
#include<vector>
#include<string>
#include<math.h>
#include<cmath>
#include<queue>
#include<stack>
#include<deque>
#include<map>
#include<set>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll ll_inf = 9223372036854775807;
const int int_inf = 2147483647;
const short short_inf = 32767;
const ll less_inf = 0x3f3f3f3f;
const char char_inf = 127;
#pragma GCC optimize(2)
#define accelerate cin.tie(NULL);cout.tie(NULL);ios::sync_with_stdio(false);
#define PI 3.141592653589793
#define EPS 1.0e-8
ll gcd(ll a, ll b) {
    
	return b ? gcd(b, a % b) : a;
}
ll lcm(ll a, ll b) {
    
	return a / gcd(a, b) * b;
}
inline ll read() {
    
	ll c = getchar(), Nig = 1, x = 0;
	while (!isdigit(c) && c != '-')c = getchar();
	if (c == '-')Nig = -1, c = getchar();
	while (isdigit(c))x = ((x << 1) + (x << 3)) + (c ^ '0'), c = getchar();
	return Nig * x;
}
inline void out(ll a) {
    
	if (a < 0)putchar('-'), a = -a;
	if (a > 9)out(a / 10);
	putchar(a % 10 + '0');
}
ll qpow(ll x, ll n, ll mod) {
    
	ll res = 1;
	while (n > 0) {
    
		if (n & 1)res = (res * x) % mod;
		x = (x * x) % mod;
		n >>= 1;
	}
	return res;
}
#define read read()
const int N = 1e5 + 7;
ll tree[N * 4];
void push_up(int rt)
{
    
	tree[rt] = tree[rt << 1] + tree[rt << 1 | 1];
}
int Get_id(int val, int l, int r, int rt)
{
    
	if (l == r)return l;
	int mid = l + r >> 1;
	if (val <= tree[rt << 1])return Get_id(val, l, mid, rt << 1);
	return Get_id(val - tree[rt << 1], mid + 1, r, rt << 1 | 1);
}
void update(int pos, int l, int r, int rt)
{
    
	if (l == r)tree[rt] = 0;
	else
	{
    
		int mid = l + r >> 1;
		if (pos <= mid)update(pos, l, mid, rt << 1);
		else update(pos, mid + 1, r, rt << 1 | 1);
		push_up(rt);
	}
}
void creat(int l, int r, int rt)
{
    
	if (l == r)
	{
    
		tree[rt] = 1;
		return;
	}
	int mid = l + r >> 1;
	creat(l, mid, rt << 1);
	creat(mid + 1, r, rt << 1 | 1);
	push_up(rt);
}
queue<int>q;
int main()
{
    
	int n = read, m = read;
	creat(1, n, 1);
	int now = 0;
	while (tree[1])
	{
    
		now = (now + m) % tree[1];
		if (now == 0)now = tree[1];
		int pos = Get_id(now, 1, n, 1);
		update(pos, 1, n, 1);
		now--;
		q.push(pos);
	}
	out(q.front());
	q.pop();
	while (!q.empty())
	{
    
		putchar(' ');
		out(q.front());
		q.pop();
	}
	puts("");
}

By-Round Moon