OJ Board

How can 65535 be a proper input? The problem is based on the two inputs being of the form:

(N+1)^k and N^k

65535 has a prime factorization of 3, 5, 17, 257. So, how does this work for the problem? That means that N would have to be each of these numbers, but N is a constant number, not a variant.

???

Check out the input of "1 1". You are getting a funky result.

Hope this helps.

Ron

I ran my program again, and I come up with the following:

390625 65535 -> 21845 1690980 (instead of 1690981)

ALL of my other answers are right. I am still not following why we would have to worry about this case because 4^8 is 65536, and 5^8 is 390625???

Ignore that last bit of code. I figured out what is wrong with it. It is still getting a wrong answer, but don't know why now.

I didn't debug all of your code, but I would think your bottleneck is the while loop, where you are using several log functions at once. This is very time consuming to a machine...and with division as well!

It should be 390625, 65536 -> 21845 1690981,
sorry
7776 3125 -> 781 31031
14641 10000 -> 1111 61051

Thanks for the reply and the correction. However, I ran the two other tests you gave me, and I get the correct answers for those as well, but the judge STILL says I have a "Wrong Answer".

I have posted replies to several people on this problem. I have ran my program against several inputs, all from this site, and my program answers every one of them correctly. I have tested this program with every possible set of data I can find, or make up, including the extreme cases. However, the online judge says that I have an incorrect answer ("Wrong Answer"). If you have solved this problem, let me know what is wrong with mine and give me some kind of clue as to what is wrong, because I just cannot see it.

[cpp]//---------------------------------------------------------------------------
// Ron Buchanan
// ACM Volume I - #107
// "The Cat in the Hat"
//---------------------------------------------------------------------------
#include <math.h>
#include <stdlib.h>
#include <stdio.h>

#define DEBUG 0

void findTheRoot();

long bigCatHeight;
long workerCats;
long theRoot;
double thePower;
long theLazyCats;
long theStackHeight;
long theHeight;
long cats;

void main()
{
while (true) {
scanf("%ld %ld", &bigCatHeight, &workerCats);
if (bigCatHeight == 0 && workerCats == 0) break;

if (bigCatHeight == 1) {
theLazyCats = 0;
theStackHeight = workerCats;
}
else {
// initialize
theRoot = 1;
thePower = log(bigCatHeight)/log(workerCats);
theLazyCats = 1;
theStackHeight = bigCatHeight;

// try to somewhat brute-force the root
findTheRoot();

#if DEBUG
printf("%ld^%f\n", theRoot, thePower);
#endif

// calculate the height of the stack and the number of lazy cats
theHeight = bigCatHeight / (theRoot+1);
cats = 1;
while (theHeight > 1) {
cats = cats * theRoot;
theLazyCats += cats;
theStackHeight += (long)(theHeight*cats);
theHeight = theHeight / (theRoot+1);
#if DEBUG
printf("%ld %ld %ld %f\n", cats, theLazyCats, theStackHeight, theHeight);
#endif
}
theStackHeight += workerCats;
/* OLD
theLazyCats = (long)((pow(theRoot, thePower+1) - 1)/(theRoot - 1)
- workerCats);
theStackHeight = 0;
for (int i = 0; i <= thePower; i++)
theStackHeight +=
(long)(pow(theRoot, i)*pow(theRoot+1, thePower-i));
*/
}
printf("%ld %ld\n", theLazyCats, theStackHeight);
}
}

//---------------------------------------------------------------------------
// attempt to brute-force the root and power
//---------------------------------------------------------------------------
void findTheRoot() {
while (log(theRoot+1)/log(theRoot) - thePower > 1e-15) {
theRoot++;
}
thePower = (long)(log(workerCats)/log(theRoot));
}[/cpp]

Any and all help would be greatly appreciated. [/cpp]

My program worked fine. I transfered everything to Unix. Got rid of any invisible characters in the code, and everything worked fine.

Windows

Anyway, I am just glad it is working.

You probably did something else wrong,

check:
1. use unsigned int rather than double for precision, if you use double, make sure there is no possible ways of precision error.

2. boundary cases, ex: 1 1 -> 0 1

3. invalid references like v[i-1], C++ probably will let you pass, but the judge will not. In the judge system, all memory other then the program is cleared. v[i-1] = 0. Although that's not likely in this program.

If it doesn't work still, I can put some more test cases

Thank you for the response, but as it turns out, I got it accepted. As it turns out, I put the code over to Unix, and loaded it in vi. I removed all Windows characters, and then resubmitted. After that, everything worked.

Again, thanks for the comments.

Why this code got WA@@?

your program gives incorrect output for the following test cases.

8 1
16 1

your program gives:

1 0
1 0

this is incorrect.

are the correct answers 3 15 and 4 31?

I have fix the problem but still got WA

Yes, they are.
but maybe you can test your program with this: hope this will be help