Given a fraction a/b, write it as a sum of different Egyptian fraction. For example, 2/3 = 1/2 + 1/6. Thereisonerestrictionthough: thereare k restrictedintegersthatshouldnotbeusedasadenominator. For example, if we can’t use 2..6, the best solution is:
2/3 = 1/7 + 1/9 + 1/10 + 1/12 + 1/14 + 1/15 + 1/18 + 1/28 The number of terms should be minimized, and then the large denominator should be minimized. If there are several solutions, the second largest denominator should be minimized etc.

The first line contains the number of test cases T (T ≤ 100). Each test case begins with three integers a, b, k (2 ≤ a < b ≤ 876, 0 ≤ k ≤ 5, gcd(a,b) = 1). The next line contains k different positive integers not greater than 1000.

For each test case, print the optimal solution, formatted as below. Extremely Important Notes It’s not difficult to see some inputs are harder than others. For example, these inputs are very hard input for every program I have: 596/829=1/2+1/5+1/54+1/4145+1/7461+1/22383 265/743=1/3+1/44+1/2972+1/4458+1/24519 181/797=1/7+1/12+1/2391+1/3188+1/5579 616/863=1/2+1/5+1/80+1/863+1/13808+1/17260 22/811=1/60+1/100+1/2433+1/20275 732/733=1/2+1/3+1/7+1/45+1/7330+1/20524+1/26388 However, I don’t want to give up this problem due to those hard inputs, so I’d like to restrict the input to “easier” inputs only. I know that it’s not a perfect problem, but it’s true that you can still have fun and learn something, isn’t it? Some tips: 1. Watch out for floating-point errors if you use double to store intermediate result. We didn’t use double. 2. Watch out for arithmetic overflows if you use integers to store intermediate result. We carefully checked our programs for that.

 Sample Input

 Sample Ouput

Case 1: 2/3=1/2+1/6

Case 2: 19/45=1/5+1/6+1/18

Case 3: 2/3=1/3+1/4+1/12

Case 4: 5/121=1/33+1/121+1/363

Case 5: 5/121=1/45+1/55+1/1089

题解：IDA*算法，标注的是困难版本，其实和lrj在之前讲的没什么区别。只要是这个算法，主框架就都是一样的。我在之前的博客里提到过是否需要d==maxd的判断，由于这个题估价函数的特点，这句话是需要的。估价函数很好理解，如果在接下来的搜索中，即便分数的大小都是目前最大的数也无法达到目标，必然就要剪枝。

 #include <bits/stdc++.h>

 using namespace std;

 typedef long long LL;

 const int maxn =  + ;

 int k, maxd;

 bool canuse[maxn];

 LL a, b;

 LL ans[maxn],v[maxn];

 LL gcd(LL a, LL b) {

     return b ==  ? a : gcd(b, a%b);

 }

 LL get_first(LL a, LL b) {

     return (b - ) / a + ;

 }

 bool better(int d) {

     for (int i = d; i >= ; i--) {

         if (v[i] != ans[i]) {

             return ans[i] == - || v[i] < ans[i];

         }

     }

     return false;

 }

 bool dfs(int d, LL from, LL a, LL b) {

     if (d == maxd) {

         if (b%a) return false;

         v[d] = b / a;

         if (v[d]<= && !canuse[v[d]]) return false;

         if (better(d)) memcpy(ans, v, (d+) * sizeof(LL));

         return true;

     }

     bool ok = false;

     for (LL i = max(from, get_first(a, b));; i++) {

         if(i<= && !canuse[i]) continue;

         if (b*(maxd +  - d) <= i * a) break;

         v[d] = i;

         LL b2 = b * i,a2 = a * i - b;

         LL g = gcd(a2, b2);

         if (dfs(d + , i + , a2 / g, b2 / g)) ok = true;

     }

     return ok;

 }

 int main()

 {

     int iCase = ;

     int T;

     scanf("%d", &T);

     while (T--) {

         scanf("%lld%lld%d", &a, &b, &k);

         memset(canuse, true, sizeof(canuse));

         int x;

         while(k--){

             scanf("%d", &x);

             canuse[x] = false;

         }

         printf("Case %d: ", iCase++);

         for (maxd = ;; maxd++) {

             memset(ans, -, sizeof(ans));

             if (dfs(,get_first(a,b), a, b)) break;

         }

         printf("%lld/%lld=1/%lld", a, b, ans[]);

         for (int i = ; i <= maxd; i++) {

             printf("+1/%lld", ans[i]);

         }

         printf("\n");

     }

     return ;

 }