POJ 2886 Who Gets the Most Candies? 线段树

/**
* @file main.cpp
* @brief 线段树+反质数理论
*        基本思路是模拟约瑟夫环问题,求出第p个出圈的小朋友
*        而p的值是小于等于小朋友总数n的最大的反质数
*
*        不对反质数理论尽心更深探究,因为现在进行线段树以及树状数组专题训练
*
*        基本算法是树状数组,每一个区间用以表示该区间内还剩下多少个小朋友,
*        例如输入数据:
*        4 2
*        Tom 2
*        Jack 4
*        Mary -1
*        Sam 1
*
*        1. 初始树:
*               1-4[4]
*           /         \
*         1-2[2]       3-4[2]
*        /   \        /   \
*       1[1]  2[1]   3[1]  4[1]
*
*
*        2. 第一轮出队, k==2,2号小朋友(index=2)出队后:
*               1-4[3]
*           /         \
*         1-2[1]       3-4[2]
*        /   \        /   \
*       1[1]  2[0]   3[1]  4[1]
*
*       由小朋友k算下一个小朋友序号的方法是:
*       if num > 0:
*          k = k + num - 1 (因为自己要出队)
*       else
*          k = k + num
*
*       根据 Jack 4以及k==2计算得出k==2
*
*       3. 第二轮出队,又是2号小朋友(index=3)出队:
*               1-4[2]
*           /         \
*         1-2[1]       3-4[1]
*        /   \        /   \
*       1[1]  2[0]   3[0]  4[1]
*
*       根据 Mary -1以及k==2计算k==1
*
*       4. 第三轮出队,1号小朋友(index=1)出队
*               1-4[1]
*           /         \
*         1-2[0]       3-4[1]
*        /   \        /   \
*       1[0]  2[0]   3[0]  4[1]
*
*       5. 最终
*               1-4[0]
*           /         \
*         1-2[0]       3-4[0]
*        /   \        /   \
*       1[0]  2[0]   3[0]  4[0]
*
* @author yekeren
* @version 1.0.0
* @date 2013-06-13
*/
#include <stdio.h>

#define LEFT(x) (((x) << 1) + 1)
#define RIGHT(x) (((x) << 1) + 2)

///<小朋友名字及编号
struct child_t {
char name[11];
int  num;
} child[510001];

///<树状数组
int range[1100001] = { 0 };

///<反质数及其约数个数
int rprime[] = { 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 };

int fact[] = { 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 };

/**
* @brief 建立树状数组
* @param root
* @param left
* @param right
*/
void build(int root, int left, int right)
{
range[root] = right - left + 1;

if (left == right) {
return;
}

int mid = (left + right) >> 1;
build(LEFT(root), left, mid);
build(RIGHT(root), mid + 1, right);
}

/**
* @brief 查找圈中的第k个小朋友
* @param root
* @param left
* @param right
* @param k
* @return
*/
int find(int root, int left, int right, int k)
{
while (left < right)
{
--range[root];

int mid = (left + right) >> 1;
if (k <= range[LEFT(root)])
{
root = LEFT(root);
right = mid;
}
else
{
k -= range[LEFT(root)];
root = RIGHT(root);
left = mid + 1;
}

}
--range[root];
return left;
}

/**
* @brief 查找小于等于n的最大的反质数
* @param n
* @return
*/
int find_rprime(int n)
{
int left  = 0;
int right = sizeof(rprime) / sizeof(rprime[0]) - 1;

while (left < right)
{
int mid = (left + right) >> 1;
if (n > rprime[mid]) {
left = mid + 1;
} else if (n < rprime[mid]) {
right = mid - 1;
} else {
return mid;
}
}
while (left >= 0 && rprime[left] > n) --left;
return left;
}

int main(int argc, char *argv[])
{
int n, k;
while (scanf("%d%d", &n, &k) == 2)
{
for (int i = 1; i <= n; ++i) {
scanf("%s%d", child[i].name, &child[i].num);
}

build(0, 1, n);

int index = 0;
int order_index = find_rprime(n);
int order = rprime[order_index];

for (int i = 1; i <= order; ++i)
{
k = k % (n - i + 1);
if (k <= 0) {
k += n - i + 1;
}

index = find(0, 1, n, k);

int num = child[index].num;
if (num > 0) {
k = k + num - 1;
} else {
k = k + num;
}
}
printf("%s %d\n", child[index].name, fact[order_index]);
}
return 0;
}