上海计算机学会9月月赛 乙组题解

上海计算机学会9月月赛 乙组题解

本次比赛考了折半搜索、二分、最短路、拓扑排序、组合数学。整体难度还是偏大的，题目比较模板，没什么套路，但是需要同学们学过这部分算法。

比赛链接：https://iai.sh.cn/contest/55

第一题：T1子集和（七）

标签：折半搜索、二分
题意：给定$n$个数字$a_1,a_2,\dots ,a_n$构成一个集合（本题中所指的集合元素允许相等），请计算有多少子集的和大于$0$？（$1\le n\le 40$，$-10^9\le a_i\le 10^9$）
题解：$n$的数据范围是$40$，直接暴力搜索时间复杂度会到达$2^{40}$，肯定会超时，所以得先分成两个集合，折半搜索处理一下，然后对两个集合进行排序。对第一个集合进行遍历，通过二分，去第二个集合中找到第一个大于$-s1[i]$的位置$j$，因为已经排序过了，从$j$到第二个集合最后一个元素都是能够加起来和大于$0$的。
代码：

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

typedef long long ll;
const ll N = 2e6;
ll n, a[50], ans = 0;
ll s1[N], s2[N], c1 = 0, c2 = 0;

void dfs1(ll p, ll sum) {
    if (p == n / 2 + 1) {
        s1[c1++] = sum;
        return ;
    }
    dfs1(p + 1, sum + a[p]);
    dfs1(p + 1, sum);
}

void dfs2(ll p, ll sum) {
    if (p == n + 1) {
        s2[c2++] = sum;
        return ;
    }
    dfs2(p + 1, sum + a[p]);
    dfs2(p + 1, sum);
}

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    dfs1(1, 0);
    dfs2(n / 2 + 1, 0);
    sort(s1, s1 + c1);
    sort(s2, s2 + c2);

    for (int i = 0; i < c1; i++) {
        ll j = upper_bound(s2, s2 + c2, -s1[i]) - s2;
        ans += c2 - j;
    }

    cout << ans;
    return 0;
}

第二题：T2方格路径（二）

标签：最短路
题意：给定$n\times m$的方格地图，每个点要么是空地$.$，要么是障碍物$\ast$，求左上角到右下角，最少的移除障碍个数，每次只能水平或者垂直移动。
题解：跑个最短路，如果走的下个点是障碍物，边权为$1$，否则为$0$。直接跑$SPFA$会超时，得用堆优化的$dijkstra$。这边代码为了方便，直接$pair$套$pair$了。
代码：

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

const int INF = 0x3f3f3f3f;
int d[1005][1005], vis[1005][1005];
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
char a[1005][1005];
pair<int, int> p;

int main() {
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
    for (int j = 1; j <= m; j++) {
        cin >> a[i][j];
        d[i][j] = INF;
    }

    priority_queue< pair<int, pair<int, int> > > q;
    d[1][1] = 0;
    q.push(make_pair(0, make_pair(1, 1)));

    while (!q.empty()) {
        p = q.top().second;
        q.pop();
        if (vis[p.first][p.second]) continue;
        vis[p.first][p.second] = 1;
        for (int i = 0; i < 4; i++) {
            int nx = p.first + dx[i];
            int ny = p.second + dy[i];
            int cost = (a[nx][ny] == '*') ? 1 : 0;
            if (nx < 1 || nx > n || ny < 1 || ny > m) continue;
            if (d[nx][ny] > d[p.first][p.second] + cost) {
                d[nx][ny] = d[p.first][p.second] + cost;
                q.push(make_pair(-d[nx][ny], make_pair(nx, ny)));
            }
        }
    }

    cout << d[n][m];
    return 0;
}

第三题：T3工程建设

标签：拓扑排序
题意：有$n$个建设任务，第$i$个建设任务完成时间为$t_i$。给定$m$个前置任务要求，第$j$条规则，若要开工$b_j$号任务，必须先完成$a_j$号任务。所有任务可以并行开工，求最快多少时间完成任务。
题解：拓扑排序模板题，把图建好，入度为$0$的点都扔到队列中，跑图过程中更新一下$u$->$v$，$v$这个顶点的最大时间，要完成所有$v$的前置任务，对该点$v$得求最大值。最终再对每个点求个最大时间就好了。
代码：

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

const int N = 2e5 + 10;
queue <int> q;
vector<int> e[N];
int t[N], in[N], mx[N];
int n, m, ans = 0;

void toposort() {
    for (int i = 1; i <= n; i++) {
        if (in[i] == 0) {
            q.push(i);
            mx[i] = t[i];
        }
    }
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int i = 0; i < e[u].size(); i++) {
            int v = e[u][i];
            in[v]--;
            if (in[v] == 0) q.push(v);
            mx[v] = max(mx[v], mx[u] + t[v]);
        }
    }
    for (int i = 1; i <= n; i++) ans = max(ans, mx[i]);
}

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> t[i];
    for (int i = 1; i <= m; i++) {
        int a, b;
        cin >> a >> b;
        in[b]++;
        e[a].push_back(b);
    }
    toposort();
    cout << ans << endl;
    return 0;
}

第四题：T4组合数

标签：组合数学
题意：求组合数$C_n^m$，即从$n$个不同的数字中取出$m$个数字的方案数，结果对$1,000,000,007$取模
（$1\le m\le n\le 10^9，1\le m\le 10^6$）
题解：直接通过通项公式$C_n^m=\frac{n!}{m!(n-m)!}$，值得注意的是要进行取模，所以得用到逆元$inv$。
费马小定理：$a^{p-1}\equiv 1(modp)$，两边同时除以$a$，$a^{p-2}\equiv inv(a)(modp)$，即$inv(a)=a^{p-2}(modp)$，得到$a^{p-2}$这部分可以通过快速幂去得到。
代码：

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

typedef long long ll;
const ll p = 1e9 + 7;

ll fast_power(ll a, ll b) {
    ll ans = 1;
    a %= p;
    while (b) {
        if (b & 1) ans = (ans * a) % p;
        a = (a * a) % p;
        b >>= 1;
    }
    return ans;
}

ll C(ll a, ll b) {
    if (b > a) return 0;
    if (a == b) return 1;
    ll ans1 = 1, ans2 = 1;
    for (ll i = 1; i <= b; i++) {
        ans1 = ans1 * (a - i + 1) % p;
        ans2 = ans2 * i % p;
    }
    return ans1 * fast_power(ans2, p - 2) % p;
}

int main() {
    ll n, m;
    cin >> n >> m;
    cout << C(n, m);
    return 0;
}