Codeforces Round #401 (Div. 2)

                                                                                  Codeforces Round #401 (Div. 2)

   很happy，现场榜很happy，完全将昨晚的不悦忘了。终判我校一片惨白，小董同学怒怼D\E,离AK就差一个C了，于是我AC了C题还剩35分钟立刻开D题，不料英文苦涩难懂，懂了题意之后发现也是个水题，从后往前遍历一遍即可。然而代码速度和思维都不算很好，还有半分钟在徘徊要不要测一下样例，但又怕OJ卡了，直接交第一组就跪了，然后发现个小问题改改又直接交最后5秒然而以第一组WA结束本场CF。

                                                                        A  Shell Game

   题意：有三个位置分别为0 1 2。有一个球在这三个位置转换，当第i次变换如果i为奇数则0和1位置交换，反之1和2交换，给出次数n和求的最终位置k。求初始位置。

   这个题没什么规律可言，可怜我们推了这么久，最后无奈手推所有情况发现6为周期，然后直接暴力判断所有情况。

int main()
{
    int n,x;
    while(~scanf("%d%d",&n,&x))
    {
        n%=6;
        if(n==0) printf("%d\n",x);
        if(n==1)
        {
            if(x<2) printf("%d\n",abs(x-1));
           else puts("2");
        }
        if(n==2) {
                if(x==0) puts("1");
            if(x==1) puts("2");
            if(x==2) puts("0");
        }
        if(n==3){
                if(x==0) puts("2");
            if(x==1) puts("1");
            if(x==2) puts("0");
        }
        if(n==4) {
                if(x==0) puts("2");
            if(x==1) puts("0");
            if(x==2) puts("1");
        }
        if(n==5) {
                if(x==0) puts("0");
            if(x==1) puts("2");
            if(x==2) puts("1");
        }


    }
    return 0;
}

                                                            B. Game of Credit Cards

   题意：A和B玩游戏，他们分别在纸上写下n个数字（0-9）。然后对比，如果A[i]>B[i] ,A打B一下，如果A比B小则B打A一下，现在B可以作弊，他知道了A的n个数。问你B最少被打几下，A最多被打几下。

  思路：就是一个简单贪心貌似，终判挂了好多人。直接将所有的数字出现的次数用数组存起来，然后求B最少被打几下，我们肯定是抵消原则，从最接近A的那个数往上开始查找然后抵消一个B的数字。我们可以假设B被打n次，然后我们肯定是尽量抵消。求A最多被打几次也是从A那个数字往上但不能等于A[i]，因为要比A大且最接近A[i]才是最优策略，如果找不到比这个数大的那只能被打了。我们就找一个最小的和这个抵消.

char s1[N],s2[N];
int a1[10],a2[10],a3[10];
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        memset(a1,0,sizeof(a1));
        memset(a2,0,sizeof(a2));
        memset(a3,0,sizeof(a3));
        scanf("%s%s",s1,s2);
        for(int i=0; i<n; i++)
        {
            a1[s1[i]-'0']++;
            a2[s2[i]-'0']++;
            a3[s2[i]-'0']++;
        }
        int mi=0,ma=0;
        for(int i=0; i<n; i++)
        {
            int id=s1[i]-'0';
            int f=1;
            for(int j=id; j<=9; j++)
                if(a2[j])
                {
                    a2[j]--;
                    f=0;
                    break;
                }
            if(f) mi++;
        }

        for(int i=0; i<n; i++)
        {
            int id=s1[i]-'0';
            int f=0;
            for(int j=id+1; j<=9; j++)
                if(a3[j])
                {
                    a3[j]--;
                    f=1;
                    break;
                }
            if(f) ma++;
            else
            {
                for(int j=0; j<=id; j++)
                    if(a3[j])
                    {
                        a3[j]--;
                        break;
                    }
            }
        }
        printf("%d\n%d\n",mi,ma);
    }
    return 0;
}

                                                                 C. Alyona and Spreadsheet

   这题仔细思考其实也很简单，开始没有明确给出n和m的范围让我很是迷茫，不过就是没有给出所以促使我去寻找优化的方案，那就是滚动数组。

   题意：n行m列的格子，每个格子里都有一个数，如果有一列的元素都非递减，那么就称这列为非递减列。现在给你l和r求l行到r行之间的这m列是否存在非递减列。

  思路：如果只有一列我们就相当于求连续非递减子序列最大长度，但有m列我们可以就用一个数组b来分别表示这m列的最长非递减子序列长度，注意b[i]表示第i列的当前最长，如果不满足非递减了直接将b[i]赋为1，每一行中都找一个最大b[i]然后用数组v存起来，v[i]就表示到第i行为止最长的。因为题目描述的是存在，所以我们只要求出最长的然后存起来就行了，如果l到r之间有某一列非递减，那么v[r]肯定大于等于这个区间长度。那么不好开数组怎么判断当前行与上一行的大小情况呢，注意我们只判断当前行与上一行，所以第一维设为2即可，然后判断完毕将当前行复制给上一行即可。

int a[2][N],b[2][N],v[N];
int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        memset(b,0,sizeof(b));
        for(int i=1; i<=m; i++) b[1][i]=1;//b数组开一维的就行了
        v[1]=1;//存到当前行的最长的递增：
        for(int i=1; i<=n; i++)
        {
            int ma=1;
            for(int j=1; j<=m; j++)
            {
                scanf("%d",&a[1][j]);
                if(i>1)
                {
                    if(a[1][j]<a[0][j]) b[1][j]=1;
                    else b[1][j]++;
                    ma=max(ma,b[1][j]);//找到到当前行最长的
                }
            }
            for(int j=1; j<=m; j++)
                a[0][j]=a[1][j];//滚动数组，哈哈
            v[i]=ma;
        }
//        for(int i=1; i<=n; i++) printf("%d ",v[i]);
//        puts("");
        int l,r;
        scanf("%d",&m);
        while(m--)
        {
            scanf("%d%d",&l,&r);
            if(v[r]>=r-l+1) puts("Yes");
            else puts("No");
        }
    }
    return 0;
}

                                                              D. Cloud of Hashtags

   这个题也是很水的啊，只是题意花了点时间理解，然后样例也没有完全明白就直接写代码。就差两分钟又可以AC一道题啊~~

   题意：有n的标签，现在要你不改变顺序的前提下使其变为字典序依次从小到大。

   思路：其实明白了样例此题极水啊，最后一行不用变，我们秒想到从后往前推即可，用排在后面的给前面的作为参照，只要后面的有个字母比前面的大直接break，如果后面的某个字母比前面的小那么只能砍掉前面的了。字典序比较原则题目已经给出了。就看你代码实现了。

string s[N],s1[N];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0; i<n; i++)
        cin>>s[i];
    for(int i=n-1; i>=0; i--)
    {
        s1[i]=s[i];
        int len1=s[i].size();
        if(i-1>=0)
        {
            int len2=s[i-1].size();
            for(int j=0; j<=len1&&j<=len2; j++)
            {
                if(s[i][j]<s[i-1][j])
                    break;
                if(s[i][j]>s[i-1][j]) break;
            }
        }
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;s1[i][j]!='\0';j++)
            cout<<s1[i][j];
        cout<<endl;
    }
    return 0;
}

  咸鱼未能翻身成功，就算涨了几分终究无法回到1500+。。

  E题貌似也不难，看这么人做了，稍后补上。

                                                E. Hanoi Factory

     贪心水题。原来这场CF是模拟+贪心专场。

    题意：汉诺塔大家都听过，现在有n个空心圆盘，每个内径a,外径b，高度c。求最高能垒多高，条件：上一层的外径必须要大于下一层的内径且小于等于下一层的外径。

    思路：很明显一个贪心思路，将所有的圆盘按外径从大到小内径也从大到小排序。然后用栈存一下，遍历一遍即可。

   这里内径为什么要从大到小呢？请看下面样例：

5
6 10 4
9 20 19
8 11 18
18 20 1
19 20 8
输出 50

排序之后：

19 20 8
18 20 1
9 20 19
8 11 18
6 10 4

50=8+1+19+18+4

而不是

9 20 19
18 20 1
19 20 8
8 11 18
6 10 4

41

struct S
{
    int a,b,h;
} f[N];
int cmp(S x,S y)//外径大且内径大的优先
{
       if(x.b!=y.b) return x.b>y.b;
       return x.a>y.a;
}
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        for(int i=0; i<n; i++) scanf("%d%d%d",&f[i].a,&f[i].b,&f[i].h);
        sort(f,f+n,cmp);
//        puts("");
//        for(int i=0;i<n;i++)
//            printf("%d %d %d\n",f[i].a,f[i].b,f[i].h);
        ll cnt=f[0].h,ma=cnt;
        stack<S>q;
        q.push(f[0]);
        for(int i=1; i<n; i++)
        {
            while(!q.empty()&&f[i].b<=q.top().a)
            {
                cnt-=q.top().h;
                q.pop();
            }
            q.push(f[i]);
            cnt+=f[i].h;
            ma=max(ma,cnt);
        }
        printf("%I64d\n",ma);
    }
    return 0;
}