NYIST-2019省赛训练组队积分赛第一场

A - The Useless Toy

CodeForces - 834A

大概题意

给你两个字符，和一个数字n，问你第一个字符转到第二个字符是顺时针转的还是逆时针转的或者无法判断，输入是合法的，保证第一个字符转n次一定可以转到第二个字符
字符只包括四钟，v , ^ , < , >
这个英文题。。。读到爆炸。。。。是个水题。。。就是读不出来题意。。你说气不气。。。。
直接模拟就行了。。。比赛的时候，就直接模拟的。。。代码巨长。。

#include
#include
#include
using namespace std;
int main()
{
    char a,b;
    scanf("%c %c",&a,&b);
    int n;
    scanf("%d",&n);
    n%=4;
    if(a=='^')
    {
        if(n==0)
        {
                printf("undefined\n");
        }
        if(n==1)
        {
            if(b=='>')
                printf("cw\n");
            else if(b=='<')
                printf("ccw\n");
            else
                printf("undefined\n");
        }
        if(n==2)
        {
                printf("undefined\n");
        }
        if(n==3)
        {
            if(b=='<')
                printf("cw\n");
            else if(b=='>')
                printf("ccw\n");
            else
                printf("undefined\n");
        }
    }
    else if(a=='>')
    {
        if(n==0)
        {
                printf("undefined\n");
        }
        if(n==1)
        {
            if(b=='v')
                printf("cw\n");
            else if(b=='^')
                printf("ccw\n");
            else
                printf("undefined\n");
        }
        if(n==2)
        {
                printf("undefined\n");
        }
        if(n==3)
        {
            if(b=='^')
                printf("cw\n");
            else if(b=='v')
                printf("ccw\n");
            else
                printf("undefined\n");
        }
    }
    else if(a=='v')
    {
        if(n==0)
        {
                printf("undefined\n");
        }
        if(n==1)
        {
            if(b=='<')
                printf("cw\n");
            else if(b=='>')
                printf("ccw\n");
            else
                printf("undefined\n");
        }
        if(n==2)
        {

                printf("undefined\n");
        }
        if(n==3)
        {
            if(b=='>')
                printf("cw\n");
            else if(b=='<')
                printf("ccw\n");
            else
                printf("undefined\n");
        }
    }
    else if(a=='<')
    {
        if(n==0)
        {
                printf("undefined\n");
        }
        if(n==1)
        {
            if(b=='^')
                printf("cw\n");
            else if(b=='v')
                printf("ccw\n");
            else
                printf("undefined\n");
        }
        if(n==2)
        {

                printf("undefined\n");
        }
        if(n==3)
        {
            if(b=='v')
                printf("cw\n");
            else if(b=='^')
                printf("ccw\n");
            else
                printf("undefined\n");
        }
    }
    return 0;
}

·
·

B - Protect Sheep

CodeForces - 948A

在一个n*m的格子上，W代表狼，S代表羊，D代表狗，狼会上下左右的移动吃羊，狗会保护羊，让你在羊的旁边放狗，让狼无法伤害到羊，如果无论如何都无法让保护羊就输出No
因为狗的数量没有限制，所以把羊的旁边填满狗就行了，如果羊的旁边就是狗，那就输出No

#include
#include
#include
using namespace std;
char e[505][505];
int nex[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
int main()
{
    int n,m;
    scanf("%d %d",&n,&m);
    int flag=0;
    for(int i=0;i<n;i++)
        scanf("%s",e[i]);
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            int xx=i;
            int yy=j;
            if(e[xx][yy]=='S')
            {
                for(int k=0; k<4; k++)
                {
                    int tx=xx+nex[k][0];
                    int ty=yy+nex[k][1];
                    if(tx<0||ty<0||tx>=n||ty>=m)
                        continue;
                    if(e[tx][ty]=='W')
                    {
                        flag=1;
                    }
                    if(!flag)
                    {
                       if(e[tx][ty]=='.')
                            e[tx][ty]='D';
                    }
                }
            }

        }
    }
    if(flag==1)
        printf("No\n");
    else
    {
        printf("Yes\n");
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
                printf("%c",e[i][j]);
            printf("\n");
        }
    }
    return 0;
}

·
·

C - Petya and Exam

CodeForces - 832B

大概题意

首先给你两个字符串，第一个字符串里的字母都是好的字母，其余的字母都是不好的字母，
第二行给你一个模式串，这个串里包括字母，‘？’ ，‘ * ’，？只能被好的字母所代替， ‘ * ’可以被代替为一个字符串，但是这个字符串里的字母只能是不好的字母，一个串中只有一个‘ * ’
然后一个数字m，代表着m次查询，每次查询一个字符串，问你这个字符串是不是模式串可以扩充出来的

思路

因为只有一个 * 所以代替 * 的这个字符串的长度是可以被算出来的，用一个数组vis来存这个字母是好的还是坏的

#include
#include
#include
using namespace std;
char a[100005],s[100005],b[100005];
int vis[1005];
int main()
{
    int m;
    scanf("%s",a);
    int l1=strlen(a);
    for(int i=0; i<l1; i++)
    {
        int k=a[i]-'0';
        vis[k]=1;
    }
    scanf("%s",b);
    int l2=strlen(b);
    scanf("%d",&m);
    while(m--)
    {
        memset(s,0,sizeof(s));
        scanf("%s",s);
        int flag=0;
        int l3=strlen(s);
        int i=0,t=0;//i遍历模式串，t遍历查询串
        while(i<l2)
        {
            if(b[i]=='?')
            {
                int k=s[t]-'0';
                if(vis[k])
                {
                    i++;
                    t++;
                }
                else
                    flag=1;
            }
            else if(b[i]=='*')
            {
                if(l3!=l2-1)
                {
                    int k=l3-l2+1;
                    while(t<i+k)
                    {
                        int e=s[t]-'0';
                        if(vis[e])
                        {
                            flag=1;
                            break;
                        }
                        t++;
                    }
                }
                i++;
            }
            else
            {
                //printf("%d %d\n",i,t);
                if(s[t]==b[i])
                {
                    i++;
                    t++;
                }
                else
                {
                    flag=1;
                }

            }

            if(flag)
                break;
        }
        if(!flag)
        {
            if(i!=l2||t!=l3)//判断这链各个串有没有遍历完
                flag=1;
        }
        if(flag)
            printf("NO\n");
        else
            printf("YES\n");
    }
    return 0;
}

·
·

D - The Tag Game

CodeForces - 813C

大概题意

有一个节点数为n的树，一共有n-1条边连接着，刚开始的时候小A在节点1，小B在节点x，每一次小A和小B可以移动到相邻的节点上去，当小A和小B站在相同的节点上的时候，游戏结束，小A想走最短的路，小B想走最远的路，问你游戏结束的时候小A和小B的总步数是多少（小B原地不动也算一步）

思路

因为小A想走最近的路，所以小A一定跟着小B走，并且没有多余的步数追小B，最后他们两个一定相遇在某个节点y，并且是小B先到小A后到，而小B可以找到他能走到的离根节点1距离最大的点这样就能使最后步数最大。
所以我们可以求出从1节点也就是小A起始的位置到每个节点的距离，在求出x节点到每个节点的距离，取出小A比小B晚到的点中选出离节点1的最远的那个点
因为小B不走也算一步没所以最后的结果小A走的步数和小B走的步数是一样的，直接让求出的符合题意的最远距离乘2就行

#include
#include
#include
using namespace std;
struct node
{
    int v,nex;
};
node e[500005];
int f[200005],vis[200005],tot;
int d1[200005],d2[200005];
void add(int u,int v)
{
    e[tot].v=v;
    e[tot].nex=f[u];
    f[u]=tot++;
}
void dfs1(int u,int fa,int sum)
{
    d1[u]=sum;
    for(int i=f[u];i!=-1;i=e[i].nex)
    {
        int v=e[i].v;
        if(v!=fa)
        {
            vis[v]=1;
            dfs1(v,u,sum+1);
        }
    }
}
void dfs2(int u,int fa,int sum)
{
    d2[u]=sum;
    for(int i=f[u];i!=-1;i=e[i].nex)
    {
        int v=e[i].v;
        if(v!=fa)
        {
            vis[v]=1;
            dfs2(v,u,sum+1);
        }
    }
}
int main()
{
    memset(f,-1,sizeof(f));
    tot=0;
    int n,m,x,y;
    scanf("%d %d",&n,&m);
    for(int i=1;i<n;i++)
    {
        scanf("%d %d",&x,&y);
        add(x,y);
        add(y,x);
    }
    memset(vis,0,sizeof(vis));
    vis[1]=1;
    dfs1(1,0,0);

    memset(vis,0,sizeof(vis));
    vis[m]=1;
    dfs2(m,0,0);
    int sum=0;
    for(int i=1;i<=n;i++)
    {
        if(d1[i]>d2[i])
        {
            sum=max(sum,2*d1[i]);
        }
    }
    printf("%d\n",sum);
    return 0;
}

·
·

E - GukiZ hates Boxes

CodeForces - 551C

大概题意

道路上有n堆石头，每堆石头有ai个石头，这n堆石头排列在一条直线上，每一秒可以做一下的其中一个操作：
1）从第i堆走到第i+1堆
2）在第i堆中移走一个石头（第i堆的石头数量不为0）
一共有m个人，刚开始的时候他们都在第一堆石头的左边，走到第一堆石头需要1秒
问你移走这些石头一共需要最小的时间是多少秒

思路

二分需要的时间，如果此时的需要判断x秒内是否可以把石头移走的方法：
我们一共有m个人，那我们一个人一个人的判断，每个人不浪费任何一秒钟从第一堆石头开始移，因为如果每次遍历一遍石头的话，时间复杂度太高了，我么设一个变量pos代表现在要移的是第pos堆石头，最后判断这n堆石头是不是已经被全部移走

#include
#include
#include
using namespace std;
long long a[100005],b[100005];
long long n,m;
int F(long long mid)
{
    for(int i=1; i<=n; i++)
        b[i]=a[i];
    int pos=1;
    long long ans=0;
    for(int i=1; i<=m; i++)
    {

        long long k=mid;
        k-=pos;
        while(k&&pos<=n)
        {
            if(b[pos]==0)
            {
                pos++;
                k--;
            }
            if(k==0)
                break;
            if(pos>n)
                break;
            if(k>=b[pos])
            {
                k-=b[pos];
                b[pos]=0;
            }
            else
            {
                b[pos]-=k;
                k=0;
            }
        }
    }
    for(int i=1; i<=n; i++)
    {
        if(b[i]>0)
            return 0;
    }
    return 1;
}
int main()
{
    scanf("%lld %lld",&n,&m);
    long long r=0,k;
    for(int i=1; i<=n; i++)
    {
        scanf("%lld",&a[i]);
        r+=a[i];
        if(a[i])
            k=i;
    }
    r+=k;
  // printf("%lld\n",r);
    long long l=1,ans=0;
    while(l<=r)
    {
        long long mid=(l+r)/2;
     //   printf("%lld %lld %lld\n",mid,l,r);
        if(F(mid))
        {
            ans=mid;
            r=mid-1;
        }
        else
            l=mid+1;
    }
    printf("%lld\n",ans);
    return 0;
}

·
·

F - Zebras

CodeForces - 950C

大概题意

给你一个01串，从中抽出k个子串，这些子串要以0开头，以0结尾，中间01相间，不要求k的数量最大或者最小

思路

遍历这个01字符串，当前字符是0就放在结尾是1的子字符串后面，如果没有以1结尾的，就把0放在第下一个子字符串，当前是1的话就放在结尾是0的子字符串的后面，如果没有，就输出-1
用一个变量z来记录当前子字符串是以0结尾还是以1结尾的

#include
#include
#include
#include
using namespace std;
char s[200005];
vector<int>v[200005];
int main()
{
    scanf("%s",s);
    int l=strlen(s);
    int z=0,ans=0;
    for(int i=0;i<l;i++)
    {
        if(s[i]=='0')
        {
            v[++z].push_back(i);
        }
        else
        {
            if(z==0)
            {
                printf("-1\n");
                return 0;
            }
            else
                v[z--].push_back(i);
        }
        ans=max(ans,z);
    }
    if(ans!=z)
    {
        printf("-1\n");
        return 0;
    }
    printf("%d\n",ans);
    for(int i=1;i<=ans;i++)
    {
        int k=v[i].size();
        printf("%d",k);
        for(int j=0;j<k;j++)
            printf(" %d",v[i][j]+1);
        printf("\n");
    }
    return 0;
}

·
·

G - Sliding Window

POJ - 2823

单调队列的板子题，比赛的时候敲了一遍板子就过了，刚刚入门单调栈和单调队列，学明白了再回来补，先放一个ac的代码
还有，交C++才能过，交G++会T

#include
#include
#include
#include
#include
using namespace std;
long long q[1000005],a[1000005],b[1000005],c[1000005],q1[1000005];
int main()
{
    int n,k;
    scanf("%d %d",&n,&k);
    for(int i=0; i<n; i++)
        scanf("%lld",&a[i]);
    int s=0,t=0,s1=0,t1=0;
    for(int i=0; i<n; i++)
    {
        while(s<t&&a[q[t-1]]>=a[i])
            t--;
        q[t++]=i;
        if(i-k+1>=0)
        {
            b[i-k+1]=a[q[s]];
            if(q[s]==i-k+1)
                s++;
        }

        while(s1<t1&&a[q1[t1-1]]<=a[i])
            t1--;
        q1[t1++]=i;
        if(i-k+1>=0)
        {
            c[i-k+1]=a[q1[s1]];
            if(q1[s1]==i-k+1)
                s1++;
        }
    }
    for(int i=0;i<=n-k;i++)
        printf("%lld%c",b[i],i==n-k?'\n':' ');
    for(int i=0;i<=n-k;i++)
        printf("%lld%c",c[i],i==n-k?'\n':' ');
    return 0;
}

·
·

HihoCoder - 1710

给定N个整数A1, A2, … AN，小Hi会询问你M个问题。
对于每个问题小Hi给出两个整数L和R(L ≤ R)，请你找出[AL, AL+1, AL+2, … AR]中最长的等差连续子数列，并输出其长度。
例如[2, 3, 5, 7, 9]中最长的等差连续子数列是[3, 5, 7, 9]长度为4。

Input
第一行包含两个整数N和M。
第二行包含N个整数A1, A2, … AN。
以下M行每行包含两个整数L和R，代表一次询问。
对于30%的数据，1 ≤ N, M ≤ 1000
对于100%的数据，1 ≤ N, M ≤ 100000 0 ≤ Ai ≤ 10000000

Output
依次对于每个询问输出一个整数，代表答案。

先写了一发奇奇怪怪的线段树。。。虽然知道大概哪里错了，但是没改出来。。。
最后用的是RMQ
首先举个栗子
1 2 3 5 7 9 8 7 6 5
我们可以看出来1 2 3 是个等差数列，3 5 7 9 是个等差数列，9 8 7 6 5是个等差数列，那么我们可以把这个数组分为三段

下面是几个数组的变量解释;
sum[i] : 第i个数字所在的等差数列的等差值
L[i] ：第i个数字所在的等差数列的最右端的开始的下标
R[i] ：第i个数字所在的等差数列最左边的结束的下标
那么刚刚上面的那个例子的sum，L，R的值就是下面的表

	1	2	3	5	7	9	8	7	6	5
sum	1	1	2	2	2	-1	-1	-1	-1	-1
L	1	1	3	3	3	6	6	6	6	6
R	3	3	6	6	6	10	10	10	10	10

那么我们把每次查询的【l,r】的结果分为三个部分的最大值，R[l]-l+1,r-L[r]+1,R[l]+1~L[r]-1
分别代表了从l到l所在的段的结束处的元素个数，从r所在段的开始处到r处的元素个数，和这中间的那一段的sum的值
那么如果我们想要计算【2,9】之间的最长连续等差序列，也就是2 3 5 7 9 8 7 6 之间的最长连续子序列
那么对于这次查询，可以把这个查询根据等差数列分的段分为3段2 3 | 5 7 | 9 8 7 6这三段
2 3这一段一共有2个数
5 7这一段的最大的sum值是3
9 8 7 6这一段一共有4个数
所以这一段的最长连续子序列的个数就是4
对于中间段R[l]+1到L[r]-1这个区间里找sum的最大值用的是RMQ查找。。。

特别的

如果l和r在同一个等差数列的段中，那么答案就是r-l+1；

* 对于查询中间段R[l]+1到L[r]-1这个区间里找sum的最大值这个步骤，要用到RMQ我以前一直写线段树，第一次写RMQ，还是记录一下：

首先预处理一下dp数组（听大佬讲，RMQ用的思想是DP）：
dp[i][j]:第i位数字到它后面的2^j个位置的最大值（i后面的一个位置是它本身）
首先预处理dp[i][0]=sum[i];
下面的我们来举个栗子
现在有4个数字 1 2 3 4 5
我们要算dp[1][2],也就是1后面的包括它本身的四个数字
那么我们可以把1 2 3 4 分为1 2 一段 3 4 一段
1 2 是1后面包括他本身的两个数字 他们的最大值也就是 dp[i][2-1];
3 4 shi 3后面包括他本身的两个数字，3和1之间隔了2¹个数字，也就是dp[i+(1<<(j-1))][j-1];
所以dp[i][j]=max (dp[i][j-1] , dp[i+(1<<(j-1))][j-1]);
然后查询的时候，令k为满足2^k<=r-l+1的最大整数，则以l开头，以r结尾的 两个 长度为2^k的区间合起来覆盖了查询区间【l，r】，取最大值就好了

#include
#include
#include
using namespace std;
int n,m,ans;
int A[100010];
int L[100010],R[100010],sum[100010],dp[100010][25];
void init_RMQ()
{
    for(int i=1; i<=n; i++)dp[i][0]=sum[i];
    for(int j=1; (1<<j)<=n; j++)
    {
        for(int i=1; i+(1<<j)-1<=n; i++)
        {
            dp[i][j]=max(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
        }
    }
}
int RMQ(int l,int r)
{
    if(r<l)
        return -1;
    int k=0;
    while(1<<(k+1)<=r-l+1) k++;
    return max(dp[l][k],dp[r-(1<<k)+1][k]);
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=1; i<=n; i++)
            scanf("%d",&A[i]);
        int i=1,j,ca,cut,q;
        while(i<=n)
        {
            q=i;
            ca=A[i+1]-A[i];
            j=i;
            cut=1;
            while(j<=n&&A[j+1]-A[j]==ca) j++,cut++;
            for(; i<j; i++)
            {
                L[i]=q,R[i]=j,sum[i]=cut;
            }
        }
        for(int i=1; i<=n; i++)
            printf("%d ",L[i]);
        printf("\n");
        for(int i=1; i<=n; i++)
            printf("%d ",R[i]);
        init_RMQ();
        int l,r;
        while(m--)
        {
            scanf("%d%d",&l,&r);
            ans=min(R[l]-l+1,r-l+1);
            ans=max(ans,min(r-L[r]+1,r-l+1));
            ans=max(ans,RMQ(R[l]+1,L[r]-1));
            printf("%d\n",ans);
        }
    }
}