时间复杂度

时间限制(普通/Java):1000MS/3000MS          运行内存限制:65536KByte
总提交:8            测试通过:3

描述

在ACM里面，计算复杂度是一项非常重要的事情，常见的复杂度格式有三种：

1、O(n)

2、O(lg(n))

3、O(sqrt(n))

一个算法往往有多种解法，每种解法的复杂度有上述常见的的复杂度组合成，例如排序的两种算法：

1、快速排序： 时间复杂度为O(n*lg(n))

2、冒泡排序： 时间复杂度为O(n*n)

现在给定你一个n，m个算法复杂度，请确定这些复杂度是否会超时。若复杂度计算结果大于100000000，则为超时(TLE)，否则输出计算的复杂度，输出的结果保留两位小数。

( lg(n)表示以2为底数，n为真数的值 )

输入

第一行输入n (1≤n≤10000), m(1≤m≤100), 其中n为题目描述的数，m为算法复杂度的个数。

接下来m行，每行为一个串，每个串都包含O()任何括号里面的数据保证仅由n,lg(),sqrt(),*组成并且合法。如sample input所示。

输出

对于每个串，若计算出来的复杂度大于100000000，则输出TLE，否则输出该复杂度的计算次数

样例输入

10000 6
O(n*n)
O(n*n*n)
O(sqrt(n))
O(lg(n))
O(n*lg(n))
O(n*lg(n*lg(n)))

样例输出

100000000.00
TLE
100.00
13.29
132877.12
170197.33

提示

关于lg(n)的C语言代码可以这样写

log(n) / log(2)

#include<iostream>
using std::cin;
using std::cout;
using std::endl;
#include<string>
using std::string;
#include<stack>
using std::stack;
#include<cmath>
#include<cstdlib>

#define MAX_TIME_COMPLEXITY 100000000.0

class ExpressionAnalyzer{
public:
	static const char LG = 'l';
	static const char SQRT = 's';
	static const char N = 'n';
	ExpressionAnalyzer(const string& str):data(str),currentPos(1){}
	char nextElement(void){
		switch (data[currentPos]){
		case N:
			++currentPos;
			return N;
		case LG:
			currentPos += 3;
			return LG;
		case SQRT:
			currentPos += 5;
			return SQRT;
		case '*':
			++currentPos;
			return '*';
		case '(':
			++currentPos;
			return '(';
		case ')':
			++currentPos;
			return ')';
		case '#':
			++currentPos;
			return '#';
		}
	}
private:
	string data;
	string::size_type currentPos;
};

int precede(const char operator1, const char operator2){
	switch (operator1){
	case '*':
		switch (operator2){
		case '*': case ')':case '#':
			return 1;
		case '(': case ExpressionAnalyzer::LG: case ExpressionAnalyzer::SQRT:
			return -1;
		}
		break;
	case '(': case ExpressionAnalyzer::LG: case ExpressionAnalyzer::SQRT:
		switch (operator2){
		case '*': case '(': case ExpressionAnalyzer::LG: case ExpressionAnalyzer::SQRT:
			return -1;
		case ')':
			return 0;
		}
		break;
	case ')':
		switch (operator2){
		case '*': case ')': case '#':
			return 1;
		}
		break;
	case '#':
		switch (operator2){
		case '*': case '(': case ExpressionAnalyzer::LG: case ExpressionAnalyzer::SQRT:
			return -1;
		case '#':
			return 0;
		}
		break;
	}
}

double timeComplexity(const string& expression, const double nValue){
	ExpressionAnalyzer expIn(expression + "#");
	stack<char> oper;
	stack<double> number;
	double rhd;
	char ch = expIn.nextElement();
	oper.push('#');
	while (ch != '#' || oper.top() != '#'){
		if (ch == ExpressionAnalyzer::N){
			number.push(nValue);
			ch = expIn.nextElement();
		}
		else{
			switch (precede(oper.top(), ch)){
			case -1:
				oper.push(ch);
				ch = expIn.nextElement();
				break;
			case 1:
				rhd = number.top(); number.pop();
				number.top() *= rhd;
				oper.pop();
				break;
			case 0:
				switch (oper.top()){
				case ExpressionAnalyzer::LG:
					number.top() = log(number.top()) / log(2);
					break;
				case ExpressionAnalyzer::SQRT:
					number.top() = sqrt(number.top());
					break;
				}
				oper.pop();
				ch = expIn.nextElement();
				break;
			}
		}
	}
	return number.top();
}

int main(void){
	unsigned int testTimes;
	string expression;
	double nValue;
	cin >> nValue >> testTimes;
	while (testTimes--){
		cin >> expression;
		double result = timeComplexity(expression, nValue);
		if (result > MAX_TIME_COMPLEXITY){
			puts("TLE");
		}
		else{
			printf("%.2lf\n", result);
		}
	}
	return EXIT_SUCCESS;
}