CodeForces - [ACM-ICPC Jiaozuo Onsite D]Resistors in Parallel(高精度C++)

题目链接：https://codeforces.com/gym/102028/problem/E
Time limit: 2.0 s Memory limit: 1024 MB

Problem Description

In this physics problem, what we are concerned about are only resistors. If you are poor at physics, do not worry, since solving this problem does not require you to have advanced abilities in physics.

Resistors are said to be connected together in parallel when both of their terminals are respectively connected to each terminal of the other resistors.

We have the following parallel resistor equation for $k$ resistors with resistances $R_1,R_2,...,R_k$ in parallel and their combined resistance $R$:
$$R=\frac{1}{\frac{1}{R_1}+\frac{1}{R_2}+\cdots +\frac{1}{R_k}}.$$
Now you have $n$ resistors, the $i$-th of which has a resistance of $r_i$ ohms with the equation
$$r_i=\{\begin{array}{ll}\infty & \text{if }i\text{ can be divided by }{d}^2\text{for some integers }d\ge 2\\ i& \text{otherwise. }\end{array}$$
You also have $n$ selections, the $i$-th of which is a set of resistors $S_i$ such that
S i = {  the  j  -th resistor  ∣   j  is a divisor of  i } . S_{i}=\{\text { the } j \text { -th resistor } |\ j \text { is a divisor of } i\}. Si​={ the j -th resistor ∣ j is a divisor of i}.
Please find a selection in which the resistors form a parallel resistor with the minimum resistance and output the reduced fraction $\frac{p}{q}$ of its resistance.

Input

The input contains several test cases, and the first line contains a positive integer $T$ indicating the number of test cases which is up to $100$.

For each test case, the only one line contains an integer $n$, where $1\le n\le 10^{100}$.

Output

For each test case, output a line containing a reduced fraction of the form $p/q$ indicating the minimum possible resistance, where $p$ and $q$ should be positive numbers that are coprime.

Example

Input

3
10
100
1000

Output

1/2
5/12
35/96

Problem solving report:

Description：如果$i$是完全平方数$(⩾4)$的倍数，那么$i$号电阻的阻值为无穷大，否则为$i$。
现在有编号为$1\sim n$的集合，每个集合包含若干个电阻，编号为$i$的集合包含所有编号为$i$的约数的电阻。求一个集合，使该集合内所有电阻的并联阻值最小。
Problem solving：

• 首先，对于一个电阻，如果它能改变总电阻，那么它的阻值不是无穷大，因此它的每个质因子最多被乘了一次。所以对于每个电阻的集合，它的编号的约数中，只有$1$、质因数、以及若干个不同质因数的积是有效的。另外，如果一个数的约数包含了若干个质因数，那么这个数的约数也必然包含这些质因数的积。
• 并联越多小电阻，总电阻越小，那就从最小的电阻开始选，越多越好，并且每个质因子只考虑一次。能选第$i$个素数时，$n$应该不小于前$i$个素数的乘积，这样才能保证前$i$个素数在前$i$个集合中同时出现在某一个集合内。
• 选出包含前$i$个素数的集合之后，该集合内的电阻应包括该$i$个素数和该$i$个素数所有组合出的乘积。设已经求出的电阻倒数之和为$sum$，下一个素数为$p$。则加入下一个电阻时有$sum=sum\ast (1+1/p)$，这样就可以很顺利的求出最终结果的倒数。因为要输出成分数形式，所以在递推的过程要分别保存分子和分母，最后输出前记得约分。

Accepted Code:

/* 
 * @Author: lzyws739307453 
 * @Language: C++ 
 */
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 5;
bool isp[MAXN];
char str[MAXN];
int pre[MAXN], cnt;
struct edge {
    int p[MAXN], size;
    edge() {//初始化
        size = 0;
        memset(p, 0, sizeof(p));
    }
    int cmp(edge b) {//高精度比大小
        if (size > b.size) return 1;
        if (size < b.size) return -1;
        for (int i = size - 1; ~i; i--) {
            if (p[i] > b.p[i]) return 1;
            if (p[i] < b.p[i]) return -1;
        }
        return 0;
    }
    edge mul(int b) {//高精度*单精度
        edge c;
        int t = 0;
        for (int i = 0; i < size || t; i++) {
            if (i < size)
                t += p[i] * b;
            c.p[c.size++] = t % 10;
            t /= 10;
        }
        return c;
    }
    edge Mul(edge b) {//高精度*高精度
        edge c;
        int t = 0;
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < b.size; j++) {
                t += p[i] * b.p[j];
                c.p[i + j] += t % 10;
                t /= 10;
            }
        }
        c.size = size + b.size - 1;
        while (t) {
            c.p[c.size++] = t % 10;
            t /= 10;
        }
        return c;
    }
    edge Sub(edge b) {//高精度-高精度
        edge c;
        int t = 0;
        for (int i = 0; i < size; i++) {
            t = p[i] - t;
            if (i < b.size)
                t -= b.p[i];
            c.p[i] = (t + 10) % 10;
            t = t < 0;
        }
        c.size = size;
        while (c.size > 1 && !c.p[c.size - 1]) --c.size;
        return c;
    }
    edge Div(edge b) {//高精度/高精度
        edge quo, rem = *this;
        quo.size = 1, quo.p[0] = 0;
        if (rem.cmp(b) < 0)
            return quo;
        quo.size = rem.size - b.size;
        for (int i = rem.size - 1; ~i; i--) {
            if (i >= quo.size) b.p[i] = b.p[i - quo.size];
            else b.p[i] = 0;
        }
        b.size = rem.size;
        for (int i = 0; i <= quo.size; i++) {
            while (rem.cmp(b) >= 0) {
                rem = rem.Sub(b);
                quo.p[quo.size - i]++;
            }
            for (int j = 0; j < b.size - 1; j++)
                b.p[j] = b.p[j + 1];
            --b.size;
        }
        ++quo.size;
        while (quo.size > 1 && !quo.p[quo.size - 1]) --quo.size;
        return quo;
    }
    edge Mod(edge b) {//高精度%高精度
        edge quo, rem = *this;
        quo.size = 1, quo.p[0] = 0;
        if (rem.cmp(b) < 0)
            return rem;
        quo.size = rem.size - b.size;
        for (int i = rem.size - 1; ~i; i--) {
            if (i >= quo.size) b.p[i] = b.p[i - quo.size];
            else b.p[i] = 0;
        }
        ++quo.size;
        b.size = rem.size;
        for (int i = 0; i < quo.size; i++) {
            while (rem.cmp(b) >= 0) {
                rem = rem.Sub(b);
                quo.p[quo.size - i - 1]++;
            }
            for (int j = 0; j < b.size - 1; j++)
                b.p[j] = b.p[j + 1];
            --b.size;
        }
        while (rem.size > 1 && !rem.p[rem.size - 1]) --rem.size;
        return rem;
    }
	edge gcd(edge b) {//高精度取最大公约数
		if (!b.p[0] && b.size == 1)
			return *this;
		return b.gcd(Mod(b));
	}
};
void Get_prime(int n) {//质数筛
    cnt = 0;
    for (int i = 2; i < n; i++) {
        if (!isp[i])
            pre[cnt++] = i;
        for (int j = 0; i * pre[j] < n && j < cnt; j++) {
            isp[i * pre[j]] = true;
            if (!(i % pre[j]))
                break;
        }
    }
}
int main() {
    int t;
    Get_prime(300);
    scanf("%d", &t);
    while (t--) {
        edge m, Mol, Den;
        scanf("%s", str);
        int len = strlen(str);
        for (int i = 0; i < len; i++)
            m.p[len - i - 1] = str[i] - '0';
        m.size = len;
        Mol.size = 1, Mol.p[0] = 1;
        Den.size = 1, Den.p[0] = 1;
        for (int i = 0; Mol.mul(pre[i]).cmp(m) <= 0; i++) {
            Mol = Mol.mul(pre[i]);
            Den = Den.mul(pre[i] + 1);
        }
        edge Gcd = Den.gcd(Mol);
        Mol = Mol.Div(Gcd), Den = Den.Div(Gcd);
        for (int i = Mol.size - 1; ~i; i--)
            printf("%d", Mol.p[i]);
        printf("/");
        for (int i = Den.size - 1; ~i; i--)
            printf("%d", Den.p[i]);
        printf("\n");
    }
    return 0;
}