atcoder grand contest 024

最新推荐文章于 2019-08-20 18:49:00 发布

tata_d2

最新推荐文章于 2019-08-20 18:49:00 发布

阅读量180

点赞数

分类专栏： agc atcoder

本文链接：https://blog.csdn.net/tata_d2/article/details/80418916

版权

atcoder 同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

agc

1 篇文章 0 订阅

订阅专栏

A - Fairness

给定 $A, B, C$ ，进行以下操作 $K$ 次：

每个数都同时变为其他两个数的和

求 $K$ 次操作后 $A - B$ 的值，如果答案大于 $10^{18}$ ，输出'unfair'

$A, B, C \leq 10^9， K \leq 10^{18}$

设每次操作后每个数的值等于 $\alpha x + \beta y$ ，其中 $x$ 为最开始时自己的值， $y$ 为最开始时其他两个数的和，我们要求的就是
$\alpha A + \beta B - \alpha B - \beta A$

我们发现对于3个数，每次操作后的 $\alpha$ 和 $\beta$ 都是相等的。

找一找规律，我们发现偶数次操作后， $\alpha - \beta = 1$ ，奇数次操作后， $\beta - \alpha = 1$

所以我们可以 $O(1)$ 求出答案。而且我们发现答案并不会超过 $10^{18}$

code：

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

int a, b, c; long long k;

int main()
{
    scanf( "%d%d%d%lld", &a, &b, &c, &k );

    if( k % 2 == 0 ) 
        printf( "%d\n", a - b );
    else printf( "%d\n", b - a );

    return 0;
}

B - Backfront

给定一个序列 $P$ ，它是 $1$ 至 $N$ 的排列，你要通过做以下操作来将该序列排序成递增的：

选择一个序列中的元素，将它放到序列最前或者最后面

求需要的最少的操作次数

$N \leq 2 \times 10^5$

可以发现，将 $N$ 至 $1$ 依次放到序列最前方或者将 $1$ 至 $N$ 依次放到序列最后方是一定可以将序列排好序的

这个操作不允许我们将一个数放到两个数中间，如果我们存在 $x, x+1, x+2$ ，其中 $x+2$ 在 $x$ 和 $x+1$ 中间，那我们就只能将 $x+2$ 至 $N$ 或 $1$ 至 $x+1$ 暴力重构

所以我们只需要找出序列中最长的连续上升子序列，这部分是不需要重构的，然后将不属于这个子序列的数都暴力重构就可以了

code：

#include <bits/stdc++.h>
using namespace std;
const int N = 300000;

int n, a[N], f[N], ans = 0;

inline void ck_max( int &a, int b ) { if( a < b ) a = b; }

int main()
{
    scanf( "%d", &n );

    for( int i = 1; i <= n; i ++ )
        scanf( "%d", &a[i] );

    memset( f, 0, sizeof( f ) );
    for( int i = 1; i <= n; i ++ )
        f[ a[i] ] = f[ a[i] - 1 ] + 1, ck_max( ans, f[ a[i] ] );

    printf( "%d\n", n - ans );

    return 0;
}

C - Sequence Growing Easy

有一个长度为 $N$ 的序列 $X$ ，其中每个元素都是 $0$
给你一个长度为 $N$ 的序列 $A$ ，你可以对 $X$ 进行任意次以下操作：

选定一个 $i$ ，使 $1 \leq i \leq N-1$ ，令 $X_{i+1} = X_i +1$

输出将 $X$ 变成 $A$ 的最少操作数，如果不能的话，输出 $-1$

$N \leq 2 \times 10^5，0 \leq A_i \leq 10^9$

如果我们要将序列中某一个数变成 $N$ 的话，那我们必定会在某一时刻将序列变成以下这种样子

. . ., 1, 2, 3, . . ., N - 1, N, . . .

$...,1,2,3,...,N-1,N,...$

然而我们是没有办法将一个数减少的，所以如果 $A_i - A_{i-1} \geq 2$ ，那么一定是不可以的（我们设 $A_0 = -1$ ）

对于序列中的一个数 $i$ ，如果 $A_i - A_{i-1} = 1$ ，我们只需要在做好 $A_{i-1}$ 的基础上进行一次操作就可以做好 $A_i$ ，否则我们需要暴力的进行 $A_i$ 次操作

至此我们扫一遍即可解决问题

code：

#include <bits/stdc++.h>
using namespace std;
const int N = 300000;

int n, a[N]; long long ans = 0;

int main()
{
    scanf( "%d", &n );

    for( int i = 1; i <= n; i ++ )
        scanf( "%d", &a[i] );

    if( a[1] != 0 ) {
        printf( "-1\n" ); return 0;
    }

    for( int i = 2; i <= n; i ++ )
    {
        if( a[i] - a[i-1] >= 2 ) {
            printf( "-1\n" ); return 0;
        }

        if( a[i] - a[i-1] == 1 ) 
            ans ++;
        else ans += a[i];
    }

    printf( "%lld\n", ans );

    return 0;
}

D - Isomorphism Freak

对于一颗树 $G$ 的顶点染色方案，如果同种颜色的每个节点作为根时形成的有根树都是同构的，那我们称这种染色方案为 good coloring，将这种染色方案的颜色总数称为这棵树的 colofulness

给定一颗 $N$ 个结点的树，你可以进行任意次以下操作来重构它：

新建一个结点，将它与树上的任意一个结点用一条边连接起来

找出重构后树的最小 colorfulness，在 colorfulness 最小的情况下，找出最小的叶子数量

$N \leq 200$

我们发现增加新点并不能使树的 colorfulness 减少

我们找出树的直径，设其长度为 $D$ ，我们可以发现该树的 colorfulness 为 $\lfloor \frac{D}{2} \rfloor$

所以第一个任务就完成了

每棵树都有一个或两个中心，当 $D$ 为偶数时，中间的两个点就是中心，当 $D$ 为奇数时，中间的一个点可以是中心，那个点与其相邻的任意一个点也可以组成两个点的中心。

我们发现对于一个确定的中心，这棵树的叶子数量是一定的

我们只需要暴力枚举中心，找出最小的叶子数量即可

code：
（这份代码 WA 了一个点…并不知道原因，求大神解答）

#include <bits/stdc++.h>

const int N = 200;
const int INF = 1<<30;

inline int read()
{
    char c = getchar(); int f = 1, x = 0;
    while( c < '0' || c>'9' ) { if(c == '-') f = -1;  c = getchar(); }
    while( c >= '0'&&c<='9' ) { x = x * 10 + c - '0'; c = getchar(); }
    return f * x;
}

int tot = 0, front[N];

struct tEdge {
    int v, next;
} e[N<<1];

inline void add_edge( int u, int v ) {
    e[++tot] = { v, front[u] }; front[u] = tot;
    e[++tot] = { u, front[v] }; front[v] = tot; 
}

int n, m = INF, max_dep[N];

inline int find_max_dep( int u, int fa )
{
    int ret = 0;

    for( int i = front[u]; i; i = e[i].next ) 
    {
        int v = e[i].v;
        if( v == fa ) continue;

        ret = std::max( ret, find_max_dep( v, u ) );
    }

    return ret + 1;
}

int sum[N];

inline int find_leaves( int u, int fa, int dep )
{
    int now_sum = 0;

    for( int i = front[u]; i; i = e[i].next )
    {
        int v = e[i].v;
        if( v == fa ) continue;

        find_leaves( v, u, dep + 1 );
        now_sum ++;
    } 

    sum[dep] = std::max( sum[dep], now_sum );
}

inline int calc_ans( int u, int v )
{
    int ret = 0;
    if( !v )
    {
        for( int i = front[u]; i; i = e[i].next )
            find_leaves( e[i].v, u, 1 ), ret ++;

        for( int i = 1; sum[i]; i ++ )
            ret *= sum[i], sum[i] = 0;

        return ret == 0 ? 1 : ret;
    }

    ret = 2;
    find_leaves( u, v, 1 );
    find_leaves( v, u, 1 );

    for( int i = 1; sum[i]; i ++)
        ret *= sum[i], sum[i] = 0;
    return ret;
}

int main()
{
    memset( max_dep, 0, sizeof( max_dep ) ); 

    n = read();
    for( int i = 1; i < n; i ++ )
        add_edge( read(), read() );

    int x = 0, y = 0;
    for( int i = 1; i <= n; i ++ )
        max_dep[i] = find_max_dep( i, 0 ),
        m = std::min( m, max_dep[i] );

    for( int i = 1; i <= n; i ++ )
        if( max_dep[i] == m ) 
            y = x ? i : 0, x = x ? x : i;

    int ans;
    if( !y )
    {
        ans = calc_ans( x, 0 );
        for( int i = front[x]; i; i = e[i].next )
            ans = std::min( ans, calc_ans( x, e[i].v ) );
    }
    else ans = calc_ans( x, y );

    printf( "%d %d\n", m - ( !!y ), ans );

    return 0;
}

E - Sequence Growing Hard

找出符合以下条件的序列组 $(A_0, A_1,...,A_N)$ 的数量，模 $M$

序列组中每个序列中的每个数都是一个 $1$ 到 $K$ 之间的整数（包括 $1$ 和 $K$ ）
对于每个满足的 i ，是 Ai 的一个子序列
- 对于每个满足 $1\leq i \leq N$ 的 $i$ ， $A_{i}$ 的字典序比 $A_{i-1}$ 大
- 序列 $A_i$ 的长度为 $i$
$1 \leq N,K \leq 300，2 \leq M \leq 10^9$

每个序列 $A_i$ 就相当于在上一个序列 $A_{i-1}$ 的基础上插入了一个数字，由于要求字典序递增，插入的数字必须大于等于原来在该位置上的数字。然而如果相等的话，我们其实就相当于在原来位置的后面一位插入了一个比它大的数字，所以我们只需要考虑插入的数字比原来大的情况。

$4, 3, 2, 1$
$4, 3, 3, 2, 1$
在 $3$ 前面插入的 $3$ 可以视为在 $2$ 前面插入了一个 $3$

我们将这个插入的过程转化成一棵树。树上的每个节点包含两个值， $id$ 和 $label$ ，分别代表了该结点是第几次插入的和结点的值，而一条边就相当于儿子插入在了父亲的左边
例如， $A_0$ 就相当于一个 $(0, 0)$ 的结点， $\{ 1 \}$ 就相当于 $(0, 0)-(1, 1)$

那么我们要求的就是满足条件的树的个数

我们设 $f_{i, j}$ 代表 $i$ 个结点的树，根节点值为 $j$ 的树的数量。我们发现 $id = 1$ 一定是 $id = 0$ 的儿子，那么我们有：

fi,j=∑x=1i−1∑j′>jkfx,j′×fi−x,j×Cx−1i−2

其中 $x$ 代表子树内有多少个结点， $j'$ 是子树根的结点的值， $C_{i-2}^{x-1}$ 枚举了两个块内儿子的次序

=∑x=1i−1fi−x,j×Cx−1i−2×(∑j′>jkfx,j′)

我们求一下前缀和，设

S(i,j)=∑k=1ifi,k

fi,j=∑x=1i−1fi−x×Cx−1i−2×(S(x,k)−S(x,j))

这样我们就可以在 $O(KN^2)$ 内解决问题

code：
```
#include <bits/stdc++.h>

typedef long long ll;

const int N = 500;


int n, k, mod;

inline ll add( ll a, ll b ) { ll ret = a + b; if( ret >= mod ) ret -= mod; return ret; }

ll fac[N], inv_f[N], f[N][N], s[N][N], c[N][N];

inline ll C( ll n, ll m ) { 
    return c[n][m];
}

int main()
{
    memset( f, 0, sizeof( f ) );
    memset( s, 0, sizeof( s ) );

    scanf( "%d%d%d", &n, &k, &mod );

    for( int i = 0; i <= n; i ++ )
    {
        c[i][0] = 1;
        for( int j = 1; j <= i; j ++ )
            c[i][j] = add( c[i-1][j-1], c[i-1][j] );
    }

    for( int i = 0; i <= k; i ++ ) 
        f[1][i] = 1; 
    for( int i = 0; i <= k; i ++ )
        s[1][i] = !i ? f[1][i] : s[1][i-1] + f[1][i];  

    for( int i = 2; i <= n + 1; i ++ )
    // i : 现在的结点个数
        for( int j = 0; j <= k; j ++ )
        {
        // j : 现在根节点的 label 值
            for( int l = 1; l < i; l ++ )
            // l : ID=1 子树含有多少个结点
                f[i][j] = add( f[i][j], C( i-2, l-1 ) * f[i-l][j] % mod * add( s[l][k], mod - s[l][j] ) % mod ),

//          printf( "%lld, %lld, %lld\n", C( i-2, l-1 ), f[i-l][j], add( s[l][k], mod - s[l][j] ) );

            s[i][j] = !j ? f[i][j] : add( s[i][j-1], f[i][j] );
//          printf( "i:%d, j:%d, f:%lld, s:%lld\n", i, j, f[i][j], s[i][j] );
        }

    printf( "%lld\n", f[n+1][0] );

    return 0;
}
```

tata_d2

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
atcoder grand contest 024

A - Fairness给定 A,B,CA,B,CA, B, C，进行以下操作 KKK 次：每个数都同时变为其他两个数的和求 KKK 次操作后 A−BA−BA - B 的值，如果答案大于 1018101810^{18}，输出'unfair' A,B,C≤109，K≤1018A,B,C≤109，K≤1018 A, B, C \leq 10^9， K \leq 10^{18}...
复制链接

扫一扫