我的博客

两数之和

签到题

思路：除了和不行，其他都可以用和凑出来

void solve() {
    int n; cin >> n;
    if (n == 2 || n == 1) {
        cout << "NO" << '\n';
    } else {
        cout << "YES" << '\n';
        cout << 1 << ' ' << n - 1 << '\n';
    }
}

小红装匣子

思路：可以发现填的块的条件很苛刻，所以我们尽量先填的，并且的得同时在上下两行一起填，然后剩下的看看的能不能补齐就行

void solve() {
    int a, b, n; cin >> a >> b >> n;
    int c = b / 2, v = c * 3, cv;
    if (v > n) {
        cv = n - (c - 1) * 3;
    } else {
        cv = n - v;
    }
    if (cv > a) cout << "NO" << '\n';
    else cout << "YES" << '\n';
}

小红的数字对对碰

这个题比赛太糖了 思路：其实不知道补码也没问题，直接在编译器上试一下就知道：负数和正数异或是负数，负数和负数异或是正数，相同的数异或是零，所以最优的一定是先把除了负数以外的相同的数两两异或消去，剩下的数再用负数两两异或消去，如果还剩下负数，就让负数两两相加消去

void solve() {
    int n; cin >> n;
    int c = 0;
    map<int, int> mp;
    for (int i = 1, x; i <= n; i ++) {
        cin >> x;
        if (x < 0) c ++;
        else mp[x] ++;
    }
    int ans = n;
    int cc = 0;
    for (auto [x, y] : mp) {
        ans -= (y / 2) * 2;
        cc += y % 2;
    }
    if (c >= cc) {
        ans -= cc * 2 + (c - cc) / 2 * 2;
    } else {
        ans -= c * 2;
    }
    cout << ans << '\n';
}

小红的括号串

思路：因为每个数数位的顺序不能改变，所以我们直接把每个字符串扔到优先队列（大根堆）里面，动态更新每一个字符串，就行，因为每个数的长度最多位

	void solve() {
    int n; cin >> n;
    vector<string> a(n + 1);
    for (int i = 1; i <= n; i ++) {
        cin >> a[i];
    }
    priority_queue<string> Q;
    for (int i = 1; i <= n; i ++) {
        Q.push(a[i]);
    }
    string s = "";
    while (Q.size()) {
        auto t = Q.top();
        Q.pop();
        s += t[0];
        if (t.size() > 1) {
            Q.push(t.substr(1));
        }
    }
    cout << s << '\n';
}

小红的图上加边

思路：每次连边的代价是连通块内点的最大值，所以要让代价最小，我们应该每次连接一条边后连通块的最大值就是我这一次加入点或联通块的值,并且以权值最小的点和连通块最为起点，我们先把当前有的联通块用并查集当成一个点（权值位连通块里面点的最大值），然后依次将每个点的权值相加即可

struct DSU {
    vector<int> fa, sz;

    DSU(int n) {
        fa.resize(n + 1);
        sz.resize(n + 1, 1);
        iota(fa.begin(), fa.end(), 0);
    }

    int find(int x) {
        if (fa[x] != x) fa[x] = find(fa[x]);
        return fa[x];
    }

    bool same(int x, int y) {
        int px = find(x);
        int py = find(y);
        return px == py;
    }

    void merge(int x, int y) {
        int px = find(x);
        int py = find(y);
        if (px != py) {
            fa[px] = py;
            sz[py] += sz[px];
        }
    }
};

void solve() {
    int n, m; cin >> n >> m;
    vector<int> val(n + 1);
    for (int i = 1; i <= n; i ++) {
        cin >> val[i];
    }
    vector<int> vis(n + 1);
    DSU dsu(n + 1);
    map<int, int> mp;
    for (int i = 1; i <= m; i ++) {
        int u, v; cin >> u >> v;
        dsu.merge(u, v);
        vis[u] = 1;
        vis[v] = 1;
    }
    vector<int> t;
    for (int i = 1; i <= n; i ++) {
        if (vis[i]) {
            int pi = dsu.find(i);
            mp[pi] = max(mp[pi], val[i]);
        } else t.push_back(val[i]);
    }
    for (auto [x, y] : mp) {
        t.push_back(y);
    }
    int ans = 0;
    sort(t.begin(), t.end());
    for (int i = 1; i < t.size(); i ++) {
        ans += t[i];
    }
    cout << ans << '\n';
}

小红的括号串

思路：这里有个结论，只要左右括号相等，通过循环移位一定可以成为合法的字符串序列，所以这道题就变成一道组合数学的题了

int fac[N], inf[N];

int ksm(int a, int b) {
    int res = 1;
    while (b) {
        if (b & 1) res = res * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res;
}

int C(int n, int m) {
    return fac[n] * inf[n - m] % mod * inf[m] % mod;
}


void solve() {
    fac[0] = inf[0] = 1;
    for (int i = 1; i < N; i++) {
        fac[i] = fac[i - 1] * i % mod;
        inf[i] = inf[i - 1] * ksm(i, mod - 2) % mod;
    }
    int n; cin >> n;
    string s; cin >> s;
    int c1 = 0, c2 = 0, cv = 0;
    for (auto i : s) {
        c1 += (i == '(');
        c2 += (i == ')');
        cv += (i == '?');
    }
    if (c1 > n / 2 || c2 > n / 2 || n & 1) {
        cout << 0 << '\n';
    } else cout << C(cv, abs(c1 - c2) + (cv - abs(c1 - c2)) / 2) << '\n';
}