Educational Codeforces Round 92 (Rated for Div. 2)——A.B.C.D.

A. LCM Problem

题意：t组输入，左右区间，区间内存在两个数的LCD（最小公倍数）的值在左右区间内 打印俩个数，否则-1 -1。
思路：两个数最小公倍数就是两倍关系，判断区间左端点的两倍是否在有区间以内，在就是l 2*l，不在就是 -1 -1。
代码

#include<stdio.h>
#include<bits/stdc++.h>
using namespace std;
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int l,r;
        scanf("%d%d",&l,&r);
        if(r>=2*l)
        {
            printf("%d %d\n",l,2*l);
        }
        else
        {
            printf("-1 -1\n");
        }
    }
    return 0;
}

B. Array Walk

题意：本人真实很菜，从这道题开始就停滞了。 给出n，数组大小，k，移动总步数，z，向左移的步数（向左移有要求是，向左不能连续）。起始位置在1位，问最大左右移动的和值是多少。
思路：dp很难（我觉得）
参见博客
代码

#include <bits/stdc++.h>
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int maxn = 3e5+10;
int n,k,z;
ll a[300005],dp[300005][10];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d%d",&n,&k,&z);
        for(int i=1; i<=n; i++)
        {
            scanf("%lld",&a[i]);
        }
        for(int i=0; i<=n; i++)//!
            memset(dp[i],0,sizeof(dp[i]));
        dp[1][0]=a[1];
        ll ans=0;
        for(int i=2; i<=n; i++)
        {
            for(int j=0; j<=z; j++)
            {
                dp[i][j]=max(dp[i][j],dp[i-1][j]+a[i]);
                if(i-1+2*j==k)
                {
                    ans=max(ans,dp[i][j]);
                }
                dp[i-1][j+1]=max(dp[i-1][j+1],dp[i][j]+a[i-1]);
                if(j+1<=z&&i-1-1+2*(j+1)==k)
                {
                    ans=max(ans,dp[i-1][j+1]);
                }
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}

C. Good String

题意：给一个字符串，删删减减之后的这个字符串要求满足：整个字符串右移一位，尾部挪到最起那面之后的字符串需要与，整个字符串左移，头部挪到尾部的字符串相同，一模一样，问最少删去几个字符得到满足条件的字符串。
思路：参考博客
如果移动之后的字符串左边拿一个放后边，右边拿一个放前边，之后这两个字符串相等，那就是这个字符串内部只能时两个 两个一组活动才能保证，121212就可以是—212121—212121，如果是三个的话——123123—231231—312312就是不行。也可以是整个字符串都是一样的字符无论怎么移动都是一样的。
代码
就是没有想到的话是两个一组的话，可以直接枚举两个是什么，10个数两两配对出去两个数相同也不大。

#include <bits/stdc++.h>
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int maxn = 3e5+10;
char a[200005];
int vis[11];
int check(int p,int q,int  n)
{
    char pp=p+'0';
    char qq=q+'0';
    int flag=0,len=0;
    for(int i=0; i<n; i++)
    {
        if(flag==0&&a[i]==pp)
            flag=1;
        if(flag==1&&a[i]==qq)
            flag=0,len+=2;
    }
    return len;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        cin>>(a);
        int n=strlen(a);
        int ans=-1;
        memset(vis,0,sizeof(vis));
        for(int i=0; i<n; i++)
        {
            vis[a[i]-'0']++;
            ans=max(ans,vis[a[i]-'0']);
        }
        //printf("%d\n",ans);
        for(int i=0; i<=9; i++)
        {
            for(int j=0; j<=9; j++)
            {
                if(i==j)
                    continue;
                ans=max(ans,check(i,j,n));
            }
        }
        //printf("%d\n",ans);
        printf("%d\n",n-ans);
    }
    return 0;
}

D. Segment Intersections

题意：给定的是n，两组区间段的个数，k相交部分的和值，第一组区间段给出左右区间（l1,r1），且组内n个区间段的范围都是这个，另一组也给出一个区间段（l2,r2）。每个区间段可以一次移动一个单位，问最后第一组对应的第二组区间段的相交部分加和的值大于等于k的最小步骤。

思路：参见博客
就是分成两种大情况，一种是给出的两个区间段是相交的，另一种是不相交的。
先说相交的，相交部分先减去，看是否满足，不满足就，进行一换一：任何一个区间朝着另一个区间移动都是相交加一的（最长可移动对方的左右区间长度），这种任意一个区间一步移动都可以带来一个单位的相交，称为一换一。累计相交部分，如果大于等于k了，则结束，否则就是两个区间段同时朝着一个方向移动换来一个单位的相交，称为二换一。二换一没有次数要求可以无数次，直到相交总值大于等于k。

不相交的则需要先弄成相交的，即离得最近的两个端点的中间距离，注意这些移动是不带来任何相交结果，暂时称为无效移动，移动之后的结果就是两个区间有一头是在同一位置的。
然后需要枚举对几个区间段进行操作，因为可能每次都要进行无效操作，会比二换一耗费更多。
然后先对当下数目的区间进行一换一，够了则继续，不够则二换一到满足。
全部枚举时更新ans最小值。
代码

#include <bits/stdc++.h>
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int maxn = 3e5+10;
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        ll n,k;
        ll l1,r1,l2,r2;
        ll ans=0x3f3f3f3f3f3f3f;
        scanf("%lld%lld",&n,&k);
        scanf("%lld%lld",&l1,&r1);
        scanf("%lld%lld",&l2,&r2);
        if(r1<l2||r2<l1)//不相交的情况
        {
            ll len=max(r2,r1)-min(l1,l2);//完全一样之后的总长度
            ll tmp;//记录中间无效移动的次数，一个的
            if(r1<l2)
                tmp=l2-r1;
            else
                tmp=l1-r2;
            for(ll i=1; i<=n; i++)//由于中间有无效移动的所以用for循环来找出是否可着一个区间加和每次都要进行无效移动哪个更好。
            {
                ll sum=len*i;//全都是一换一的话是否满足
                if(sum>=k)///一换一比较划算
                {
                    ans=min(ans,tmp*i+k);///tmp次无效移动*i个区间需要移动+加上一换一最小的k值。
                }
                else///不够的话，就要二换一。（无限次）
                {
                    ans=min(ans,sum+tmp*i+(k-sum)*2);///tmp次无效移动*i个区间需要移动+加上一换一最小的k值，
                    //接下来就是两条线同步移动（往同一个方向），即两个片段个移动一下换来一单位的重叠区间
                }
            }
        }
        else//相交的情况
        {
            ll jiao=min(r2,r1)-max(l1,l2);//已经相交的长度
            ll len=max(r2,r1)-min(l1,l2)-jiao;//到达两个区间一样————还需要（-jiao）————走多少，每个
            k-=jiao*n;//先要把已经相交的地方去掉，看是否满足
            if(k<=0)//如果已相交部分够用
                ans=0;
            else if(len*n>=k)//不够用先一换一
            {
                ans=k;
            }
            else//还不够二换一。（无限次）
                ans=len*n+(k-len*n)*2;
        }
        printf("%lld\n",ans);
    }
    return 0;
}