1374 - Power Calculus

Starting with x andrepeatedly multiplying by x, we can compute x³¹ withthirty multiplications:

x² = x x x,     x³ = x² x x,     x⁴ = x³ x x,     ... ,     x³¹ = x³⁰ x x.

The operation of squaring can appreciablyshorten the sequence of multiplications. The following is a way tocompute x³¹ with eight multiplications:

x² = x x x,     x³ = x² x x,     x⁶ = x³ x x³,     x⁷ = x⁶ x x,     x¹⁴ = x⁷ x x⁷, 
x¹⁵ = x¹⁴ x x,     x³⁰ = x¹⁵ x x¹⁵,     x³¹ = x³⁰ x x.

This is not the shortest sequence of multiplicationsto compute x³¹. There are many ways with only sevenmultiplications. The following is one of them:

x² = x x x,     x⁴ = x² x x²,     x⁸ = x⁴ x x⁴,     x¹⁰ = x⁸ x x², 
x²⁰ = x¹⁰ x x¹⁰,     x³⁰ = x²⁰ x x¹⁰,     x³¹ = x³⁰ x x.

There however is no way to compute x³¹ withfewer multiplications. Thus this is one of the most efficient ways tocompute x³¹ only by multiplications.

If division is also available, we can finda shorter sequence of operations. It is possible to compute x³¹ withsix operations (five multiplications and one division):

x² = x x x,     x⁴ = x² x x²,     x⁸ = x⁴ x x⁴,     x¹⁶ = x⁸ x x⁸,     x³² = x¹⁶ xx¹⁶,     x³¹ = x³² ÷ x.

This is one of the most efficient ways tocompute x³¹ if a division is as fast as amultiplication.

Your mission is to write a program to findthe least number of operations to compute xⁿ bymultiplication and division starting with x for the givenpositive integer n. Products and quotients appearing in thesequence of operations should be x to a positive integer'spower. In other words, x^-3, for example, should neverappear.

Input 

The input is a sequence of one or morelines each containing a single integer n. n ispositive and less than or equal to 1000. The end of the input is indicated by azero.

Output 

Your program should print the least totalnumber of multiplications and divisions required to compute xⁿ startingwith x for the integer n. The numbers should bewritten each in a separate line without any superfluous characters such asleading or trailing spaces.

SampleInput 

1

31

70

91

473

512

811

953

0

SampleOutput 

0

6

8

9

11

9

13

12

代码:

// UVa1374 Power Calculus

// Rujia Liu

#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;

const int maxans = 13; // we got it by experimenting

int n, a[maxans+1];

bool dfs(int d, int maxd) {

if(a[d] == n) return true;

if(d == maxd) return false;

int maxv = a[0];

for(int i = 1; i <= d; i++) maxv = max(maxv, a[i]);

if((maxv << (maxd-d)) < n) return false;

// Always use the last value.

// I can't prove it, but we haven't found a counter-example for n <= 1000

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

a[d+1] = a[d] + a[i];

if(dfs(d+1, maxd)) return true;

a[d+1] = a[d] - a[i];

if(dfs(d+1, maxd)) return true;

}

return false;

}

int solve(int n) {

if(n == 1) return 0;

a[0] = 1;

for(int maxd = 1; maxd < maxans; maxd++) {

if(dfs(0, maxd)) return maxd;

}

return maxans;

}

int main() {

while(scanf("%d", &n) == 1 && n) {

printf("%d\n", solve(n));

}

return 0;

}

 

�#< �/QpSNormal>{

   int T;

   scanf("%d", &T);

   while(T--)

    {

       scanf("%lf%d", &r, &n);

       for(int i = 0; i < n; i++) scanf("%lf", &w[i]);

       for(int i = 0; i < (1<<n); i++)

       {

           sum[i] = 0;

           tree[i].clear();

           for(int j = 0; j < n; j++)

                if(i & (1<<j)) sum[i]+= w[j];

       }

       int root = (1<<n)-1;

       memset(vis, 0, sizeof(vis));

       dfs(root);

       double ans = -1;

       for(int i = 0; i < tree[root].size(); i++)

           ans = max(ans, tree[root][i].L + tree[root][i].R);

       printf("%.10lf\n", ans);

    }

   return 0;

}