NewOJ Week 3题解

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

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

A 复制粘贴

题意： 最开始是$1$行字符串，变成$n$行最少需要复制粘贴多少次。

Tag： 思维题

难度： ☆

来源： $UVA11636$

思路： 简单发现规律：从$1$开始的答案分别是：$0,1,2,2,3,3,3,3....$

根据贪心的思想，每次复制粘贴所有行，那么经过$t$次复制粘贴最多可以变成$2^t$行，对于数字$n$，只需要判断$n$在哪个$（2^{t-1},2^t]$区间即可。

答案等于数字$n-1$可以除以$2$的次数。

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int T;
    cin >> T;
    while(T--)
    {
        long long n, ans = 0;
        cin >> n;
        n--;
        while(n)n /= 2, ans++;
        cout<<ans<<endl;
    }
    return 0;
}

B Radical of N

题意： 多次询问，每次求${\sum }_{i=l}^{r}rad(i)$，其中$rad(i)$表示$i$的素因子乘积，$1\le l\le r\le 1000000$。

Tag： 数论、埃氏筛

难度： ☆☆

来源： 原创

思路： 本题为多组询问区间和，$i$的范围$[1,1000000]$，考虑打表所有数字的$rad$值，而$[l,r]$区间和可以转换成$rad$数组的前缀和$sum[r]-sum[l-1]$。这样每次询问直接$O(1)$输出结果即可。

对于$rad(n)$的求解：在素因子分解的过程中可以直接累乘，时间复杂度$O(\sqrt{n})$，所总的时间复杂度为$n\sqrt{n}$，在$n=1000000$时难以通过。

能否一次性求出所有$rad$值？

答案是可以的，先前做法是对于每个数字$n$找存在哪些素因子，而数论中的埃氏筛法是对于每个素因子$x$去找出现在哪些数字中，后者时间复杂度为$O(n\log (n))$。本题直接在埃氏筛的基础上，顺便计算一下$rad$值即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 10;
bool not_prime[maxn];
ll rad[maxn], sum[maxn];

void init(int n)    ///埃氏筛的同时，求解出每个rad的值
{
    not_prime[1] = 1;
    for(int i = 1; i <= n; i++)
        rad[i] = 1;
    for(int i = 2; i <= n; i++)if(!not_prime[i])
    {
        rad[i] = i;
        for(int j = i + i; j <= n; j += i)///j是i倍数，其中i为素数
            rad[j] *= i, not_prime[j] = 1;
    }
    for(int i = 1; i <= n; i++)
        sum[i] = sum[i - 1] + rad[i];
}

int main()
{
    int n = 1000000;
    init(n);
    int T;
    cin >> T;
    while(T--)
    {
        int l, r;
        cin >> l >> r;
        cout<<sum[r] - sum[l - 1]<<endl;
    }
    return 0;
}

C 二进制中的1

题意： $f(i)$表示数字$i$的素因子数目，求${\prod }_{i=1}^{n}f(i)$。

Tag： 数位$DP$

难度： ☆☆☆

来源： $BZOJ3209$

思路： $[1,n]$的二进制表示中恰好有$x$个$1$的数字数目，记为$s(x)$，则有：

$$\prod _{i=1}^{n}f(i)=\prod _{x=1}^{tot}{x}^{s(x)}$$

相当于我们只需要计算出$s(1),s(2),...,s(50)$即可，因为数字$n\le 10^{15}$二进制最多不会超过50位。

而$[1,n]$的二进制表示中恰好有$x$个$1$的数字数目是一道经典的数位$DP$问题。直接用$DFS$+记忆化搜索进行求解：$dp[depth][sum]$表示当前计算到第$depth$位，并且$1$的个数为$sum$的方案数。

在搜索的过程中暴力枚举第$depth$位的取值即可。$dfs$中的第三个参数$flag$表示前面枚举的数字是否达到上限。$flag=True$时，当前位的取值上限与数字$n$有关。$flag=False$时，后续都不可能达到上限，因此答案与数字$n$的值无关，对于这部分使用记忆化搜索记录答案。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 10000007;
///快速幂a^b % m
ll ksm(ll a, ll b, ll m)
{
    ll ans = 1 % m;
    a %= m;
    while(b)
    {
        if(b & 1)ans = ans * a % m;
        b >>= 1;
        a = a * a % m;
    }
    return ans;
}

int num[70];
ll dp[70][70];
//depth：当前第几位
//sum：当前有多少个1
//flag：当前是否达到上限
ll dfs(int depth, int sum, bool flag, int k)
{
    if(depth == 0)return sum == k;  //递归出口
    if(!flag && dp[depth][sum] != -1)
        return dp[depth][sum];
    int up = flag ? num[depth] : 1;
    dp[depth][sum] = 0;
    for(int i = 0; i <= up; i++)
        dp[depth][sum] += dfs(depth - 1, sum + (i == 1), flag && (i == up), k);
    return dp[depth][sum];
}

int main()
{
    ll n, ans = 1, tot = 0;
    cin >> n;
    while(n)num[++tot] = n % 2, n >>= 1;///将n进行二进制分解
    for(int i = 1; i <= tot; i++)///[1,n]中二进制中1的个数为i的方案数
    {
        memset(dp, -1, sizeof(dp));
        ll tmp = dfs(tot, 0, 1, i);
        ans = ans * ksm(i, tmp, MOD) % MOD;
    }
    cout<<ans<<endl;
    return 0;
}

D 最小生成树

题意： 平面上的$n(n\le 10^5)$个点 { ( x i , y i ) ∣ i = 1 , . . . , n , 0 ≤ x i ≤ 1 0 6 , 0 ≤ y i ≤ 10 } \{(x_i,y_i)|i=1,...,n,0\le x_i\le10^6,0\le y_i \le10\} {(xi​,yi​)∣i=1,...,n,0≤xi​≤106,0≤yi​≤10}，求最小生成树。

Tag： 贪心、最小生成树

难度： ☆☆☆

来源： $USACO2022Feb$

思路： 最小生成树模板很简单，使用$Kruskal$算法即可。核心在于无法连接$n^2$数量的边。

如何尽可能的减少边？

本题最特殊的地方在于$y_i$的取值范围。基于$y$坐标范围很小，对于某个点$(x_i,y_i)$来说，所以考虑每一行分别往左和往右连接最近的点。

为什么这样连边可以保证求MST时不出错？

如下图所示，对于红点来说，只需要连接第一个绿点而不需要连第二个绿点，这是由于在$Kruskal$算法进行的时候，首先按照边排序，而实线边长度均小于虚线边，因此虚线边本身就不会被$Kruskal$算法选中，所以对每一行的点，只需要连接左边离自己最近的和右边离自己最近的即可。

#include<bits/stdc++.h>
#define Mul(a) ((long long)(a) * (a))
using namespace std;
const int maxn = 1e5 + 10;
typedef pair<int, int> Node;
int n, tot;///点、边
Node a[maxn];   ///n个点的坐标
struct edge
{
    int u, v;
    long long w;
    edge(){}
    bool operator<(const edge& a)const
    {
        return w < a.w;
    }
}e[maxn * 22];

void add_edge(int u, int v)//点u和点v连边
{
    tot++;
    e[tot].u = u;
    e[tot].v = v;
    e[tot].w = Mul(a[u].first - a[v].first) + Mul(a[u].second - a[v].second);
    //cout<<u<<" "<<v<<" "<<e[tot].w<<endl;
}
int f[maxn];//并查集
int Find(int x)
{
    return x == f[x] ? x : f[x] = Find(f[x]);
}
void kruskal()
{
    for(int i = 1; i <= n; i++)//并查集初始化
        f[i] = i;
    sort(e + 1, e + 1 + tot);//边排序
    long long ans = 0;
    for(int i = 1; i <= tot; i++)//从小到大遍历边
    {
        int u = Find(e[i].u), v = Find(e[i].v);
        if(u != v)f[u] = v, ans += e[i].w;
    }
    cout<<ans<<endl;
}
int Last[15];
int main()
{
    cin >> n;
    for(int i = 1; i <= n; i++)cin >> a[i].first >> a[i].second;
    //对点排序
    sort(a + 1, a + 1 + n);
    //每个点往每行的左边最近点连边
    for(int i = 0; i <= 10; i++)Last[i] = 0;
    for(int i = 1; i <= n; i++)
    {
        for(int y = 0; y <= 10; y++)if(Last[y])
            add_edge(i, Last[y]);
        Last[a[i].second] = i;
    }
    //每个点往每行的右边最近点连边
    for(int i = 0; i <= 10; i++)Last[i] = 0;
    for(int i = n; i >= 1; i--)
    {
        for(int y = 0; y <= 10; y++)if(Last[y])
            add_edge(i, Last[y]);
        Last[a[i].second] = i;
    }
    kruskal();
    return 0;
}

E 黑白边

题意： 给定一颗$n$个节点的树，根节点为1，初始均为黑色边。两种操作：$Axy$把边$<x,y>$修改为白色，$Wx$，询问$1$到$n$的路径上黑色边数量。

Tag： $dfs$序、树状数组

难度： ☆☆☆

来源： $POI2007$

思路： 题目相当于每次修改树的边权，每次询问从根节点到其他节点的距离。

考虑预处理出$dfs$序，因为树的$dfs$序将问题变成单点修改区间查询。

例如样例中的$dfs$先序遍历序列：1 2 2 3 3 4 5 5 4 1，节点$i$进入的$dfs$序记为$L[i]$，出去的$dfs$序记为$R[i]$。

将边的权值下放，即每个点$i$表示其父亲到点$i$这条边的边权，每个点进入的时候$+1$、出去的时候$-1$，即在$L[i]$处减$1$、在$R[i]$处减$1$，可以得到数组$a$。

可以发现，从根节点$1$到节点$i$的距离，等价于$a$数组前缀和$[1,L[i]]-1$。这是由于$dfs$序使得一个子树正好是对应一个连续区间，当进入时$+1$、出去时$-1$可以保证子树遍历结束总和为0。

对于修改操作：$<x,y>$，记$y$为儿子，那么只需要把最开始$L[y]$的$+1$和$R[y]$的$-1$抵消掉即可，相当于把这条边的边权赋值为$0$。

#include<bits/stdc++.h>
#define lowbit(x) ((x) & (-x))
using namespace std;
const int maxn = 250000 + 10;
int n, tree[maxn * 2];
vector<int>G[maxn];
int read() {
  int x = 0, w = 1;
  char ch = 0;
  while (ch < '0' || ch > '9') {  // ch 不是数字时
    if (ch == '-') w = -1;        // 判断是否为负
    ch = getchar();               // 继续读入
  }
  while (ch >= '0' && ch <= '9') {  // ch 是数字时
    x = x * 10 + (ch - '0');  // 将新读入的数字’加’在 x 的后面
    // x 是 int 类型，char 类型的 ch 和 ’0’ 会被自动转为其对应的
    // ASCII 码，相当于将 ch 转化为对应数字
    // 此处也可以使用 (x<<3)+(x<<1) 的写法来代替 x*10
    ch = getchar();  // 继续读入
  }
  return x * w;  // 数字 * 正负号 = 实际数值
}
//树状数组模板
void add(int x, int d)
{
    while(x <= n + n)
        tree[x] += d, x += lowbit(x);
}
int sum(int x)
{
    int ans = 0;
    while(x)
        ans += tree[x], x -= lowbit(x);
    return ans;
}

//求dfs序
int l[maxn], r[maxn], cnt;
void dfs(int u)
{
    //cout<<u<<endl;
    l[u] = ++cnt;
    for(auto v : G[u])
        dfs(v);
    r[u] = ++cnt;
}

int main()
{
    n = read();
    for(int i = 1; i < n; i++)
    {
        int u, v;
        u = read();v = read();
        if(u > v)swap(u, v);
        G[u].push_back(v);
    }
    dfs(1);
    //for(int i = 1; i <= n; i++)
    //    cout<<i<<" "<<l[i]<<" "<<r[i]<<endl;
    for(int i = 1; i <= n; i++)
        add(l[i], 1), add(r[i], -1);
    int m;
    m = read();
    m = m + n - 1;
    while(m--)
    {
        char op;
        op = getchar();
        if(op == 'A')
        {
            int x, y;
            x = read();
            y = read();
            if(x > y)swap(x, y);
            add(l[y], -1);
            add(r[y], 1);
        }
        else
        {
            int x;
            x = read();
            printf("%d\n", sum(l[x]) - 1);
        }
    }
    return 0;
}