Educational Codeforces Round 80 (Rated for Div. 2)

A. Deadline

题目链接：https://codeforces.com/contest/1288/problem/A

题意：

给你一个 N 和 D，问是否存在一个 X ， 使得 $x+\lceil \dfrac {x}{d+1}\rceil \leq n$

分析：

可以将式子变为 

$\begin{aligned}\left( x+1\right) +\lceil \dfrac {d}{x+1}\rceil \leq n+1\\ \Rightarrow 2\sqrt {d}\leq n+1\end{aligned}$

然后判断一下即可

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 2e5 + 10;
int main()
{
    int t;
    cin >> t;
    while(t --)
    {
        double n , d;
        cin >> n >> d;
        if(2 * sqrt(d) <= n + 1)
        cout << "YES" << '\n';
        else cout << "NO" << '\n';
    }
    return 0;
}

B. Yet Another Meme Problem

题目链接：https://codeforces.com/contest/1288/problem/B

题意：

给你一个 A 和 B，你可以从1 - A 中任选一个 a ，1 - B 中任选一个 b，使得 a + b + a * b = conc(a , b)  // conc(12 , 23) = 1223

问你最多可以从两个集合中找出几对满足上述关系的a ，b

分析：

设 k 为 B 的位数，则 conc(a , b) = a * 10 ^ k + b , 即

$\begin{aligned}a\times b+a+b=a\times 10^{k}+b\\ \Rightarrow a\left( b+1\right) =a\times 10^{k}\end{aligned}$

所以当b = 10^x-1时则任意a都可以与b组成一对,所以ans = A * (1 - B 中 9,99,999...的个数)

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 2e5 + 10;
int main()
{
    int t;
    cin >> t;
    while(t --)
    {
        ll a , b;
        cin >> a >> b;
        int now = 9 , cnt = 0;
        while(now <= b) now = now * 10 + 9 , cnt ++;
        cout << a * cnt << '\n';
    }
    return 0;
}

C. Two Arrays

题目链接：https://codeforces.com/contest/1288/problem/C

题意：

给你一个 N 和 M（1 <= N <= 1000 , 1 <= M <= 10 ），M表示数组的长度，N表示你可以任意使用[1 , N]内的数字（可重复使用）

问你有多少种方法构造两个数组 A , B 使得 A 数组不降序 , B数组不升序且对于数组中的任一位置 i 都有ai < bi

分析：

①dp

因为数据范围不大 ，所以比赛时很快想到了O(n * n * m)的做法

定义dp1[i][j] 表示 A数组第 i 项为 j 有多少种方案，定义dp2[i][j]表示 B数组第 i 项为 j 有多少种方案

则 $ans=\sum ^{n}_{i=1}\sum ^{n}_{i=i}dp_{1}\left[ m\right] \left[ i\right] \times dp_{2}\left[ m\right] \left[ j\right] $

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int MOD = 1e9 + 7;
const int N = 1e3 + 10;
ll dp1[15][N] , dp2[15][N];
int main()
{
    int n , m;
    cin >> n >> m;
    for(int i = 1 ; i <= n ; i ++)
        dp1[1][i] = dp2[1][i] = 1;
    for(int i = 2 ; i <= m ; i ++)
        for(int j = 1 ; j <= n ; j ++)
            for(int k = 1 ; k <= j ; k ++)
                dp1[i][j] += dp1[i - 1][k] , dp1[i][j] %= MOD;
    for(int i = 2 ; i <= m ; i ++)
        for(int j = 1 ; j <= n ; j ++)
            for(int k = j ; k <= n ; k ++)
                dp2[i][j] += dp2[i - 1][k] , dp2[i][j] %= MOD;
    ll ans = 0;
    for(int i = 1 ; i <= n ; i ++)
        for(int j = i ; j <= n ; j ++)
            ans += dp1[m][i] * dp2[m][j] , ans %= MOD;
    cout << ans << '\n';
    return 0;
}

②组合数学

由题可得 a1 <= a2 <= a3 ... <= am，b1 >= b2 >= b3 ... >= bm，又因为bm >= am

所以a1,a2,a3...am,bm,...b3,b2,b1就是一长度为2 * m且不降序的数组

我们设 xi 为第 i 个数被选中的次数，那么 x1 + x2 + x3 + ... + xn = 2 * m

于是我们可以把数组中的每一个位置看成一个小球，把n个数中的每一个数看成一个盒子

那么就有 2 * m个小球，n个盒子。题目就可以转换为我们要将2 * m个小球放在n个盒子里（盒子可以为空）

这样就成了隔板法的经典例题

卢卡斯随便一搞就完事了

/*这句话写给我自己看⊙︿⊙*/

/*(先通过这个方法计算总方案数,每个方案选择出来的数都可以从小到大插到2 * m个位置上,所以每个方案必定合法,对答案必定有贡献)*/

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int MOD = 1e9 + 7;
const int N = 2e5 + 10;
ll F[N];
void init(ll p)
{
    F[0] = 1;
    for(int i = 1;i <= p;i++)
        F[i] = F[i-1]*i % MOD;
}
ll inv(ll a,ll m)
{
    if(a == 1)return 1;
    return inv(m%a,m)*(m-m/a)%m;
}
ll Lucas(ll m,ll n,ll p)
{
    ll ans = 1;
    while(n && m)
    {
        ll a = n % p;
        ll b = m % p;
        if(a < b)return 0;
        ans = ans * F[a] % p * inv(F[b] * F[a - b] % p , p) % p;
        n /= p;
        m /= p;
    }
    return ans;
}
int main()
{
    init(N);
    int n , m;
    cin >> n >> m;
    cout << Lucas(n - 1 , 2 * m + n - 1 , MOD) << '\n';
    return 0;
} 

D. Minimax Problem

题目链接：https://codeforces.com/contest/1288/problem/D

题意：

给你 n <= 3e5 个长度为 m <= 8 的数组，你需要选出两个数组a , b使他们的每一位结合（留下max(ai , bi)），结合后数组中的最小值必须尽可能的大

分析：

首先我们肯定需要一个数作为最小值来进行筛选，但是题目最多可能有 n * m 种数，枚举每个数再操作肯定是不可能的，所以比赛时一眼就想到二分

先将 n 个数组看成是 n * m 的矩阵，那么矩阵的第i行就代表第i个数组

可以先二分一个最小值 mid ，然后遍历矩阵，将小于mid的元素标记为0，大于等于mid的标记为1，于是就可以得到一个01矩阵，并且我们把每行都看成一个二进制数

那么这时候如果有任意两行对应的二进制数进行或运算得到 (1 << m) - 1 , 即两行 | 完之后若得到全1的一行(结合之后每个数都 >= mid)，那么说明这个mid是可行的,更新ans1,ans2

然而这步如果我们暴力一对一的做法来查找这两行则复杂度为O( n^2)肯定是不行的,但是题目给的 m 最大值只有8，也就是说01矩阵的每一行转二进制后对应的值肯定是小于256

所以我们只要在对这256个数进行暴力一对一同时判断是否有两行能与之对应即可

比赛时候用了部分以前写状压dp的优化，虽然运行起来会快一点点，但是其实关了同步流就没什么卵用，反而还丑的不像话（貌似不关同步流会TLE）

赛后给 Vv 讲了做法，发现她居然用同样的思路写出比我好看的代码？excuse me？？

于是我赶紧写了一个比她好看的（虽然还是有点丑）

#include<bits/stdc++.h>
using namespace std;
#define rep(i , a , b) for(int i = a ; i <= b ; i ++)
#define ll long long
const int N = 3e5 + 10;
int a[N][10] , b[N][10];
int n , m ;
int id[1010];
int tot;
int ans1 , ans2;
bool check(int mid)
{
     memset(id , 0 , sizeof(id));
    rep(i , 1 , n)
    {
        rep(j , 1 , m)
        if(a[i][j] >= mid)
        b[i][j] = 1;
        else b[i][j] = 0;
    }
    rep(i , 1 , n)
    {
        int temp = 0;
        rep(j , 1 , m)
        temp += b[i][j] << (j - 1);
        id[temp] = i;
    }
    rep(i , 0 , 256)
    {
        rep(j , 0 , 256)
        {
            if((i | j) == tot && id[i] && id[j])
            {ans1 = id[i] , ans2 = id[j] ; return true;}
        }
    }
    return false;
}
int main()
{
    ios::sync_with_stdio(false);
    cin >> n >> m;
    tot = (1 << m) - 1;
    rep(i , 1 , n)
        rep(j , 1 , m)
            cin >> a[i][j];
    int l = 0  , r = 1000000010 , mid;
    while(l <= r)
    {
        mid = l + r >> 1;
        if(check(mid))    l = mid + 1;
        else             r = mid - 1;
    }
    cout << ans1 << " " << ans2 << '\n';
    return 0;
}
 

E. Messenger Simulator

题目链接：https://codeforces.com/contest/1288/problem/E

题意：

给你一个长度为n的序列，初始化为1,2,3...n，现在进行m次操作，每次操作有一个数 x，你需要将 x 提至数组的首位，问1~m次操作中每个数在序列中的最左端和最右端分别是多少

分析：

对于第 i 个数，如果它被操作过，则它的最左端为1，否则为 i （它前面的数被操作不影响它当前位置，后面的数被操作只会使它位置增大）

如果没被操作过，则最右端为操作结束之后的位置（同上），但是若它被操作过，则它的位置会减小（若为1则不变），而之后别的数被操作，它的位置又会增大

所以若它被操作过，它的位置即可能增加，也可能减少。而当它刚被操作结束，别的数被操作时，它的位置必定增加，一直到所有操作都结束或者它又一次被操作。

所以它的最右端需要在每次被操作时更新。

我们可以先在序列前空下m个空位，并初始化第i个数在操作前的坐标pos[i]为 i + m ， 并将该坐标标记为1，代表这坐标上存在着一个数。若某坐标上不存在数则标记为0

当第 j 次操作时，我们在更新被操作数X的最右端的同时将被操作数X坐标改为m + 1 - j，并把原来的坐标标记去掉，并在新坐标m + 1 - j做标记。

而对于某个数 i ，它当前的相对位置为1 ~ pos[i]有标记的坐标的个数，即1 ~ pos[i]的区间和，所以我们可以想到用树状数组来维护这些操作

当所有操作结束之后我们再去更新每个数的最大值即可

（通宵写博客，脑子有点不好使，感觉自己没有表述清楚，不过代码还是很好理解的）

ps：比赛的时候其实还留有半小时的时间可以去思考E，但是因为D写得太丑太乱搞得自己有点自闭 + 为人太懒了于是就放弃了，现在想来有点可惜，喜欢以后不会再这样了！

#include<bits/stdc++.h>
using namespace std;
#define rep(i , a , b) for(int i = a ; i <= b ; i ++)
#define ll long long
const int N = 3e5 + 10;
int pos[N << 1];
struct node{
    int mi , ma;
}ha[N << 1];
int tree[N << 4] , a[N];
int n , m ;
int lowbit(int x)
{
    return x & (-x);
}
void update(int pos , int x)
{
    while(pos <= N * 2)
    {
        tree[pos] += x;
        pos += lowbit(pos);
    }
}
int query(int x)
{
    int res = 0;
    while(x)
    {
        res += tree[x];
        x -= lowbit(x);
    }
    return res;
}
int main()
{
    cin >> n >> m;
    rep(i , 1 , n)
    ha[i].mi = ha[i].ma = i , pos[i] = N + i , update(N + i , 1);
    rep(i , 1 , m)
    cin >> a[i];
    rep(i , 1 , m)
    {
        ha[a[i]].mi = 1;
        ha[a[i]].ma = max(ha[a[i]].ma , query(pos[a[i]]));
        update(pos[a[i]] , -1);
        update(N + 1 - i , 1);
        pos[a[i]] = N + 1 - i;
    }
 
    rep(i , 1 , n)
        ha[i].ma = max(ha[i].ma , query(pos[i]));
    rep(i , 1 , n)
        cout << ha[i].mi << " " << ha[i].ma << '\n';
    return 0;
}