2018山东省赛题目整理—5月23日

    欠了一大堆题目要整理都不知到要从哪里开始了。慢慢补上吧。

C题—Cities

题意：给出若干个城市的权值，求把它们连起来最少花费（花费=一条边连得两个城市权值）。

看似是最小生成树，其实是贪心更好写，权值最小的那个城市，用此城市连其他所有。

ll a[100005];
ll n;
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        ll minn=99999999;
        ll sum=0;
        scanf("%lld",&n);
        for(int i=1;i<=n;i++)
        {
            scanf("%lld",&a[i]);
            if(a[i]<minn) minn=a[i];
            sum+=a[i];
        }
        sum=sum-minn;
        sum=sum+(n-1)*minn;
        cout<<sum<<endl;
    }

}

A题—Anagram

题意：题目给出两个字符串A、B，这两个字符串都由'A'-'Z'构成，字符串X是字符串B任意颠倒字符顺序构成的，求由字符串A转变到字符串X的最少操作数，如A->B，1步 ；B->A，25步（可以看成Z、A相连成环）。

思路：还是贪心，

先将字符串A、B分别排序，如果a[i]<=b[j]依次寻找距离字符a[i]最近的字符b[j],如果a[i]>b[j],则将剩下的配对（这里不需要考虑配对的次序）

char s1[100],s2[100];
int a[100],b[100];
int vis[100];
int solve(int x,int y)
{
    if(x<=y) return y-x;
    else return 26-x+y;
}
int main()
{
    int len;
    while(scanf("%s%s",s1,s2)!=EOF)
    {
        len=strlen(s1);
        int i,j;
        for(i=0;i<len;i++)
        {
            a[i+1]=s1[i]-'A'+1;
            b[i+1]=s2[i]-'A'+1;
        }
        sort(a+1,a+1+len);
        sort(b+1,b+1+len);
        int ans=0;
        memset(vis,0,sizeof(vis));
        for(i=1;i<=len;i++)
        {
            int flag=0;
            for(j=1;j<=len;j++)
            {
                if(!vis[j]&&b[j]>=a[i])
                {
                    vis[j]=1;
                    ans=ans+solve(a[i],b[j]);
                    flag=1;
                    break;
                }
            }
            if(!flag)
            {
                for(j=1;j<=len;j++)
                {
                    if(!vis[j])
                    {
                        vis[j]=1;
                        ans=ans+solve(a[i],b[j]);
                        break;
                    }
                }
            }
        }
        cout<<ans<<endl;
    }

}

F题—Four-tuples

题意：给出四个区间，问分别从四个区间中取出一个数，满足x1!=x2,x2!=x3,x3!=x4,x4!=x1，的情况有多少种。

来自：https://blog.youkuaiyun.com/MIECZ/article/details/80279668

1.先将四个区间长度的乘积作为答案 
2.分别减去 x1=x2,x2=x3,x3=x4,x4=x1 四种情况的组合数量（每种情况中未提及的变量在其区间中任选，即统计答案时直接乘区间长度） 
3.因为减去 x1=x2 和 x2=x3 时会重复减去 x1=x2=x3,x1=x2=x3 的情况，所以要加回来 
类似的还有 x1=x2=x4, x2=x3=x4, x1=x3=x4, x1=x2=x3,x1=x2且x3=x4, x2=x3且x1=x4

4.第一步的答案中应该减去1个x1=x2=x3=x4,但是在第二步中减去了4个，第三步中又加了6个，所以总共加了2个，最终应该减去3个x1=x2=x3=x4的情况

       这道题补题的时候有讨论了好久，主要是在那个对边的情况没考虑到，果然是我对容斥原理的理解深度不够，容斥原理不是简单的奇加偶减，而是始终补缺减余。

这确实是一道好题，还是我太菜了。

const ll mod=1e9+7; 
int main() 
{ 
    ll n,l1,l2,l3,l4,r1,r2,r3,r4,tp1l,tp2l,tp1r,tp2r,ans; 
    scanf("%lld\n",&n); 
    while(n--&&scanf("%lld%lld%lld%lld%lld%lld%lld%lld",&l1,&r1,&l2,&r2,&l3,&r3,&l4,&r4)!=EOF) 
    { 
        ans=(r1-l1+1)*(r2-l2+1)%mod; 
        ans=ans*(r3-l3+1)%mod; 
        ans=ans*(r4-l4+1)%mod; 
        //1==2 
        tp1l=max(l1,l2); 
        tp1r=min(r1,r2); 
        if(tp1l<=tp1r) 
            ans=((ans-(tp1r-tp1l+1)*(r3-l3+1)%mod*(r4-l4+1)%mod)%mod+mod)%mod; 
        //2==3 
        tp1l=max(l3,l2); 
        tp1r=min(r3,r2); 
        if(tp1l<=tp1r) 
            ans=((ans-(tp1r-tp1l+1)*(r1-l1+1)%mod*(r4-l4+1)%mod)%mod+mod)%mod; 
        //3==4 
        tp1l=max(l3,l4); 
        tp1r=min(r3,r4); 
        if(tp1l<=tp1r) 
            ans=((ans-(tp1r-tp1l+1)*(r1-l1+1)%mod*(r2-l2+1)%mod)%mod+mod)%mod; 
        //4==1 
        tp1l=max(l1,l4); 
        tp1r=min(r1,r4); 
        if(tp1l<=tp1r) 
            ans=((ans-(tp1r-tp1l+1)*(r3-l3+1)%mod*(r2-l2+1)%mod)%mod+mod)%mod; 
             
             
             
        //1==2 2==3 
        tp1l=max(l1,max(l3,l2)); 
        tp1r=min(r1,min(r3,r2)); 
        if(tp1l<=tp1r) 
            ans=(ans+(tp1r-tp1l+1)*(r4-l4+1)%mod)%mod;
              
        //1==2 3==4 
        tp1l=max(l1,l2); 
        tp1r=min(r1,r2); 
        tp2l=max(l3,l4); 
        tp2r=min(r3,r4); 
        if(tp1l<=tp1r&&tp2l<=tp2r) 
            ans=(ans+(tp1r-tp1l+1)*(tp2r-tp2l+1)%mod)%mod; 
             
             
        //1==2 4==1 
        tp1l=max(l1,max(l4,l2)); 
        tp1r=min(r1,min(r4,r2)); 
        if(tp1l<=tp1r) 
            ans=(ans+(tp1r-tp1l+1)*(r3-l3+1)%mod)%mod; 
        //2==3 3==4 
        tp1l=max(l4,max(l3,l2)); 
        tp1r=min(r4,min(r3,r2)); 
        if(tp1l<=tp1r) 
            ans=(ans+(tp1r-tp1l+1)*(r1-l1+1)%mod)%mod; 
        //2==3 1==4 
        tp1l=max(l3,l2); 
        tp1r=min(r3,r2); 
        tp2l=max(l1,l4); 
        tp2r=min(r1,r4); 
        if(tp1l<=tp1r&&tp2l<=tp2r) 
            ans=(ans+(tp1r-tp1l+1)*(tp2r-tp2l+1)%mod)%mod;
             
              
        //3==4 4==1 
        tp1l=max(l4,max(l3,l1)); 
        tp1r=min(r4,min(r3,r1)); 
        if(tp1l<=tp1r) 
            ans=(ans+(tp1r-tp1l+1)*(r2-l2+1)%mod)%mod; 
             
             
        //1==2==3==4 
        tp1l=max(l4,max(max(l2,l3),l1)); 
        tp1r=min(r4,min(min(r2,r3),r1)); 
        if(tp1l<=tp1r) 
            ans=((ans-(tp1r-tp1l+1)*3)%mod+mod)%mod; 
        printf("%lld\n",ans); 
    } 
    return 0; 

}

G题—Games

题意：给n堆石子，要从这n堆石子里删去x堆，(0<=x<=d)，使得 Bob（后手）赢，求总方案数。

用到了一点Nim博弈的知识。实际上是背包。不过这道题注意卡内存，用int。

设dp[ i ] [ j ] [ k ]代表在前 i 堆石子，去掉 j 堆的异或结果为k的方案数。
那么动态转移方程为： 

dp[i][j][k]=(dp[i-1][j][k]+dp[i-1][j-1][k^a[i]])

const long long mod=1e9+7;
int a[1002],dp[1002][12][1205];
int sum;
int main()
{
    int T,n,d;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&d);
        sum=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum^=a[i];
        }
        memset(dp,0,sizeof(dp));
        for(int i=0;i<=n;i++) dp[i][0][0]=1;
        ll ans=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=d;j++)
            {
                for(int k=0;k<=1204;k++)
                {
                    dp[i][j][k]=dp[i-1][j-1][(k^a[i])]+dp[i-1][j][k];
                    if(dp[i][j][k]>=mod) dp[i][j][k]-=mod;
                }
                if(i==n)
                {
                    ans=ans+dp[i][j][sum];
                    if(ans>=mod) ans-=mod;
                }
            }
        }
        ans=(ans+dp[n][0][sum])%mod;
        printf("%lld\n",ans);
    }

}

E—Sequence

题意：给你一个长度为n(n<=1e6)的整数序列，定义“好数”：存在下标比它小的数，值也严格小于它。

你现在必须要删除且只能删除一个数，使删除后好数数量最多，如果有多个答案，输出最小的那个。

思路：

删除一个好数，则总的好数数量将减少一个(因为删除它后能影响到的好数仅有它自己)；

删除一个不好数，考虑删除这个不好数后能影响到的好数有几个，那么总的好数数量就减少几个；(被它所影响到的好数

因此维护一个前缀最小值和次小值就可以了。

#define inf 0x3f3f3f3f
ll a[1000010];
ll first[1000010];
ll second[1000010];
bool flag[1000010];
ll cnt[1000010];
 
int main()
{
    ll t;
    scanf("%lld",&t);
    while(t--)
    {
        ll n;
        scanf("%lld",&n);
        ll now_min=inf;
        ll pre_min=inf;
        for(ll i=1;i<=n;i++)
        {
            scanf("%lld",&a[i]);
            first[i]=now_min;//前缀最小
            second[i]=pre_min;//前缀次小
            if(a[i]<=now_min) {pre_min=now_min; now_min=a[i];}
            else {if(a[i]<pre_min) pre_min=a[i];}
        }
        for(ll i=1;i<=n;i++)
        {
            if(a[i]<=first[i]) flag[i]=1;//坏数
            else flag[i]=0;//好数
        }
        ll k;
        for(ll i=1;i<=n;i++)
        {
            if(flag[i]==1)//坏数
            {
                k=i;
                cnt[k]=0;
            }
            else if(flag[i]==0)//好数
            {
                if(a[i]<=second[i]) cnt[k]++;
            }
        }
        ll ans=inf;
        for(ll i=1;i<=n;i++)
        {
            if(flag[i]==1&&cnt[i]==0) ans=min(ans,a[i]);
        }
        if(ans==inf)
        {
            for(ll i=1;i<=n;i++)
            {
                if(flag[i]==0) ans=min(ans,a[i]);
                else if(cnt[i]==1) ans=min(ans,a[i]);
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}