VK Cup 2017 - Round 1

和FallDream组队瞎打一通……B两个人写的都挂了233，最后只剩下FallDream写的A和我写的C，最后我yy了个E靠谱做法结果打挂了，结束之后改了改就A了，难受。

AC:AC Rank:180 Rating:2133-8->2125

A.Bear and Friendship Condition

题目大意；问一个无向图是否满足若a到b有边且b到c有边则a到c有边。（n<=150,000）

思路：判定每个连通块是不是团，不是则不满足，复杂度O(n)。

#include<cstdio>
inline int read()
{
    int x;char c;
    while((c=getchar())<''||c>'');
    for(x=c-'';(c=getchar())>=''&&c<='';)x=(x<<)+(x<<)+c-'';
    return x;
}
#define MN 150000
struct edge{int nx,t;}e[MN*+];
int h[MN+],en,r[MN+],u[MN+];
long long sum,cnt;
inline void ins(int x,int y)
{
    e[++en]=(edge){h[x],y};h[x]=en;++r[x];
    e[++en]=(edge){h[y],x};h[y]=en;++r[y];
}
void dfs(int x)
{
    cnt+=u[x]=;sum+=r[x];
    for(int i=h[x];i;i=e[i].nx)if(!u[e[i].t])dfs(e[i].t);
}
int main()
{
    int n,m,x,y,i;
    n=read();m=read();
    while(m--)ins(read(),read());
    for(i=;i<=n;++i)if(!u[i])
    {
        sum=cnt=;dfs(i);
        if(cnt*(cnt-)!=sum)return *puts("NO");
    }
    puts("YES");
}

B.Bear and Different Names

题目大意：给定n,k和n-k+1个NO/YES，第i个NO/YES表示第i~i+k-1个字符串有/没有重复的字符串，要求构造一种合法方案。（k<=n<=50）

思路：倒着构造，先把后k-1个弄成各不相同，倒着每碰到一个NO就把第i个和第i+k-1个弄成相同的，否则弄成不同的。

#include<iostream>
using namespace std;
#define MN 50
int f[MN+],t[MN+];
string build(int x)
{
    string s=x<?"A":"B";
    return s+=x%+'a';
}
int main()
{
    int n,k,i;string s;
    cin>>n>>k;
    for(i=;i<n;++i)f[i]=i;
    for(i=;i<n-k+;++i)cin>>s,t[i]=s=="NO";
    while(i--)if(t[i])f[i]=f[i+k-];
    for(i=;i<n;++i)cout<<build(f[i])<<' ';
}

C.Bear and Tree Jumps

题目大意：给定一棵n个点的树，f(s,t)表示从s走到t，一次最多走k步，最少走几次，求Σf(i,j) (i<j)。（n<=200,000，k<=5）

思路：树形DP，ff[i]表示子树i内，所有节点走到根，共走了几个整的k步，f[i][j]表示子树i内，所有节点走到根，除去走的整的k步，剩下一步走了j的点有几个，每次合并子树信息并统计答案即可，复杂度O(n*k^2)。

#include<cstdio>
#include<iostream>
using namespace std;
char B[<<],*S=B,C;int X;
inline int read()
{
    while((C=*S++)<''||C>'');
    for(X=C-'';(C=*S++)>=''&&C<='';)X=(X<<)+(X<<)+C-'';
    return X;
}
#define MN 200000
struct edge{int nx,t;}e[MN*+];
int k,h[MN+],en,f[MN+][];
long long ans,ff[MN+];
inline void ins(int x,int y)
{
    e[++en]=(edge){h[x],y};h[x]=en;
    e[++en]=(edge){h[y],x};h[y]=en;
}
void dfs(int x,int fa)
{
    int i,j,l;
    f[x][]=;
    for(i=h[x];i;i=e[i].nx)if(e[i].t!=fa)
    {
        dfs(e[i].t,x);
        for(j=;j<k;++j)
        {
            ans+=1LL*f[e[i].t][j]*ff[x]+1LL*f[x][j]*ff[e[i].t];
            for(l=;l<k;++l)ans+=1LL*f[e[i].t][j]*f[x][l]*((j+l)/k+);
        }
        for(j=;j<k;++j)f[x][j]+=f[e[i].t][j-];
        f[x][]+=f[e[i].t][k-];ff[x]+=ff[e[i].t]+f[e[i].t][k-];
    }
}
int main()
{
    fread(B,,<<,stdin);
    int n=read(),i;k=read();
    for(i=;i<n;++i)ins(read(),read());
    dfs(,);
    cout<<ans;
}

D.Bear and Company

题目大意：给定一个字符串，问你至少交换多少次相邻字符，才能使得字符串中不出现相邻的“VK”。（字符串长度<=75）

思路：用0表示V，用1表示K，用2表示其他字符，容易得出最后交换完，0,1,2各自的相对顺序不会改变，我们用f[i][j][k][0/1]表示最终答案的前i+j+k个由前i个0，前j个1，前k个2组成，最后一个是不是V时的最小花费，每次我们往状态里加一个字符，我们统计另外两种字符已加入状态的有多少个在原串中位置大于该字符，即为加入该字符的花费。复杂度O(飞快)。

#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
#define MN 75
#define INF 0x3FFFFFFF
char s[MN+];
vector<int> v[];
int f[MN+][MN+][MN+][];
int main()
{
    int n,i,j,k,l,cnt;
    scanf("%d%s",&n,s);
    for(i=;i<n;++i)
        if(s[i]=='V')v[].push_back(i);
        else if(s[i]=='K')v[].push_back(i);
        else v[].push_back(i);
    for(i=;i<=v[].size();++i)for(j=;j<=v[].size();++j)for(k=;k<=v[].size();++k)if(i||j||k)
    {
        f[i][j][k][]=f[i][j][k][]=INF;
        if(i)
        {
            f[i][j][k][]=min(f[i-][j][k][],f[i-][j][k][]);
            for(l=;l<j;++l)if(v[][l]>v[][i-])++f[i][j][k][];
            for(l=;l<k;++l)if(v[][l]>v[][i-])++f[i][j][k][];
        }
        if(j)
        {
            cnt=f[i][j-][k][];
            for(l=;l<i;++l)if(v[][l]>v[][j-])++cnt;
            for(l=;l<k;++l)if(v[][l]>v[][j-])++cnt;
            f[i][j][k][]=min(f[i][j][k][],cnt);
        }
        if(k)
        {
            cnt=min(f[i][j][k-][],f[i][j][k-][]);
            for(l=;l<i;++l)if(v[][l]>v[][k-])++cnt;
            for(l=;l<j;++l)if(v[][l]>v[][k-])++cnt;
            f[i][j][k][]=min(f[i][j][k][],cnt);
        }
    }
    printf("%d",min(f[i-][j-][k-][],f[i-][j-][k-][]));
}

E.Bear and Rectangle Strips

题目大意：给定一个2*n的数字矩阵，问最多能选出多少个互不相交的子矩阵和都为0。（n<=300,000）

思路：预处理出每个i作为右端点时第一行/第二行/两行一起向左最近的和为0的矩阵的左端点，用f[i]表示前2*i的数字矩阵的答案，每次转移有两种情况，一种直接两行一起取一个和为0的矩阵，利用预处理的信息直接转移，另一种情况是两行分别取若干个一行的子矩阵，我们用d(i,j)表示第一行i左边任意取，第二行j左边任意取的最大收益，采用记忆化搜索的方式计算，容易发现我们排除了大量的重复计算和无用状态，最终复杂度是比较科学的O(能过)。

#include<cstdio>
#include<algorithm>
#include<map>
using namespace std;
#define ll long long
char B[<<],*S=B,C;ll X,F;
inline ll read()
{
    for(F=;(C=*S++)<''||C>'';)if(C=='-')F=-;
    for(X=C-'';(C=*S++)>=''&&C<='';)X=(X<<)+(X<<)+C-'';
    return X*F;
}
#define MN 300000
#define d(x,y) make_pair(x,y)
ll s[MN+][];
int t[MN+][],f[MN+];
map<ll,int> mp;
map<pair<int,int>,int> u,ff;
int cal(int x,int y)
{
    if(u[d(x,y)])return ff[d(x,y)];
    return u[d(x,y)]=,ff[d(x,y)]=max(f[min(x,y)],t[x][]>t[y][]?cal(t[x][],y)+:cal(x,t[y][])+);
}
int main()
{
    fread(B,,<<,stdin);
    int n=read()+,i,j,k,l;
    for(i=;i<=n;++i)s[i][]=s[i-][]+read();
    for(i=;i<=n;++i)s[i][]=s[i-][]+read(),s[i][]=s[i][]+s[i][];
    for(l=;l<;++l)for(mp.clear(),i=;i<=n;++i)t[i][l]=max(t[i-][l],mp[s[i][l]]),mp[s[i][l]]=i;
    f[]=t[][]=t[][]=-;u[d(,)]=;ff[d(,)]=-;
    for(i=;i<=n;++i)f[i]=max(f[t[i][]]+,cal(i,i)),ff[d(i,i)]=f[i];
    printf("%d",f[n]);
}