SRM 450 div1(practice)
250pt:
对普通nim游戏的改编，取石子的时候只能从前往后取，每次取非空的石子，不能取者为输。
我是从后往前推的，注意当前数字如果>1，不管后面是必胜态还是必败态，肯定能调节成必胜态，如果=1，就身不由己了。。
500pt
一开始，你有n个工厂，k个专家，每工作一轮，能获得n*k的gold，购买一个工厂或者一个专家需要price的gold，你想要获得的gold是target，当你具备足够的钱买一个专家或者工厂的时候，你可以买任意多个专家或工厂。问你最小需要几轮才能获得target的gold。
这是一个 看似难写，实则更难写的模拟题。。
注意到n k肯定是越接近越好，还有当前如果要买一个专家或者工厂，那肯定是花所有的钱去买(n,k肯定是越早增大越好)。因为下一轮就赚回来了。还有就是假设当前的钱>=price了，就需要先判断一下是不是要买工厂或者专家了，因为有可能凭借当前的nk，很快就能到达target了。
代码写的比较渣，错了很多遍
#include <cstdio>
#include <cstring>
#include <cctype>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <iostream>
#include <map>
#include <set>
#include <list>
#include <sstream>
#include <queue>
#include <deque>
#include <stack>
#include <vector>
#include <bitset>
#include <algorithm>
using namespace std;
typedef long long lld;
class StrongEconomy {
public:
lld ABS(lld a)
{
if(a > 0) return a;
return -a;
}
void get(lld &n,lld &k,lld &tim) {
if(tim >= ABS(n-k) )
{
lld tn = n , tk = k;
n = (tn+tk+tim) / 2;
k = (tn+tk+tim+1) / 2;
}
else
{
if(n>k) k+=tim; else n+=tim;
}
}
lld gao(lld n,lld k,lld price,lld target,lld earn) {
lld tim = earn / price;
earn -= tim * price;
get(n,k,tim);
lld tmp = mul(n,k);
if(tmp == -1) return tmp;
lld ans = (target - earn)/tmp;
if((target-earn)%tmp) ans ++;
return ans;
}
lld mul(lld a,lld b) {
lld ans = 0;
bool flag = false;
for(int i=0; i<50; i++) {
// cout<<ans<<endl;
if(b&(1LL<<i)) {
if(flag) return -1;
ans = ans + a;
if(ans > 1000000000000LL) return -1;
}
a = a + a;
if(a > 1000000000000LL) flag = true;
}
return ans;
}
lld earn(lld n, lld k, lld price, lld target) {
if(mul(n,k) == -1) return 1;
lld round = 0;
lld earn = 0;
while(true) {
lld tmp = mul(n,k); if(tmp == -1) return round ;
// cout<<earn<<endl;
if(earn >= target) break;
if(earn >= price) {
lld tmp = mul(n,k);
lld tmp1 = (target - earn) / tmp ;
if((target-earn)%tmp) tmp1++;
lld tmp2 = gao(n,k,price,target,earn);
// cout<<tmp1<<" "<<tmp2<<endl;
if(tmp1 < tmp2 ) {
round += tmp1;
break;
} else {
lld tim = earn / price;
if(tmp2 == -1) return round + 1;
earn -= tim * price;
// cout<<"pre"<<" "<<n<<" "<<k<<" "<<tim<<endl;
get(n,k,tim);
// cout<<n<<" "<<k<<" "<<earn<<endl;
}
}
else if(price < target){
lld tmp = n * k;
lld t = (price-earn)/tmp;
if((price-earn)%tmp) t++;
round += t;
earn += t * n * k;
cout<<"earn"<<" "<<earn<<endl;
} else {
lld tmp = n * k;
lld t = (target-earn)/tmp;
if((target-earn)%tmp) t++;
round += t;
earn += t * n * k;
}
// cout<<n<<" "<<k<<endl;
}
return round;
}
// BEGIN CUT HERE
public:
void run_test(int Case) {
if ((Case == -1) || (Case == 1)) test_case_1();
}
private:
template <typename T> string print_array(const vector<T> &V) {
ostringstream os;
os << "{ ";
for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\",";
os << " }";
return os.str();
}
void verify_case(int Case, const lld &Expected, const lld &Received) {
cerr << "Test Case #" << Case << "...";
if (Expected == Received) cerr << "PASSED" << endl;
else {
cerr << "FAILED" << endl;
cerr << "\tExpected: \"" << Expected << '\"' << endl;
cerr << "\tReceived: \"" << Received << '\"' << endl;
}
}
//void test_case_0() { lld Arg0 = 4294967297LL; lld Arg1 = 4294967297LL; lld Arg2 = 1000000000000LL; lld Arg3 = 100000000000LL; lld Arg4 = 1LL; verify_case(0, Arg4, earn(Arg0, Arg1, Arg2, Arg3)); }
void test_case_1() {
lld Arg0 = 3LL;
lld Arg1 = 2LL;
lld Arg2 = 1000000000000LL;
lld Arg3 = 222LL;
lld Arg4 = 37LL;
verify_case(1, Arg4, earn(Arg0, Arg1, Arg2, Arg3));
}
// void test_case_2() { lld Arg0 = 1LL; lld Arg1 = 1LL; lld Arg2 = 500000LL; lld Arg3 = 1000002LL; lld Arg4 = 1000001LL; verify_case(2, Arg4, earn(Arg0, Arg1, Arg2, Arg3)); }
//void test_case_3() { lld Arg0 = 5LL; lld Arg1 = 4LL; lld Arg2 = 15LL; lld Arg3 = 100LL; lld Arg4 = 5LL; verify_case(3, Arg4, earn(Arg0, Arg1, Arg2, Arg3)); }
// END CUT HERE
};
// BEGIN CUT HERE
int main() {
StrongEconomy ___test;
___test.run_test(-1);
}
// END CUT HERE