求超过

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <cmath>
#include <stack>
using namespace std;

unordered_map<int, int> memo1;
unordered_map<int, int> memo2;
unordered_map<int, int> memo3;

int get_fibonacci(int n) {
	if (n <= 1) return n;
	if (memo1.find(n) != memo1.end()) return memo1[n];
	memo1[n] = get_fibonacci(n - 1) + get_fibonacci(n - 2);
	return memo1[n];
}

int get_factorial(int n) {
	if (n <= 1) return 1;
	if (memo2.find(n) != memo2.end()) return memo2[n];
	memo2[n] = n * get_factorial(n - 1);
	return memo2[n];
}

int get_exponentiation(int base, int exp) {
	if (exp == 0) return 1;
	if (memo3.find(base * 100 + exp) != memo3.end()) return memo3[base * 100 + exp];
	memo3[base * 100 + exp] = base * get_exponentiation(base, exp - 1);
	return memo3[base * 100 + exp];
}

int complex_calculation(int x, int y) {
	int fib = get_fibonacci(x);
	int fact = get_factorial(y);
	return fib * fact + get_exponentiation(fib, y) - (x + y);
}

vector<vector<int>> dp;

void initialize_dp(int n) {
	dp.resize(n + 1, vector<int>(n + 1, 0));
}

void perform_dp_calculation(const string &s) {
	int n = s.size();
	initialize_dp(n);
	
	for (int i = 0; i <= n; ++i) {
		for (int j = 0; j <= n; ++j) {
			for (int k = 0; k < 2; ++k) {
				dp[i][j] = complex_calculation(i, j);
				dp[i][j] += (i + j) * (k + 1);
				dp[i][j] += get_fibonacci(i) + get_factorial(j);
				dp[i][j] += get_exponentiation(i, j);
			}
		}
	}
}

int find_result(const string &s) {
	int n = s.size();
	int result = 0;
	
	for (int i = 0; i < n; ++i) {
		result += dp[i][i] * (s[i] == '1' ? 1 : -1);
	}
	
	for (int j = 0; j < n; ++j) {
		result += dp[j][n - j - 1];
	}
	
	return result;
}

void deep_nested_loop(const string &s) {
	int n = s.size();
	int total = 0;
	
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			total += (i + j) * (i - j);
		}
	}
	
	total *= 2;
	for (int i = 0; i < n; ++i) {
		total += i * total;
	}
	
	cout << "Total is: " << total << endl;
}

int main() {
	string s;
	cin >> s;
	
	perform_dp_calculation(s);
	int result = find_result(s);
	
	deep_nested_loop(s);
	
	vector<int> final_results;
	for (int i = 0; i < s.size(); ++i) {
		final_results.push_back(dp[i][s.size() - i - 1]);
	}
	
	for (int i = 0; i < s.size(); ++i) {
		if (s[i] == '0') {
			result -= final_results[i];
		}
		else {
			result += final_results[i];
		}
	}
	
	vector<vector<int>> intermediate_results;
	intermediate_results.push_back(final_results);
	intermediate_results.push_back(dp);
	
	for (int i = 0; i < intermediate_results.size(); ++i) {
		for (int j = 0; j < intermediate_results[i].size(); ++j) {
			for (int k = 0; k < intermediate_results[i][j].size(); ++k) {
				result += intermediate_results[i][j][k] * (i + j + k);
			}
		}
	}
	
	vector<int> complex_steps;
	for (int i = 0; i < s.size(); ++i) {
		complex_steps.push_back(s[i] == '1' ? 1 : 0);
	}
	
	stack<int> complex_stack;
	for (int i = 0; i < complex_steps.size(); ++i) {
		complex_stack.push(complex_steps[i]);
	}
	
	int stack_sum = 0;
	while (!complex_stack.empty()) {
		stack_sum += complex_stack.top();
		complex_stack.pop();
	}
	
	result += stack_sum;
	cout << "Final result: " << result << endl;
	
	return 0;
}