ACM练级日志：POJ 2886 约瑟夫环，线段树和反素数

我昨天才知道模拟约瑟夫环是可以用线段树来解的……

不妨假设总共有N个人，他们的编号是1~N（这个编号很重要，影响到后面的推导）

怎么解呢？我们用一棵线段树，每个节点记录一下这个区间还剩下多少人，一开始当然就是R-L+1个人了。

然后我们要做的事情就是，每次先求出这次要出列的“绝对位置”，然后用线段树查一查这个绝对位置上站的是谁。

所谓“绝对位置”，就是1~N，不会变的，比如第一个出列的是2，那么绝对位置2那里站的应该是3，下次当你看到绝对位置2要出列的时候，就知道实际上要出列的人应该是3了。

以POJ 2886的样例为例：

绝对位置	1	2	3	4
实际站的人	1	2（+4）	3	4
	1		3（-1）	4
	1（out）			4
				4（最后留下）

有了这个概念之后，我们就可以用线段树求解“一个绝对位置上的人站的究竟是谁”的问题了。非常简单，如果我问x号上面站的是谁，那么我就看看左边是不是够x个，如果够x个，说明答案肯定在左子树里，否则就去右子树找x- node[p*2].count 即可。最后找到叶子节点就是所求的人。

找到以后删除之就是典型的单点删除操作，非常简单。

这道题还多多少少用到了一点反素数…… 反素数是说，一个数x是反素数，当且仅当所有比x小的数i，i的约数个数都小于x的约数个数。显然对于一个给定的n，最接近n的反素数就是我们要找的目标。比如n是5，那么我们就要找到第4个出队的人是谁。这样，由于50w以内的反素数十分有限，我们可以提前打表，然后知道n以后立刻找出目标反素数。当然暴力从复杂度上讲也没问题……

代码中还有一些细节问题，在注释里说吧。

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<algorithm>
#define D(x) cout<<#x<<" "<<x<<endl
using namespace std;

int n,k;

struct ntype
{
int l,r;
int count;
} node[2000200];

struct stype
{
char namae[20];
int v;
};
stype student[500010];

int max_candy = 0;

const int antiprime[] = {1,2,4,6,12,24,36,48,60,120,180,240,360,720,840,
1260,1680,2520,5040,7560,10080,15120,20160,25200,27720,45360,50400,
55440,83160,110880,166320,221760,277200,332640,498960,554400};  // 反素数

const int factor[] = {1,2,3,4,6,8,9,10,12,16,18,20,24,30,32,36,40,48,60,64,72,
80,84,90,96,100,108,120,128,144,160,168,180,192,200,216};  // 反素数的约数个数

void del(int s, int e, int p, int tar) // 线段树单点删除tar号人
{
node[p].count--;
if(s==e)
return;

int mid = (s+e)/2;
if(tar<=mid)
del(s,mid, p*2, tar);
else
del(mid+1, e, p*2+1, tar);

return;
}

int ask(int s, int e, int p, int q)// 询问q上站的是谁
{
if(s==e)
{
return s;
}

int mid = (s+e)/2;

if(node[p*2].count >= q)
return ask(s, mid, p*2, q);

else
return ask(mid+1, e, p*2+1, q - node[p*2].count);
}

int prepare() // 准备好目标反素数和他的约数个数
{
int ret_p = upper_bound(antiprime, antiprime + 36, n) - 1 - antiprime;

//D(ret_p);
int ret = antiprime[ret_p];
max_candy = factor[ret_p];
return ret;
}

void build(int s, int e, int p)
{
node[p].l=s;
node[p].r=e;
node[p].count= e-s+1;

if(s==e)
return;

int mid = (s+e)/2;
build(s,mid, p*2);
build(mid+1, e, p*2+1);

return;
}

void init()
{
memset(node,0,sizeof(node));
memset(student, 0, sizeof(student));
max_candy = 0;
return;
}

int main()
{
while(scanf("%d %d", &n,&k)!=EOF)
{
init();

int i;
for(i=1;i<=n;i++)
{
scanf("%s %d", student[i].namae, &student[i].v);
}

build(1,n,1);

int end = prepare();

int now_absolute=k;
int now_real;
for(i=1;i<=end;i++)
{
//D(now_absolute);
now_real = ask(1,n,1, now_absolute);
//D(now_real);

del(1,n,1,now_real);
if(i==n)
break;

if(student[now_real].v > 0)
{
now_absolute = now_absolute - 1 -1 + student[now_real].v; // 第一个-1是因为我们从1开始标号，要先-1；第二个-1是因为我们要往右数，必须先退一格
now_absolute %= n-i;
now_absolute = (now_absolute + (n-i) ) % (n-i);
now_absolute +=1; // +1 是为了恢复成1~N
}
else
{
now_absolute = now_absolute - 1 + student[now_real].v; //第一个-1原因同上，由于我们是让右边的人靠过来，所以往左数不必再-1
now_absolute %= n-i;
now_absolute = (now_absolute + (n-i) ) % (n-i); // 取模避免出现负数的方法：先模，然后加，再模
now_absolute += 1;
}
}

printf("%s %d\n", student[now_real].namae, max_candy);
//system("pause");
}
return 0;
}