牛客练习赛15

A - 吉姆的运算式

思路：
$\ \ \ \ \ \ $直接用栈去模拟就好了。

#include<bits/stdc++.h>
typedef long long ll;
const int maxn = 1e5 + 10;
using namespace std;

int n, m, T, kase = 1;
char str[maxn];
char stk[maxn];
int num[maxn], len;

int cal(int &id) {
    int flag = 1, sum = 0;
    if(str[id] == '-') { flag = -1; id++; }
    while(id < len && str[id] >= '0' && str[id] <= '9') { sum = sum * 10 + str[id] - '0'; id++; }
    id--; return flag * sum;
}

int main() {
    while(cin >> str) {
        len = strlen(str);
        int cnt1 = 0, cnt2 = 0, ans;
        for(int i = 0; i < len; i++) {
            if(str[i] == '(') {
                stk[cnt1++] = '(';
            } else if(str[i] == ')') {
                ans = num[cnt2 - 1];
                while(stk[cnt1 - 1] != '(') {
                    cnt1--; cnt2--;
                }
                cnt1--; cnt2--;
                num[cnt2++] = ans;
            } else if(str[i] == ',') {
                stk[cnt1++] = ',';
            } else {
                int now = cal(i);
                num[cnt2++] = now;
            }
        }
        if(cnt2) ans = num[cnt2 - 1];
        cout << ans << endl;
    }
    return 0;
}

B - 沃老师学生的成绩

思路：
$\ \ \ \ \ \ $写了好多版本啊。。 $string$类型把尾数0去了直接比较小数部分都超时。。看别人的都不会啊， 果然还是$low$。。。
$\ \ \ \ \ \ $把分数拆成整数和小数部分，然后哈希二分查找小数部分首次不同的位置，比较那里就好了。二分也超时几次。。。。

#include<bits/stdc++.h>
typedef long long ll;
const int maxn = 6e5 + 10;
const ll mod = 1e17 + 3;
using namespace std;

int n, m, T, kase = 1;
char s1[maxn], s2[maxn];



vector<int> sco[maxn];

struct P {
    string name;
    string score, score2;
    void input() { cin >> name >> score;  }
    int solve(int idx) {
        int l1 = 0, l2 = 0, flag = 0;
        for(int i = 0; i < score.length(); i++) {
            if(score[i] == '.') { flag = 1; continue; }
            else if(flag) {
                s2[l2++] = score[i];
            } else {
                s1[l1++] = score[i];
            }
        }
        s2[l2++] = '0'; s2[l2] = 0; s1[l1] = 0;
        int sum = 0; ll ds = 0;
        for(int i = 0; i <l1; i++) sum = sum * 10 + s1[i] - '0';
        while(l2 > 1 && s2[l2 - 1] == '0') l2--; s2[l2] = 0;
        for(int i = 0; i < l2; i++) {
            ds = ds * 10 + s2[i] - '0';
            sco[idx].push_back(ds);
        }
        score2 = s2;
        return sum;
    }
} res[maxn];

int ans[maxn];
vector<int> vec[15];

int find_id(int x, int y, int r) {
    int l = 0;
    while(l < r) {
        int mid = (l + r) >> 1;
        if(sco[x][mid] == sco[y][mid]) l = mid + 1;
        else r = mid;
    }
    return l;
}

bool cmp(int x, int y) {
    int L1 = res[x].score2.length();
    int L2 = res[y].score2.length();
    int L = min(L1, L2);
    int id = find_id(x, y, L);
    if(id != L) return res[x].score2[id] > res[y].score2[id];
    if(L1 != L2) return L1 > L2;
    return res[x].name < res[y].name;
}

int main() {
    while(cin >> n) {
        for(int j = 0; j < 15; j++) vec[j].clear();
        for(int i = 0; i < n; i++) {
            res[i].input();
            int k = res[i].solve(i);
            vec[k].push_back(i);
        }
        for(int i = 0; i < 10; i++) sort(vec[i].begin(), vec[i].end(), cmp);
        for(int i = 9; i >= 0; i--) {
            for(int j = 0; j < vec[i].size(); j++) {
                cout << res[vec[i][j]].name << " " << res[vec[i][j]].score <<endl;
            }
        }
    }
    return 0;
}

C - 吉姆的奇思妙想

思路：
$\ \ \ \ \ \ $感觉自己的思路好$low$啊。。。。
$\ \ \ \ \ \ $看表达式，发现$a_i$对应的是一个前缀和值，$b_i$对应的是一个后缀和值，而且两个而且前缀后缀的组合发现最多有$n + 1$种情况，可以预处理出来，不妨这$n+1$种前缀后缀的组合是$(x_0,y_0)，(x_1,y_1)...(x_n,y_n)$，发现可以对它们按照$x$拍个序，一定是$x$严格递增，$y$严格递减，现在要求$E_i = a_i * x + b_i * y$最小，即找出某个点$(x_k,y_k)$满足这个$E_i$最小，对这个式子处理一下：

$$y = -\frac{a_i}{b_i}\cdot x + \frac{E_i}{b_i}$$
$\ \ \ \ \ \ $对$b_i$固定的话， 就要使得$\frac{E_i}{b_i}$最小，因为查询可以离线，那么对于查询按照这个斜率从小到大排好序之后，那么就是斜率$dp$那样去维护了，维护一个下凸包就行了。
$\ \ \ \ \ \ $然后是注意各种判断溢出。。。。。。。。

#include<bits/stdc++.h>
//typedef long long ll;
typedef unsigned long long ull;
const int maxn = 3e5 + 10;
const ull max_ll = ((ull)1 << 63);
using namespace std;

struct P {
    ull a, b;
    int id;
    void input(int i) { scanf("%llu %llu", &a, &b); id = i; }
    bool operator < (P p) const { return a * p.b > b * p.a; }
} pot[maxn];
ull n, m, q, M, L;
ull deg[maxn], freq[maxn];
ull suml[maxn], sumr[maxn];
ull ans[maxn];

typedef pair<ull, ull> pa;
pa res[maxn];
vector<pa> vec;

bool solve_k(pa i, pa j, pa k) { ///i_j 是否 > j_k
    ull dx_ij = i.first - j.first;
    ull dy_ij = j.second - i.second;
    ull dx_jk = j.first - k.first;
    ull dy_jk = k.second - j.second;
    double d1 = (double)dy_ij / dx_ij;
    double d2 = (double)dy_jk / dx_jk;
    return d1 < d2;
}

bool is_over(ull x, ull y) {
    if(!y) return false;
    ull c = max_ll / y;
    if(c <= x) return true;
    return false;
}
bool is_add_over(ull x, ull y) { return (max_ll - x <= y); }

int vis[maxn];

int main() {
    while(scanf("%llu %llu", &M, &L) != EOF) {
        n = L;
        memset(vis, 0, sizeof vis);
        memset(suml, 0, sizeof suml);
        memset(sumr, 0, sizeof sumr);
        vec.clear();
        int id = -1;
        for(int i = 1; i <= L; i++) scanf("%llu %llu", &deg[i], &freq[i]);
        for(int i = 1; i <= L; i++) {
            suml[i] = suml[i - 1] + deg[i] * deg[i] * freq[i];
            int k = L - i + 1;
            if((is_over(M, freq[k]) || is_add_over(sumr[k + 1], M * freq[k])) && id == -1) id = k; ///第二部分已经溢出
            sumr[k] = sumr[k + 1] + M * freq[k];
        }

        int num = 0;
        for(int i = 0; i < n + 1; i++) {
            if(is_over(deg[i], deg[i])) break;
            if(is_over(deg[i] * deg[i], freq[i])) break;
            if(i && is_add_over(suml[i - 1], deg[i] * deg[i] * freq[i])) break;
            if(i + 1 > id) res[num++] = pa(suml[i], sumr[i + 1]);
        }

        scanf("%llu", &q);
        for(int i = 0; i < q; i++) pot[i].input(i);
        sort(res, res + num);
        sort(pot, pot + q);
        for(int i = 0; i < num; i++) {
            while(vec.size() >= 2 && !solve_k(res[i], vec[vec.size() - 1], vec[vec.size() - 2])) vec.pop_back(); ///维护下凸包
            vec.push_back(res[i]);
        }
        int l = 0;
        for(int i = 0; i < q; i++) {

            while(l + 1 < vec.size()) {
                pa now = vec[l];
                pa nxt = vec[l + 1];
                if(is_over(pot[i].b, now.second) || is_over(pot[i].a, now.first) || is_add_over(pot[i].b * now.second, pot[i].a * now.first)) { l++; continue; }
                if(is_over(pot[i].b, nxt.second) || is_over(pot[i].a, nxt.first) || is_add_over(pot[i].b * nxt.second, pot[i].a * nxt.first)) break;
                ull now_ans = pot[i].b * now.second + pot[i].a * now.first;
                ull nxt_ans = pot[i].b * nxt.second + pot[i].a * nxt.first;
                if(nxt_ans <= now_ans) l++;
                else break;
            }
            pa nxt = vec[l];
            ans[pot[i].id] = pot[i].b * nxt.second + pot[i].a * nxt.first;
        }
        for(int i = 0; i < q; i++) cout << ans[i] << endl;
    }
    return 0;
}