19059 可识别的数字

时间限制:1000MS 代码长度限制:10KB

提交次数:0 通过次数:0

题型: 编程题 语言: 不限定

Description

桌子上原本有n个从左到右排列的数字，但是因为某些原因有些数字不可识别了。

现在要求你将可识别的数字挑出来，然后不改变它们原来的相对顺序从左到右重新放在桌子上。

再在每两个相邻的数字之间加上一个符号（只能加三种符号“+”，“-”，“*”），添加的符号不同就能得到不同的公式。

问在所有可能的公式中结果的最大值是多少？

输入格式

第一行输入一个数T表示有T组测试数据

每组测试数据第一行为一个数n表示有n个字符串

接下来n行，每行有一个字符串，每个字符串的长度最多为4

一个字符串是可以被识别的数字的条件为：

只有'-'、'0'、'1'、'2'、'3'、'4'、'5'、'6'、'7'、'8'、'9'这些字符组成。

如果一个字符串是可识别的数字且是负数那么它的第一位是'-'后面必须接是一个合法的正整数表示；

如果一个字符串是可识别的数字且是非负数那么它一定是一个合法的自然数表示。

下面的字符串就是一些可识别的数字：

"-12","0","123","1","1000"

下面的字符串就是一些不可识别数字：

"-","AD*","-0","S&23","-231-","0023","-012","000"

注：“可识别的数字”不超过4个，且至少有一个“可识别的数字”。

n <= 20，T<=1000

输出格式

输出一个整数表示结果的最大值。

输入样例

2

4

1

2kk

-0

012

4

234

-12

fd

000

输出样例

1

246

提示

第一个样例，可识别的数字只有1,所以结果为1。

第二个样例，可识别的数字依次为234、-12,所有可能的公式为：

234 + (-12) = 222

234 - (-12) = 246

234 * (-12) = -2808

所以结果为246

解析

由于“可识别的数字”不超过4个，且至少有一个“可识别的数字”，数据范围很小，所以我直接使用穷举法。

思路：先对给出的字符串进行合法判断（这里我根据题意写了canCheck函数），判断完后再将字符串转数字（turn函数）

存入num数组中。

由于要求这几个数再进行运算后的最大值，而且只有加减乘三个运算符，我直接暴力穷举，更新结果。

不知道结果用int能不能过（没试过），我结果是用的long long

具体代码如下：

#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
#define ll long long
bool canCheck(string s) {
    int flag = 0;

    if (s.size() == 1) {
        if (!(s[0] >= '0' && s[0] <= '9')) {
            flag = 1;
        }
    }
    else {
        int cnt = 0;
        for (int i = 0; i < s.size(); ++i) {
            if (!(s[i] >= '0' && s[i] <= '9') && s[i] != '-') {
                flag = 1;
            }
            if (s[i] == '-') {
                cnt++;
            }
        }
        if (s[0] == '0') {
            flag = 1;
        }
        else if (s[0] == '-') {
            if (s[1] == '0') {
                flag = 1;
            }
            if (cnt >= 2) {
                flag = 1;
            }
        }
    }
    if (flag) {
        return false;
    }
    else {
        return true;
    }
}

ll turn(string s) {
    ll sum = 0;
    for (int i = 0; i < s.size(); ++i) {
        if (s[i] >= '0' && s[i] <= '9') {
            sum = sum * 10 + s[i] - '0';
        }
    }
    if (s[0] == '-') {
        sum *= -1;
    }
    return sum;
}

int main() {
    ll num[5];
    int t;
    cin >> t;
    while (t--) {
        int n, j=0;
        cin >> n;
        for (int i = 0; i < n; ++i) {
            string s;
            cin >> s;
            //cout << s << endl;
            if (canCheck(s)) {
                num[j++] = turn(s);
                cout << num[j - 1] << ' ';
            }
            
        }
        ll maxn = num[0];
        ll ans;
        if (j == 2) {
            ans = num[0] + num[1];
            maxn = max(maxn, ans);
            ans = num[0] - num[1];
            maxn = max(maxn, ans);
            ans = num[0] * num[1];
            maxn = max(maxn, ans);
        }
        else if (j == 3) {
            ans = num[0] + num[1] + num[2];
            maxn = max(maxn, ans);
            ans = num[0] + num[1] - num[2];
            maxn = max(maxn, ans);
            ans = num[0] + num[1] * num[2];
            maxn = max(maxn, ans);
            ans = num[0] - num[1] + num[2];
            maxn = max(maxn, ans);
            ans = num[0] - num[1] - num[2];
            maxn = max(maxn, ans);
            ans = num[0] - num[1] * num[2];
            maxn = max(maxn, ans);
            ans = num[0] * num[1] + num[2];
            maxn = max(maxn, ans);
            ans = num[0] * num[1] - num[2];
            maxn = max(maxn, ans);
            ans = num[0] * num[1] * num[2];
            maxn = max(maxn, ans);
        }
        else if(j==4){
            ans = num[0] + num[1] + num[2] + num[3];
            maxn = max(ans, maxn);
            ans = num[0] + num[1] + num[2] - num[3];
            maxn = max(ans, maxn);
            ans = num[0] + num[1] + num[2] * num[3];
            maxn = max(ans, maxn);
            ans = num[0] + num[1] - num[2] + num[3];
            maxn = max(ans, maxn);
            ans = num[0] + num[1] - num[2] - num[3];
            maxn = max(ans, maxn);
            ans = num[0] + num[1] - num[2] * num[3];
            maxn = max(ans, maxn);
            ans = num[0] + num[1] * num[2] + num[3];
            maxn = max(ans, maxn);
            ans = num[0] + num[1] * num[2] - num[3];
            maxn = max(ans, maxn);
            ans = num[0] + num[1] * num[2] * num[3];
            maxn = max(ans, maxn);

            ans = num[0] - num[1] + num[2] + num[3];
            maxn = max(ans, maxn);
            ans = num[0] - num[1] + num[2] - num[3];
            maxn = max(ans, maxn);
            ans = num[0] - num[1] + num[2] * num[3];
            maxn = max(ans, maxn);
            ans = num[0] - num[1] - num[2] + num[3];
            maxn = max(ans, maxn);
            ans = num[0] - num[1] - num[2] - num[3];
            maxn = max(ans, maxn);
            ans = num[0] - num[1] - num[2] * num[3];
            maxn = max(ans, maxn);
            ans = num[0] - num[1] * num[2] + num[3];
            maxn = max(ans, maxn);
            ans = num[0] - num[1] * num[2] - num[3];
            maxn = max(ans, maxn);
            ans = num[0] - num[1] * num[2] * num[3];
            maxn = max(ans, maxn);
            ans = num[0] * num[1] + num[2] + num[3];
            maxn = max(ans, maxn);
            ans = num[0] * num[1] + num[2] - num[3];
            maxn = max(ans, maxn);
            ans = num[0] * num[1] + num[2] * num[3];
            maxn = max(ans, maxn);
            ans = num[0] * num[1] - num[2] + num[3];
            maxn = max(ans, maxn);
            ans = num[0] * num[1] - num[2] - num[3];
            maxn = max(ans, maxn);
            ans = num[0] * num[1] - num[2] * num[3];
            maxn = max(ans, maxn);
            ans = num[0] * num[1] * num[2] + num[3];
            maxn = max(ans, maxn);
            ans = num[0] * num[1] * num[2] - num[3];
            maxn = max(ans, maxn);
            ans = num[0] * num[1] * num[2] * num[3];
            maxn = max(ans, maxn);
        }
        cout << maxn << endl;
    }
    return 0;
}