Codeforces Round 992 (Div. 2)（A-E）

比赛链接

A. Game of Division

You are given an array of integers $a_1,a_2,\dots ,a_n$ of length $n$ and an integer $k$.

Two players are playing a game. The first player chooses an index $1\le i\le n$. Then the second player chooses a different index $1\le j\le n,i\ne j$. The first player wins if $|a_i-a_j|$ is not divisible by $k$. Otherwise, the second player wins.

We play as the first player. Determine whether it is possible to win, and if so, which index $i$ should be chosen.

The absolute value of a number $x$ is denoted by $|x|$ and is equal to $x$ if $x\ge 0$, and $-x$ otherwise.

Input

Each test contains multiple test cases. The first line of input contains a single integer $t$ ($1\le t\le 100$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $k$ ($1\le n\le 100$; $1\le k\le 100$) — the length of the array and the number $k$.

The second line of each test case contains $n$ integers $a_1,a_2,\dots ,a_n$ ($1\le a_i\le 100$) — the elements of the array $a$.

Output

For each test case, if it is impossible for the first player to win, print “NO” (without quotes).

Otherwise, print “YES” (without quotes) and on the next line the appropriate index $1\le i\le n$. If there are multiple solutions, print any of them.

You can output each letter in any case (lowercase or uppercase). For example, the strings “yEs”, “yes”, “Yes” and “YES” will be recognized as a positive answer.

核心代码

int n,k;
int w[N];

void solve(){
    cin>>n>>k;

    for(int i=1;i<=n;i++)cin>>w[i];

    int ans=0;

    for(int i=1;i<=n;i++){
        bool f=false;
        for(int j=1;j<=n;j++){
            if(i!=j){
                if(abs(w[i]-w[j])%k==0){
                    f=true;
                }
            }
        }
        if(!f){
            cout<<"YES"<<endl;
            cout<<i<<endl;
            return;
        }
    }
    cout<<"NO"<<endl;
}

B. Paint a Strip

You have an array of zeros $a_1,a_2,\dots ,a_n$ of length $n$.

You can perform two types of operations on it:

1. Choose an index $i$ such that $1\le i\le n$ and $a_i=0$, and assign $1$ to $a_i$;
2. Choose a pair of indices $l$ and $r$ such that $1\le l\le r\le n$, $a_l=1$, $a_r=1$, $a_l+\dots +a_r\ge \lceil \frac{r-l+1}{2}\rceil$, and assign $1$ to $a_i$ for all $l\le i\le r$.

What is the minimum number of operations of the first type needed to make all elements of the array equal to one?

Input

Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1\le t\le 10^4$). The description of the test cases follows.

The only line of each test case contains one integer $n$ ($1\le n\le 10^5$) — the length of the array.

Note that there is no limit on the sum of $n$ over all test cases.

Output

For each test case, print one integer — the minimum number of needed operations of first type.

核心代码

int n;

void solve(){
    cin>>n;

    int m=0;

    if(n==1){
        cout<<"1"<<endl;
        return;
    }

    int ans=1;

    for(int i=1;i<n;i=(i+1)<<1){
        ans++;
    }

    cout<<ans<<endl;

}

C. Ordered Permutations

Consider a permutation${}^{\text{∗}}$ $p_1,p_2,\dots ,p_n$ of integers from $1$ to $n$. We can introduce the following sum for it${}^{\text{†}}$:

$$S(p)=\sum _{1\le l\le r\le n}\min (p_l,p_{l+1},\dots ,p_r)$$

Let us consider all permutations of length $n$ with the maximum possible value of $S(p)$. Output the $k$-th of them in lexicographical${}^{\text{‡}}$order, or report that there are less than $k$ of them.

${}^{\text{∗}}$A permutation of length $n$ is an array consisting of $n$ distinct integers from $1$ to $n$ in arbitrary order. For example, $[2,3,1,5,4]$ is a permutation, but $[1,2,2]$ is not a permutation ($2$ appears twice in the array), and $[1,3,4]$ is also not a permutation ($n=3$ but there is $4$ in the array).

${}^{\text{†}}$For example:

• For the permutation $[1,2,3]$ the value of $S(p)$ is equal to $\min (1)+\min (1,2)+\min (1,2,3)+\min (2)+\min (2,3)+\min (3)=$ $1+1+1+2+2+3=10$
• For the permutation $[2,4,1,3]$ the value of $S(p)$ is equal to $\min (2)+\min (2,4)+\min (2,4,1)+\min (2,4,1,3)+$ $ \min(4) + \min(4, 1) + \min(4, 1, 3) \ +$ $\min (1)+\min (1,3)+$ $\min (3)=$ $2+2+1+1+4+1+1+1+1+3=17$.

${}^{\text{‡}}$An array $a$ is lexicographically smaller than an array $b$ if and only if one of the following holds:

• $a$ is a prefix of $b$, but $a\ne b$; or
• in the first position where $a$ and $b$ differ, the array $a$ has a smaller element than the corresponding element in $b$.
• Input

Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1\le t\le 10^4$). The description of the test cases follows.

The only line of each test case contains two integers $n$ and $k$ ($1\le n\le 2\cdot 10^5$; $1\le k\le 10^{12}$) — the length of the permutation and the index number of the desired permutation.

It is guaranteed that the sum of $n$ over all test cases does not exceed $2\cdot 10^5$.
Output

For each test case, if there are less than $k$ suitable permutations, print $-1$.

Otherwise, print the $k$-th suitable permutation.

核心代码

int n,k,m;

void solve(){
    cin>>n>>k;

    vector<bool>w(n+1,0);

    if(n<=60&&(1ll<<(n-1))<k) {
        cout<<-1<<endl;
        return;
    }
    k--;
    for(int i=n-1;i>=1;i--){
        if(k&1)w[i]=true;
        k/=2;
    }

    vector<int>ans(n+1,0);

    for(int i=1,l=0,r=n+1;i<=n;i++){
        if(w[i])ans[--r]=i;
        else ans[++l]=i;
    }

    for(int i=1;i<=n;i++)cout<<ans[i]<<" \n"[i==n];
}

D. Non Prime Tree

You are given a tree with $n$ vertices.

You need to construct an array $a_1,a_2,\dots ,a_n$ of length $n$, consisting of unique integers from $1$ to $2\cdot n$, and such that for each edge $u_i\leftrightarrow v_i$ of the tree, the value $|a_{u_i}-a_{v_i}|$ is not a prime number.

Find any array that satisfies these conditions, or report that there is no such array.

Input

Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1\le t\le 10^4$). The description of the test cases follows.

The first line of each test case contains a single integer $n$ ($2\le n\le 2\cdot 10^5$) — the number of vertices in the tree.

The next $n-1$ lines contain the edges of the tree, one edge per line. The $i$-th line contains two integers $u_i$ and $v_i$ ($1\le u_i,v_i\le n$; $u_i\ne v_i$), denoting the edge between the nodes $u_i$ and $v_i$.

It’s guaranteed that the given edges form a tree.

It is guaranteed that the sum of $n$ over all test cases does not exceed $2\cdot 10^5$.

Output

For each test case, if an array that satisfies the conditions exists, print its elements $a_1,a_2,\dots ,a_n$. Otherwise, print $-1$.

核心代码（解法1）

int n;
struct E{
    int x,y;
    bool operator<(const E& t)const{
        return x<t.x;
    }
};

void solve(){
    cin>>n;

    vector<vector<int>>G(n+n+1),C(n*2+1);

    for(int i=1;i<n;i++){
        int a,b;
        cin>>a>>b;
        G[a].emplace_back(b);
        G[b].emplace_back(a);
    }

    vector<int>siz(n+n+1,0),ans(n+n+1,0);
    int root=1,maxv=n+1;

    function<void(int,int)>dfs1=[&](int u,int fa){
        siz[u]=1;
        int mx=0;
        for(auto& j:G[u]){
            if(j==fa)continue;
            dfs1(j,u);
            siz[u]+=siz[j];
            mx=max(mx,siz[j]);
        }
        mx=max(mx,n-siz[u]);
        if(mx<maxv)maxv=mx,root=u;
    };

    function<void(int,int)>dfs2=[&](int u,int fa){
        siz[u]=1;
        for(auto& j:G[u]){
            if(j==fa)continue;
            dfs1(j,u);
            siz[u]+=siz[j];
        }
    };

    dfs1(1,0);
    dfs2(root,0);
    priority_queue<E>q;

    int t1=0,t=6,p=0;

    for(auto& j:G[root]){
        if(siz[j]==1&&!t1)t1=1,ans[j]=1;
        else q.push({siz[j],j});
    }

    while(q.size()){
        int u=q.top().y;
        q.pop();

        siz[u]--;
        C[u].push_back(t);
        t=t+2;

        if(siz[p])q.push({siz[p],p});
        p=u;
    }

    int a,b;

    function<void(int,int)>dfs3=[&](int u,int fa){
        ans[u]=C[a][b++];
        int t1=0;
        for(auto& j:G[u]){
            if(j==fa)continue;
            if(siz[j]==1&&!t1)t1=1,ans[j]=ans[u]-1;
            else dfs3(j,u);
        }
    };

    for(auto& j:G[root]){
        if(C[j].size()){
            a=j,b=0;
            dfs3(j,root);
        }
    }

    ans[root]=2;
    for(int i=1;i<=n;i++)cout<<ans[i]<<" \n"[i==n];

}

核心代码（解法二）

int n;

void solve(){
    cin>>n;

    vector<vector<int>>G(n+1);

    for(int i=1;i<n;i++){
        int a,b;
        cin>>a>>b;
        G[a].emplace_back(b);
        G[b].emplace_back(a);
    }

    vector<int>ans(n+1,0);

    int t=1;

    function<void(int,int)>dfs=[&](int u,int fa){
        ans[u]=t;
        bool f=true;
        for(auto& j:G[u]){
            if(j==fa)continue;
            if(f){
                t++;
                f=false;
                dfs(j,u);
                t++;
            }else{
                t+=2;
                dfs(j,u);
            }
        }
    };

    dfs(1,0);

    for(int i=1;i<=n;i++){
        cout<<ans[i]<<" \n"[i==n];
    }

}

核心代码（解法三）

这道题好像还有线性筛+二分的方法，建议看：value0的提交记录。

E. Control of Randomness

You are given a tree with $n$ vertices.

Let’s place a robot in some vertex $v\ne 1$, and suppose we initially have $p$ coins. Consider the following process, where in the $i$-th step (starting from $i=1$):

• If $i$ is odd, the robot moves to an adjacent vertex in the direction of vertex $1$;
• Else, $i$ is even. You can either pay one coin (if there are some left) and then the robot moves to an adjacent vertex in the direction of vertex $1$, or not pay, and then the robot moves to an adjacent vertex chosen uniformly at random.

The process stops as soon as the robot reaches vertex $1$. Let $f(v,p)$ be the minimum possible expected number of steps in the process above if we spend our coins optimally.

Answer $q$ queries, in the $i$-th of which you have to find the value of $f(v_i,p_i)$, modulo${}^{\text{∗}}$ $998244353$.

${}^{\text{∗}}$ Formally, let $M=998244353$. It can be shown that the answer can be expressed as an irreducible fraction $\frac{p}{q}$, where $p$ and $q$ are integers and $q\not\equiv 0(\mathrm{mod}M)$. Output the integer equal to $p\cdot q^{-1}\mathrm{mod}M$. In other words, output such an integer $x$ that KaTeX parse error: Expected 'EOF', got '&' at position 9: 0 \le x &̲lt; M and $x\cdot q\equiv p(\mathrm{mod}M)$.

Input

Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1\le t\le 10^3$). The description of the test cases follows.

The first line of each test case contains two integers $n$ and $q$ ($2\le n\le 2\cdot 10^3$; $1\le q\le 2\cdot 10^3$) — the number of vertices in the tree and the number of queries.

The next $n-1$ lines contain the edges of the tree, one edge per line. The $i$-th line contains two integers $u_i$ and $v_i$ ($1\le u_i,v_i\le n$; $u_i\ne v_i$), denoting the edge between the nodes $u_i$ and $v_i$.

The next $q$ lines contain two integers $v_i$ and $p_i$ ($2\le v_i\le n$; $0\le p_i\le n$).

It’s guaranteed that the given edges form a tree.

It is guaranteed that the sum of $n$ over all test cases does not exceed $2\cdot 10^3$.

It is guaranteed that the sum of $q$ over all test cases does not exceed $2\cdot 10^3$.
Output

For each test case, print $q$ integers: the values of $f(v_i,p_i)$ modulo $998244353$.

Formally, let $M=998244353$. It can be shown that the answer can be expressed as an irreducible fraction $\frac{p}{q}$, where $p$ and $q$ are integers and $q\not\equiv 0(\mathrm{mod}M)$. Output the integer equal to $p\cdot q^{-1}\mathrm{mod}M$. In other words, output such an integer $x$ that KaTeX parse error: Expected 'EOF', got '&' at position 9: 0 \le x &̲lt; M and $x\cdot q\equiv p(\mathrm{mod}M)$.

核心代码

int n,m,q;
int f[N][N];

void solve(){
    cin>>n>>q;

    for(int i=0;i<=n;i++)f[0][i]=-1e18;

    vector<vector<int>>G(n+n+1);

    for(int i=1;i<n;i++){
        int a,b;
        cin>>a>>b;
        G[a].emplace_back(b);
        G[b].emplace_back(a);
    }

    vector<int>fa(n+1,0);

    auto dfs=[&](auto& dfs,int u,int fp)->void{
        fa[u]=fp;
        if(u!=1){
            for(int p=0;p<=n;p++){
                f[u][p]=f[fa[fa[u]]][p]+(int)G[u].size()*2;
                if(p>0){
                    f[u][p]=min(f[u][p],f[fa[fa[u]]][p-1]+2);
                }
            }
        }
        for(auto& j:G[u]){
            if(j==fp)continue;
            dfs(dfs,j,u);
        }
    };

    dfs(dfs,1,0);

    while(q--){
        int a,b;
        cin>>a>>b;
        cout<<f[fa[a]][b]+1<<endl;
    }
}

后记

思路暂时就先不放了，发这篇文章只是想记录一下这场比赛，只写了前面A~C，D、E调了很久 掉大分，直到赛后才调好，太菜了。