#Codeforces Round #384 (Div. 2) 题解(743A,743B,743C,743D,743E)

Codeforces Round #384 (Div. 2) 题解(743A,743B,743C,743D,743E)

A. Vladik and flights

题意：有n个飞机场按顺序排列，飞机场有两种类型，要么是0，要么是1，从一个飞机场飞到另一个相同类型的飞机场花费0，飞到不同类型的飞机场花费为两个飞机场间的距离。问从a飞到b的最少花费，中间可以降落。
题解：如果a，b所在的飞机场类型相同答案为0，不同则为1。

B. Chloe and the sequence

题意：给定一个初始序列1和数字n，进行n-1次操作，每次操作都会产生一个新序列，设为st[i]，第i次操作产生的字符串为st[i-1]+(i+1)+st[i-1]，当n=1是最终产生的序列为[1, 2, 1]，当n=2时，序列为[1, 2, 1, 3, 1, 2, 1]。
代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n,k;
int main()
{
    scanf("%I64d%I64d",&n,&k);
    int ans=-1;
    while(n)
    {
        if(k==(1LL<<n))
        {
            ans=n+1;break;
        }
        else if(k>(1LL<<n))
            k-=(1LL<<n);
        --n;
    }
    if(ans==-1) ans=1;
    printf("%d\n",ans);
    return 0;
}

C. Vladik and fractions

题意：给定n，要你找到x，y，z，使$\frac{1}{n}=\frac{1}{x}+\frac{1}{y}+\frac{1}{z}$，其中$x\neq y\neq z$。
题解：x=n，y=n+1，z=n*(n+1)，当y=z时输出-1。

D. Chloe and pleasant prizes

题意：给定一棵有n个点的有根树，每个点都有一个权值，要你找到两棵不相交的子树，使这两棵子树的权值和最大。
题解：treedp，dp[i]表示以i为根的子树的权值和，答案为某棵子树中的两个不相交子树的权值和。
代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 200010
typedef long long ll;
const ll inf=1e18;
ll dp[N],v[N],sum[N];
int head[N],to[N*2],pre[N*2];
int n,e;
ll ans;
void addedge(int x,int y)
{
    to[e]=y;pre[e]=head[x];head[x]=e++;
}
void dfs(int x,int pa)
{
    sum[x]=v[x];
    for(int i=head[x];i!=-1;i=pre[i])
    {
        if(to[i]==pa) continue;
        dfs(to[i],x);
        if(dp[x]!=-inf) ans=max(ans,dp[x]+dp[to[i]]);
        sum[x]+=sum[to[i]];
        dp[x]=max(dp[x],dp[to[i]]);
    }
    dp[x]=max(dp[x],sum[x]);
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;++i)
        scanf("%I64d",&v[i]);
    memset(head,-1,sizeof(head));
    e=0;
    int x,y;
    for(int i=1;i<n;++i)
    {
        scanf("%d%d",&x,&y);
        addedge(x,y);addedge(y,x);
    }
    ans=-inf;
    for(int i=1;i<=n;++i) dp[i]=-inf;
    memset(sum,0,sizeof(sum));
    dfs(1,0);
    if(ans==-inf) printf("Impossible");
    else printf("%I64d\n",ans);
    return 0;
}

E. Vladik and cards

题意：给定一个长度为n的序列，序列只有1-8这八个数字组成，要你找到一个最长的子序列，满足在找到的子序列中每个数字的数目相差不超过1，并且相同的数字在子序列中要求连续。
题解：设子序列中每个数字的数量至少为len，其中长度为len+1的为k个，则子序列长度为$k*(len+1)+(8-k)*len$，通过二分枚举len，然后用状压dp判断是否可行并得到最大的k，设数组$dp[n][2^8-1]$，在dp[i][s]中，s的二进制串中，1表示那个数字已经出现了至少len次，0表示没有，dp[i][s]表示在前i位中，s的二进制串为1那位的那个数字已经出现了至少len次。
代码：

#include <bits/stdc++.h>
using namespace std;
#define N 1010
vector<int> g[10];
int a[N],p[10],cur[10],dp[N][1<<8];
int n;
int check(int len)
{
    memset(cur,0,sizeof(cur));
    memset(dp,-1,sizeof(dp));
    dp[0][0]=0;
    for(int i=0;i<n;++i)
    {
        for(int j=0;j<(1<<8);++j)
        {
            if(dp[i][j]==-1) continue;
            for(int k=1;k<=8;++k)
            {
                if(j&(1<<(k-1))) continue;
                int x=cur[k]+len-1;
                if(x>=g[k].size()) continue;
                dp[g[k][x]][j|(1<<(k-1))]=max(dp[g[k][x]][j|(1<<(k-1))],dp[i][j]);
                ++x;
                if(x>=g[k].size()) continue;
                dp[g[k][x]][j|(1<<(k-1))]=max(dp[g[k][x]][j|(1<<(k-1))],dp[i][j]+1);
            }
        }
        ++cur[a[i]];
    }
    int ans=-1;
    for(int i=1;i<=n;++i)
    {
        //printf("%d ??\n",dp[i][(1<<8)-1]);
        ans=max(ans,dp[i][(1<<8)-1]);
    }
    if(ans==-1) return -1;
    return ans*(len+1)+(8-ans)*len;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;++i)
    {
        scanf("%d",&a[i]);
        g[a[i]].push_back(i);
    }
    int s=1,t=n/8,mid;
    while(s+1<t)
    {
        mid=s+t>>1;
        if(check(mid)!=-1) s=mid;
        else t=mid-1;
    }
    int ans=max(check(s),check(t));
    if(ans==-1)
    {
        ans=0;
        for(int i=1;i<=8;++i)
            if(g[i].size()) ++ans;
    }
    printf("%d\n",ans);
    return 0;
}