听寒's Blog

#include <bits/stdc++.h>
using namespace std;

using nodeidT = int;
using chainT = vector<nodeidT>;
using broadcastMsg = pair<nodeidT, chainT>; // 发出节点ID，主链
vector<vector<nodeidT> > rel; // 节点-邻接表{相连节点...}
vector<chainT> chain;// 节点-主链{主链节点...}
unordered_map<int, vector<pair<nodeidT, int>>> creation; // 时间- {{节点，块编号}...}
unordered_map<int, vector<broadcastMsg> > transmission; // 时间- {节点，链{接收链组成节点...｝}...}
set<int> timepoints;

int n;
int delay;

inline void gen(int node, int t, int id) {
    creation[t].push_back({node, id});
    timepoints.insert(t);
}

inline void broadcastNeighbor(int node, int tp) {
    transmission[tp + delay].push_back({node, chain[node]});
    timepoints.insert(tp + delay); // 不要忘记维护时间点表
}

inline void query(int node, int t) {
    auto it = timepoints.begin();
    for (; it != timepoints.end() && *it <= t; ++it) {
        int tp = *it;
        // 先处理接收
        if (transmission.count(tp)) {
            for (const auto &msg: transmission[tp]) {
                const auto &fromid = msg.first;
                const auto &sentchain = msg.second;
                for (const auto &toid: rel[fromid]) {
                    if (chain[toid].size() < sentchain.size()
                        || (chain[toid].size() == sentchain.size() && chain[toid].back() > sentchain.back())
                            ) {
                        chain[toid] = sentchain; // 接受更新
                        broadcastNeighbor(toid, tp); // 向邻居广播自己的主链
                    }
                }
            }
        }
        transmission.erase(tp);
        // 处理创建
        if (creation.count(tp)) {
            for (const auto &p: creation[tp]) {
                const auto &nodeid = p.first;
                const auto &blockid = p.second;
                chain[nodeid].push_back(blockid); // 主链延长
                broadcastNeighbor(nodeid, tp); // 向邻居广播自己的主链
            }
        }
        creation.erase(tp);
    }
    timepoints.erase(timepoints.begin(), it); // 此处erase使用注意，不能在循环中擦除当前key，否则当前迭代器失效无法自增至下一元素
    // 输出该时间点状态
    cout << chain[node].size();
    for (int b: chain[node]) {
        cout << " " << b;
    }
    cout << endl;
}

int main() {
    ios_base::sync_with_stdio(false);
    int m;
    cin >> n >> m;
    rel.resize(n + 1);
    chain.resize(n + 1, chainT(1, 0));
    creation.reserve(2000);
    transmission.reserve(2000);
    for (int i = 1; i <= m; ++i) {
        int u, v;
        cin >> u >> v;
        rel[u].push_back(v);
        rel[v].push_back(u);
    }
    int k;
    cin >> delay >> k;
    for (int i = 1; i <= k; ++i) {
        int a, b, c;
        cin >> a >> b;
        if (cin.get() == '\n' || cin.eof()) {
            query(a, b);
        } else {
            cin >> c;
            gen(a, b, c);
        }
    }
}

#include <bits/stdc++.h>
using namespace std;
using element = string;

map<element, int> &operator+=(map<element, int> &a, const map<element, int> &b) {
    for (const auto &p : b) {
        a[p.first] += p.second;
    }
    return a;
}
map<element, int> operator*(int coef, const map<element, int> &b) {
    map<element, int> r;
    for (const auto &p : b) {
        r[p.first] = p.second * coef;
    }
    return r;
}

map<element, int> parseTerm(const string &str);
map<element, int> parseFormula(const string &str);
size_t parseCOEF(const string &str, size_t pos, int &coef);

map<element, int> parseTerm(const string &str) {
    map<element, int> r;
    if (str.front() == '(') {
        return parseFormula(str.substr(1, str.size() - 2));
    }
    ++r[str];
    return r;
}

map<element, int> parseFormula(const string &str) {
    map<element, int> r;
    size_t i = 0;
    int level = 0;
    string term;
    while (i < str.size()) {
        if (level > 0) {
            if (str[i] == '(') {
                ++level;
            } else if (str[i] == ')') {
                --level;
            }
            term += str[i];
            ++i;
        } else {

            // 在level=0，只有小写才代表上一项没有结束。
            if (islower(str[i])) {
                term += str[i];
                ++i;
            } else {
                // level=0，非小写一律代表上一个符号已经结束。
                // 此处处理
                if (!term.empty()) {
                    int co = 0;
                    i += parseCOEF(str, i, co);
                    r += co * parseTerm(term);
                    term.clear();
                }
                if (str[i] == '(') {
                    ++level;
                    term = str[i];
                    ++i;
                } else if (isupper(str[i])) {
                    term = str[i];
                    ++i;
                }
            }

        }

    }
    // 不要忘了最后可能还有一项，循环中可能没有处理。
    if (!term.empty()) {
        int co = 0;
        parseCOEF(str, i, co);
        r += co * parseTerm(term);
        term.clear();
    }
    return r;
}

// 返回coef长度
size_t parseCOEF(const string &str, size_t pos, int &coef) {
    if (pos >= str.size()) {
        coef = 1;
        return 0;
    }
    coef = 0;
    size_t i = pos;
    if (isdigit(str[i])) {
        coef = str[i] - '0';
        ++i;
        while (i < str.size() && isdigit(str[i])) {
            coef = coef * 10 + (str[i] - '0');
            ++i;
        }
    } else {
        coef = 1;
    }
    return i - pos;
}

map<element, int> parseExpr(const string &str) {
    map<element, int> r;
    size_t i = 0, ni = str.find('+');
    if (ni == string::npos) {
        int coef, coeflen;
        coeflen = parseCOEF(str, 0, coef);
        r += coef * parseFormula(str.substr(coeflen));
    } else
        while (i != string::npos) {
            int coef, coeflen;
            coeflen = parseCOEF(str, i, coef);
            if (ni != string::npos) {
                r += coef * parseFormula(str.substr(i + coeflen, ni - (i + coeflen)));
            } else {
                r += coef * parseFormula(str.substr(i + coeflen));
            }
            if (ni != string::npos) {
                i = ni + 1;
                ni = str.find('+', i);
            } else {
                i = ni;
            }
        }
    return r;
}

bool legalEquation(const string &str) {
    size_t i = str.find('=');
    if (i == string::npos) return false;
    return parseExpr(str.substr(0, i)) == parseExpr(str.substr(i + 1, str.size()));
}

int main() {
    ios_base::sync_with_stdio(false);
    int n;
    cin >> n;
    cin.get();
    while (n--) {
        string e;
        getline(cin, e);
        cout << (legalEquation(e) ? "Y" : "N") << endl;
    }
}

#include <bits/stdc++.h>
using namespace std;
int times[4] = {0, 0, 0, 0};

bool skip(int x) {
    if (x % 7 == 0) return true;
    while (x > 0) {
        if (x % 10 == 7) return true;
        x /= 10;
    }
    return false;
}

int main() {
    assert(!skip(6)); assert(!skip(1));
    assert(skip(7));  assert(skip(17));  assert(skip(71)); assert(skip(711)); assert(skip(117)); assert(skip(171));
    ios_base::sync_with_stdio(false);
    // n: 要喊的数的数量
    // i: 要喊的数
    // cnt：已喊的数
    int n, i=1;
    cin >> n;
    for(int cnt=0; cnt<n; i++) {
        int who = (i-1)%4;
        if(skip(i)) {
            times[who]++;
        } else {
            cnt++;
        }
    }
    cout << times[0] << endl
    << times[1] << endl
    <<  times[2] << endl
    <<  times[3] << endl;
}

#include <bits/stdc++.h>
using namespace std;

set<pair<int, int>> p;
vector<int> cnt(5);
set<pair<int, int>> pre;

int main() {
    ios_base::sync_with_stdio(false);
    int n;
    cin >> n;
    int minx = 100000, miny = 100000;
    int maxx = -1, maxy = -1;
    while (n--) {
        int xi, yi;
        cin >> xi >> yi;
        p.emplace(xi, yi);
        pre.emplace(xi, yi);
        pre.emplace(xi-1, yi);
        pre.emplace(xi+1, yi);
        pre.emplace(xi, yi-1);
        pre.emplace(xi, yi+1);
        if (xi < minx) {
            minx = xi;
        }
        if (xi > maxx) {
            maxx = xi;
        }
        if (yi < miny) {
            miny = yi;
        }
        if (yi > maxy) {
            maxy = yi;
        }
    }
    for (auto xp : pre) {
        int &xx = xp.first;
        int &yy = xp.second;
            if (p.count({xx, yy})
                && p.count({xx, yy - 1})
                && p.count({xx, yy + 1})
                && p.count({xx - 1, yy})
                && p.count({xx + 1, yy})
                    ) {
                int score = 0;
                if (p.count({xx - 1, yy - 1})) {
                    ++score;
                }
                if (p.count({xx - 1, yy + 1})) {
                    ++score;
                }
                if (p.count({xx + 1, yy - 1})) {
                    ++score;
                }
                if (p.count({xx + 1, yy + 1})) {
                    ++score;
                }
                ++cnt[score];
            }
    }
    cout << cnt[0] << endl
         << cnt[1] << endl
         << cnt[2] << endl
         << cnt[3] << endl
         << cnt[4] << endl;
}