Data Mining UVA - 1591

  Dr. Tuple is working on the new data-mining application for Advanced Commercial Merchandise Inc. One of the subroutines for this application works with two arrays P and Q containing N records of data each (records are numbered from 0 to N − 1). Array P contains hash-like structure with keys. Array P is used to locate record for processing and the data for the corresponding record is later retrieved from the array Q.

  All records in array P have a size of SP bytes and records in array Q have size of SQ bytes. Dr. Tuple needs to implement this subroutine with the highest possible performance because it is a hot-spot of the whole data-mining application. However, SP and SQ are only known at run-time of application which complicates or makes impossible to make certain well-known compile-time optimizations.

  The straightforward way to find byte-offset of i-th record in array P is to use the following formula:

                Pofs(i) = SP · i, (1)

and the following formula for array Q:

                 Qofs(i) = SQ · i. (2)

  However, multiplication computes much slower than addition or subtraction in modern processors. Dr. Tuple avoids usage of multiplication while scanning array P by keeping computed byte-offset Pofs(i) of i-th record instead of its index i in all other data-structures of data-mining application. He uses the following simple formulae when he needs to compute byte-offset of the record that precedes or follows i-th record in array P:

                Pofs(i + 1) = Pofs(i) + SP

                Pofs(i − 1) = Pofs(i) − SP

  Whenever a record from array P is located by either scanning of the array or by taking Pofs(i) from other data structures, Dr. Tuple needs to retrieve information from the corresponding record in array Q. To access record in array Q its byte-offset Qofs(i) needs to be computed. One can immediately derive formula to compute Qofs(i) with known Pofs(i) from formulae (1) and (2):

                 Qofs(i) = Pofs(i)/SP · SQ (3)

  Unfortunately, this formula not only contains multiplication, but also contains division. Even though only integer division is required here, it is still an order of magnitude slower than multiplication on modern processors. If coded this way, its computation is going to consume the most of CPU time in data-mining application for ACM Inc.

  After some research Dr. Tuple has discovered that he can replace formula (3) with the following fast formula:

​ Qofs’(i) = (Pofs(i) + Pofs(i) << A) >> B (4)

  where A and B are non-negative integer numbers, “<< A” is left shift by A bits (equivalent to integer multiplication by 2A), “ >> B” is right shift by B bits (equivalent to integer division by 2B).

  This formula is an order of magnitude faster than (3) to compute, but it generally cannot always produce the same result as (3) regardless of the choice for values of A and B. It still can be used if one is willing to sacrifice some extra memory.

  Conventional layout of array Q in memory (using formula (2)) requires N · SQ bytes to store the entire array. Dr. Tuple has found that one can always choose such K that if he allocates K bytes of memory for the array Q (where K ≤ N ·SQ) and carefully selects values for A and B, the fast formula (4) will give non-overlapping storage locations for each of the N records of array Q.

  Your task is to write a program that finds minimal possible amount of memory K that needs to be allocated for array Q when formula (4) is used. Corresponding values for A and B are also to be found. If multiple pairs of values for A and B give the same minimal amount of memory K, then the pair where A is minimal have to be found, and if there is still several possibilities, the one where B is minimal. You shall assume that integer registers that will be used to compute formula (4) are wide enough so that overflow will never occur.

Input

  Input consists of several datasets. Each dataset consists of three integer numbers N, SP, and SQ separated by spaces (1 ≤ N ≤ 2^20,1 ≤ SP ≤ 2^10,1 ≤ SQ ≤ 2^10).

Output

  For each dataset, write to the output file a single line with three integer numbers K, A, and B separated by spaces.

Sample Input

20 3 5

1024 7 1

Sample Output

119 0 0

1119 2 5

HINT

   这个题是参照vj上下面评论的一个大佬写的，虽然想到了等差之类的，但没有想到k的取值公式。这个题从公式上面看可以知道是一个等差公式，那么要保证映射后的下标不会出现位置重复那么公差就必须(p + (p << i)) >> j)/q大于1，否则，比如1和1.2和1.8转换为整数后都是1，那么当公差大于1的话，计算出来的每一个下标比前一个都大于1就不会出现重复的现象。

  下一个要解决的问题就是如何来表示k的取值，因为每一个映射的下标都不会重复，那么最后一个最大的映射之后获得的也是最大的就是k的值，然后每一次比较获得更小的一个。因此比较公式就是(p * (n - 1) + ((p * (n - 1)) << i)) >> j) + q。最后一个是n-1，不是n，0......n-1。另外需要注意的是位运算符的优先级以及int 范围的k很可能会越界。下面是代码：

Accepted

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>

int main()
{
	long long int n, p, q;
	while (scanf("%lld %lld %lld", &n, &p, &q) != EOF)
	{
		long long int k = 9223372036854775807;
		int a, b;
		for (int i = 0;i < 32;i++)
		{
			for (int j = 0;j < 32;j++)
			{
				if ((p + (p << i)) >> j >= q && (k > ((p * (n - 1) + ((p * (n - 1)) << i)) >> j) + q))
				{
					k = ((p * (n - 1) + ((p * (n - 1)) << i)) >> j) + q;
					a = i;b = j;
				}
			}
		}
		printf("%lld %d %d\n", k, a, b);
	}
}