NewOJ Week 5题解

NewOJ周赛于2022年3月19日正式开始，比赛时间为每周六晚19:00-22:00。

比赛链接：http://oj.ecustacm.cn/contest.php?cid=1019

A 并行处理

题意： 现在有$n$个任务需要到GPU上运行，但是只有两张​GPU，每张​GPU​一次只能运行一个任务，两张GPU可以并行处理。告诉你$n$个任务需要的时间，你需要选择一个数字$i$：将任务$1$到任务$i$放到第一个GPU上运行，任务$i+1$到任务$n$放到第二个GPU上运行。求最短运行时间。

Tag： 思维题，前缀和

难度： ☆

来源： $CodeChefEasy$

思路： 最短运行时间为 m i n { m a x ( ∑ j = 1 i a j , ∑ j = i + 1 n a j ) , i = 1 , . . . , n } min\{max(\sum_{j=1}^ia_j,\sum_{j=i+1}^na_j),i=1,...,n\} min{max(∑j=1i​aj​,∑j=i+1n​aj​),i=1,...,n}。如果暴力计算每一个$i$，则总的时间复杂度为$O(n^2)$。

优化： 利用前缀和来优化里面那一项，最短运行时间为 m i n { m a x ( s u m [ i ] ， s u m [ n ] − s u m [ i ] ) , i = 1 , . . . , n } min\{max(sum[i]，sum[n]-sum[i]),i=1,...,n\} min{max(sum[i]，sum[n]−sum[i]),i=1,...,n}，这样时间复杂度为$O(n)$。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 10;
ll sum[maxn];
int main()
{
    int n;
    cin >> n;
    for(int i = 1; i <= n; i++)
    {
        int x;
        cin >> x;
        sum[i] = sum[i - 1] + x;
    }
    ll ans = sum[n];
    for(int i = 1; i <= n; i++)
        ans = min(ans, max(sum[i], sum[n] - sum[i]));
    cout<<ans<<endl;
    return 0;
}

B 排列变换

题意： 给定一个长度为$n$的排列$a$，需要将这个排列变成$b$。每次可以选择一个数字往左移若干个位置。请求出最小移动次数。

Tag： 思维题，类逆序对

难度： ☆☆

来源： $USACO2022Feb$

思路： 将排列$a$转换成排列$b$，首先需要处理出数组$c$，$c[i]$表示数字$a[i]$在$b$中的下标。

例如样例$a=[5,1,3,2,4],b=[4,5,2,1,3]$，对应的$c=[2,4,5,3,1]$。$c$表示当前排列$a$对应的$b$中的下标，则最终肯定要把$c$变成$[1,2,3,4,5]$。

则问题变成：每次可以将$c$数组中的数字往左移，最终变成$[1,2,3,4,5]$，求最小移动次数。

什么时候一定要往左移？存在逆序的时候，即$c[i]$的左边存在一个大于$c[i]$的数字，则$c[i]$一定要左移。

对于每个$c[i]$判断左边是否有数字大于$c[i]$，暴力求解时间复杂度为$O(n^2)$。

优化： 维护一个从左往右的最大值，判断最大值是否大于$c[i]$即可。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn], b[maxn], c[maxn];
int id[maxn];///id[x]表示数字x在b数组中的下标

int main()
{
    int n;
    cin >> n;
    for(int i = 1; i <= n; i++)
        cin >> a[i];
    for(int i = 1; i <= n; i++)
        cin >> b[i], id[b[i]] = i;
    ///把a数组全部变成对应b数组的下标
    for(int i = 1; i <= n; i++)
        c[i] = id[a[i]];
    int ans = 0, Max = 0;
    for(int i = 1; i <= n; i++)
    {
        ///只要目前c[i]左边有一个比c[i]大的数字，则答案++
        if(Max > c[i])ans++;
        Max = max(Max, c[i]);
    }
    cout<<ans<<endl;
    return 0;
}

C 硬币游戏

题意： $N$个硬币，每次可以移除1个或者$p^x$个，其中$p$为质数，$x$为正整数。均采取最优策略，求先手胜还是后手胜。

Tag： 博弈论，找规律

难度： ☆☆

来源： $CodeChefEasy$

思路： 小范围模拟，可以发现$N=1,2,3,4,5$时，均为必胜态，因为$2,3,5$为质数，$4=2^2$，而$N=6$为必败态。按照这个规律可以发现问题变成巴什博奕。

博弈基础：必胜态可以转换成必败态，而必败态只能转换成必胜态。

$N$只要是$6$的倍数，那么一定是必败态。

1、如果$N\%6=0$，由于取出的数字要么是$1$，要么是质数的幂，不可能取出一个$6$的倍数，因此只能转移到非$6$的倍数。

2、如果$N\%6\ne 0$，那么一定可以让对方面临$6$的倍数。

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

int main()
{
    int T;
    cin >> T;
    while(T--)
    {
        int n;
        cin >> n;
        if(n % 6 != 0)cout<<"Alice"<<endl;
        else cout<<"Bob"<<endl;
    }
    return 0;
}

D 矩阵

题意： 给定两个$n\ast n$的矩阵$A$和$B$，记$C=A\ast B$（此处为矩阵乘法），$m$次询问，每次询问$C$中一个子矩阵中所有数字之和。

Tag： 数学，前缀和，枚举

难度： ☆☆☆

来源： $BZOJ2901$

思路： 矩阵乘法：$C_{i,j}={\sum }_{k=1}^n{A}_{i,k}{B}_{k,j}$，对于每次询问$a,b,c,d$，询问子矩阵和为：
$$\begin{array}{rl}ans& =\sum _{i=a}^c\sum _{j=b}^d{C}_{i,j}\\ & =\sum _{i=a}^c\sum _{j=b}^d\sum _{k=1}^n{A}_{i,k}{B}_{k,j}\\ & =\sum _{k=1}^n\sum _{i=a}^c\sum _{j=b}^d{A}_{i,k}{B}_{k,j}\\ & =\sum _{k=1}^n\left[\left(\sum _{i=a}^c{A}_{i,k}\right)\left(\sum _{j=b}^d{B}_{k,j}\right)\right]\end{array}$$
可以发现，括号中的两个值分别可以用$A$的列前缀和、$B$的行前缀和$O(1)$获取。
$$\begin{gathered} \sum _{i=a}^c{A}_{i,k}=(Su{m}_A[c][k]-Su{m}_A[a-1][k]) \\ \sum _{i=b}^d{B}_{k,j}=(Su{m}_B[k][d]-Su{m}_B[k][b-1]) \end{gathered}$$
因此，对于每次询问，暴力枚举$k$即可，时间复杂度$O(n^2+m\ast n)$

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9 + 7;
template <typename T>
inline T read(T& x) {
  x = 0;
  T w = 1;
  char ch = 0;
  while (ch < '0' || ch > '9') {
    if (ch == '-') w = -1;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9') {
    x = x * 10 + (ch - '0');
    ch = getchar();
  }
  return x = x * w;
}
const int maxn = 2010;
int A[maxn][maxn], B[maxn][maxn];
int main()
{
    int n, m;
    read(n); read(m);
    ///读入矩阵，同时处理前缀和
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
            read(A[i][j]), A[i][j] += A[i - 1][j];
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
            read(B[i][j]), B[i][j] += B[i][j - 1];
    while(m--)
    {
        int a, b, c, d;
        read(a);read(b);read(c);read(d);
        ///可能存在a>c、b>d的情况
        if(a > c)swap(a, c);
        if(b > d)swap(b, d);
        ll ans = 0;
        for(int k = 1; k <= n; k++)
            ans += (ll)(A[c][k] - A[a - 1][k]) * (B[k][d] - B[k][b - 1]);
        printf("%lld\n", ans);
    }
    return 0;
}

E 可达点

题意： 在$n$个点$m$条边的有向图中，请你求出有多少个点是可达点。点$u$为可达点：所有其他的点均可到达点$u$。

Tag： 强连通分量、缩点

难度： ☆☆☆

来源： $BZOJ1051$

思路： 可达点表示所有点都可到达的点。对于一个普通图来说暴力去做肯定会超时，而对于$DAG$来说，只需要统计出度为0的点是否只存在1个。

在有向无环图中，出度为$0$的点一定存在。如果存在多个，则说明这几个点之间互相是不可达的，此时不存在可达点。因此如果存在可达点，则最多存在$1$个出度为0的点。

对于普通图而言，可以利用缩点，将图转换成$DAG$，只需要求出$DAG$中出度为$0$的数目，等于1则有解。记$DAG$中找到的可达点编号为$u$，此时原图中可达点的数量$u$对应原图强连通分量中点的数目。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 10000 + 10;
vector<int>G[maxn];
int pre[maxn], lowlink[maxn], sccno[maxn], dfs_clock, scc_cnt;
stack<int>S;

void dfs(int u)
{
    pre[u] = lowlink[u] = ++dfs_clock;
    S.push(u);
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        if(!pre[v])
        {
            dfs(v);
            lowlink[u] = min(lowlink[u], lowlink[v]);
        }
        else if(!sccno[v])
        {
            lowlink[u] = min(lowlink[u], pre[v]);
        }
    }
    if(lowlink[u] == pre[u])
    {
        scc_cnt++;
        for(;;)
        {
            int x = S.top();
            S.pop();
            sccno[x] = scc_cnt;
            if(x == u)break;
        }
    }
}
//求解强连通分量
void find_scc(int n)
{
    dfs_clock = scc_cnt = 0;
    for(int i = 0; i < n; i++)if(!pre[i])dfs(i);
}
int chu[maxn];
int main()
{
    int n, m, u, v;
    scanf("%d%d", &n, &m);
    while(m--)
    {
        scanf("%d%d", &u, &v);
        u--, v--;
        G[u].push_back(v);
    }
    find_scc(n);
    //重新构图成DAG，计算每个新点的出度
    for(int u = 0; u < n; u++)
    {
        for(int i = 0; i < G[u].size(); i++)
        {
            int v = G[u][i];
            if(sccno[u] != sccno[v])
            {
                chu[sccno[u]]++;
            }
        }
    }
    //统计出度为0点的个数
    int tot = 0, t;
    for(int i = 1; i <= scc_cnt; i++)
        if(chu[i] == 0)tot++, t = i;
    int ans = 0;
    if(tot == 1)//只有1个点出度为0，计算对应强连通分量中的点
    {
        for(int i = 0; i < n; i++)
        {
            if(sccno[i] == t)ans++;
        }
    }
    printf("%d\n", ans);
    return 0;
}