Codeforces Round #607 (Div. 2)

场次链接

A. Suffix Three
题目链接
给你t个字符串，让你根据后缀输出是哪国语言。
数据范围：$1\le t\le 30$,$1\le 字符串长度\le 1000$
解：因为最后一个字符都不相同，所以判断最后一个字符即可。
复杂度：$O(t)$

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void work()
{
    char a[100005];
    scanf("%s",a);
    int l=strlen(a);
        if(a[l-1]=='o'){
            printf("FILIPINO\n");
            return;
        }
        if(a[l-1]=='u'){
            printf("JAPANESE\n");
            return;
        }
        if(a[l-1]=='a'){
            printf("KOREAN\n");
            return;
        }
}
int main()
{
    //ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int T;
    scanf("%d",&T);
    //T=1;
    while(T--){
        work();
    }
}

B. Azamon Web Services
题目链接
t个询问，每个询问给2个字符串s、c，你可以交换s字符串中的2个字符，问能否使得s字符串字典序严格小于c字符串，如果可以，输出交换后的字符串，否则输出"$---$"
数据范围：$1\le t\le 1500$,$2\le |s|\le 5000$，$1\le |c|\le 5000$,
$2\le sum(|s|)\le 5000$，$1\le sum(|c|)\le 5000$。
解：从前往后将s字符串的每一位和后面所有位相比，取最小的最后的字符进行交换，再判断2个字符串大小。
复杂度：$O(|s{|}^2)$

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void work()
{
    string a;
    string b;
    cin>>a>>b;
    int l=a.length();
    int i=0;
    while(i<l){
        int minn=i;
        for(int j=l-1;j>i;j--){
            if(a[j]<a[minn]){
                minn=j;
            }
        }
        if(minn!=i){
            swap(a[minn],a[i]);
            break;
        }
        i++;
    }
    if(a<b){
        cout<<a<<endl;
    }else{
        cout<<"---"<<endl;
    }
}
int main()
{
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int T;
    //scanf("%d",&T);
    cin>>T;
    //T=1;
    while(T--){
        work();
    }
}

C. Cut and Paste
题目链接
t组数据，每组数据输入一个x和字符串s（字符只有1,2,3），然后进行x次操作
一开始ℓ=0
每次操作：
1、ℓ++;
2、将s[ℓ]及之后的字符剪切。
3、将剪切的量粘贴s[ℓ-1]次。
4、如果ℓ不为字符串尾，则进行下一次操作，否则退出。
问最后的字符串长度。
数据范围：$1\le t\le 1000$,$1\le x\le 10^6$,$1\le |s|\le 500$
解：模拟即可，注意当字符串长度超过x时就不需要再往里加了。
复杂度：$O(x)$

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
void work()
{
    int x;
    cin>>x;
    string a;
    cin>>a;
    ll l=a.length();
    for(int i=1;i<=x;i++){
        l=(l-1)*(a[i-1]-'0')%mod;
        if(l==0)break;
        if(a.length()<=x){
            string b=a.substr(i);
            //cout<
            for(int j=2;j<=a[i-1]-'0';j++){
                a+=b;
                if(a.length()>x)break;
            }
        }
    }
    printf("%lld\n",(l+x)%mod);
}
int main()
{
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int T;
    cin>>T;
    //T=1;
    while(T--){
        work();
    }
}

D. Beingawesomeism
题目链接
t组数据，每组给一个$r\ast c$的矩形，由字符串‘A’和‘P’组成。你可以进行2种操作，选择水平$1\ast x$的网格，将其向上或向下覆盖任意行。或者选择垂直$x\ast 1$的网格，将其向左或向右覆盖任意列。问将所有网格都变成‘A’需要几步。如果无法完成则输出“MORTAL”。
数据范围：$1\le t\le 2\ast 10^4$,$1\le r\le 60$,$1\le c\le 60$
解：如果全是‘A’那么输出0，如果全是P那么输出MORTAL。
如果第一列或者最后一列或者第一行或者最后一行都是A，那么可以通过一次操作将其他全部变成A，输出1。
如果除上述行列以外有任意行列全是A，那么可以通过一次操作变成上一个情况，故输出2。同样的，如果四个角有任意一个是A，也可以通过一次操作变成上一个情况。故输出2。
如果非四个角的边上有 A，那么可以通过一个操作将其变成四个角有A，即上一个情况，则输出3。
其他，输出4。
复杂度：$O(r\ast c)$

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
char a[65][65];
int px[65];
int py[65];
int ax[65];
int ay[65];
void work()
{
    memset(px,0,sizeof(px));
    memset(py,0,sizeof(py));
    memset(ax,0,sizeof(ax));
    memset(ay,0,sizeof(ay));
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%s",a[i]+1);
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(a[i][j]=='A'){
                ax[i]++;
                ay[j]++;
            }else{
                px[i]++;
                px[i]++;
            }
        }
    }
    for(int i=1;i<=n;i++){
        if(px[i]>0){
            break;
        }
        if(i==n){
            printf("0\n");
            return;
        }
    }
    for(int i=1;i<=n;i++){
        if(ax[i]>0){
            break;
        }
        if(i==n){
            printf("MORTAL\n");
            return;
        }
    }
    if(ax[1]==m||ax[n]==m||ay[1]==n||ay[m]==n){
        printf("1\n");return;
    }
    for(int i=2;i<n;i++){
        if(ax[i]==m){
            printf("2\n");return;
        }
    }
    for(int i=2;i<m;i++){
        if(ay[i]==n){
            printf("2\n");return;
        }
    }
    if(a[1][1]=='A'||a[1][m]=='A'||a[n][1]=='A'||a[n][m]=='A'){
        printf("2\n");return;
    }
    if(ax[1]>0||ax[n]>0||ay[1]>0||ay[m]>0){
        printf("3\n");return;
    }
    printf("4\n");
}
int main()
{
    //ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int T;
    //cin>>T;
    scanf("%d",&T);
    //T=1;
    while(T--){
        work();
    }
}

E. Jeremy Bearimy
题目链接
t组数据，给出k对人，你需要将他们放到有2k个节点的树上，给出了2k-1条边和边权，问每对人之间的距离和的最大值和最小值
输入 t组数据，k对人，a、b为边的两点，t为边权
数据范围 $1\le t\le 500$,$1\le k\le 10^5$,$1\le a_i,b_i,\le 2k$,$1\le t_i\le 10^6$
解：求最大值，对于每一条边要使更多对的人经过该边，最大为$min(2\ast k-子树的size,子树的size)$，dfs求子树的size然后乘边权加入答案即可。
求最小值，如果一个节点连了偶数个未被算的节点（不算上父节点），那么显然这偶数个节点互相连接最小。如果一个节点连了奇数个还未被算的节点（不算父节点），那么显然这个节点和他连着的节点相连更小。dfs即可
复杂度 $O(2\ast k)$

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct node
{
    int to;
    ll v;
};
vector<node>v[200005];
int vis[200005];
ll ans1=0;
ll ans2=0;
int k;
int dfs1(int past,int x)
{
    vis[x]=1;
    int sum=1;
    for(int i=0;i<v[x].size();i++){
        if(v[x][i].to!=past&&!vis[v[x][i].to]){
            int t=dfs1(x,v[x][i].to);
            sum+=t;
            ans1+=v[x][i].v*min(k-t,t);
        }
    }
    return sum;
}
void dfs2(int past,int x)
{
    int cnt=0;
    for(int i=0;i<v[x].size();i++){
        if(v[x][i].to!=past){
            dfs2(x,v[x][i].to);
        }
    }
    for(int i=0;i<v[x].size();i++){
        if(v[x][i].to!=past&&!vis[v[x][i].to]){
            ans2+=v[x][i].v,cnt++;
        }
    }
    if(cnt%2==1){
        vis[x]=1;
    }
}
void work()
{
    scanf("%d",&k);
    k=k*2;
    for(int i=1;i<=k;i++){
        v[i].clear();
    }
    for(int i=1;i<k;i++){
        int x,y;
        ll z;
        scanf("%d%d%lld",&x,&y,&z);
        node tmp;
        tmp.to=x;
        tmp.v=z;
        v[y].push_back(tmp);
        tmp.to=y;
        v[x].push_back(tmp);
    }
    ans1=0;
    ans2=0;
    memset(vis,0,sizeof(vis));
    dfs1(0,1);
    memset(vis,0,sizeof(vis));
    dfs2(0,1);
    printf("%lld %lld\n",ans2,ans1);
}
int main()
{
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int T;
    scanf("%d",&T);
    //cin>>T;
    //T=1;
    while(T--){
        work();
    }
}

F. Miss Punyverse
题目链接
T组数据，每组数据给$n$个地方，每个地方有$b_i$个人支持蜜蜂，$w_i$个人支持黄蜂，接着给出$n-1$条边，保证这是一个树形结构，你要把这些地方分为$m$个区域，如果区域的$sum(b)\le sum(w)$，则黄蜂会获胜，问最多能有多少个区域黄蜂获胜。
输入 $t$,对于每一个$t$,给出$n$,$m$,然后$n$个$b_i$,然后$n$个$w_i$，然后$n-1$条边
数据范围 $1\le t\le 100$,$1\le m\le n\le 3000$,$0\le b_i\le 10^9$,$0\le w_i\le 10^9$,$1\le x,y\le n$
解：很明显的一道树形dp题，$dp[x][y]$，$x$代表当前节点，$y$代表把这个子树分为$y$组，$dp$中存$2$个数据，一个是最多获胜多少次，一个是在当前获胜情况下，剩余的黄蜂最多能比蜜蜂多多少。
转移方程 $dp[x][y]=max(dp[x][y],dp[x的一部分子树][i]+dp[x的另一部分子树][j])$，$i+j=y$
复杂度 $O(n^2)$

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct node
{
    ll sum;
    ll asum;
};
int a[3005];
vector<int>v[3005];
node dp[3005][3005];
node tmp[3005];
int dfs(int past,int now)
{
    int sz=1;
    dp[now][0].sum=0;
    dp[now][0].asum=a[now];
    for(auto u:v[now]){
        if(u==past)continue;
        int l=dfs(now,u);
        for(int i=0;i<l+sz;i++){
            tmp[i].sum=-1;
            tmp[i].asum=-1;
        }
        for(int i=0;i<=l;i++){
            for(int j=0;j<sz;j++){
                if(tmp[i+j].sum<dp[u][i].sum+dp[now][j].sum){
                    tmp[i+j].sum=dp[u][i].sum+dp[now][j].sum;
                    tmp[i+j].asum=dp[u][i].asum+dp[now][j].asum;
                }else if(tmp[i+j].sum==dp[u][i].sum+dp[now][j].sum&&tmp[i+j].asum<dp[u][i].asum+dp[now][j].asum){
                    tmp[i+j].sum=dp[u][i].sum+dp[now][j].sum;
                    tmp[i+j].asum=dp[u][i].asum+dp[now][j].asum;
                }
            }
        }
        for(int i=0;i<l+sz;i++){
            dp[now][i]=tmp[i];
        }
        sz+=l;
    }
    for(int i=sz-1;i>=0;i--){
        node x=dp[now][i];
        if(x.asum>0){
            x.sum++;
        }
        x.asum=0;
        if(dp[now][i+1].sum<x.sum||dp[now][i+1].sum==x.sum&&dp[now][i+1].asum<x.asum){
            dp[now][i+1]=x;
        }
    }
    return sz;
}
void work()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        v[i].clear();
    }
    for(int i=1;i<=n;i++){
        int k;
        scanf("%d",&k);
        a[i]=k-a[i];
    }
    for(int i=1;i<n;i++){
        int x,y;
        scanf("%d%d",&x,&y);
        v[x].push_back(y);
        v[y].push_back(x);
    }
    for(int i=1;i<=n;i++){
        for(int j=0;j<=n;j++){
            dp[i][j].sum=-1;
            dp[i][j].asum=-1;
        }
    }
    dfs(0,1);
    printf("%lld\n",dp[1][m-1].sum+(dp[1][m-1].asum>0));(dp[1][m]的asum小于0时是不成立的，所以最后不直接输出dp[1][m])
}
int main()
{
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int T;
    scanf("%d",&T);
    //cin>>T;
    //T=1;
    while(T--){
        work();
    }
}