CCPC2018-湖南全国邀请赛 G String Transformation

String Transformation

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 36    Accepted Submission(s):
8

Problem Description

Bobo has a string S=s1s2…sn

consists of letter `a`, `b` and `c`.
He can transform the string by
inserting or deleting substrings `aa`, `bb` and `abab`.

Formally, A=u°w°v

(``°

‘‘ denotes string concatenation) can be transformed into A=u°v

and vice versa where u

, v

are (possibly empty) strings and w∈{aa,bb,abab}

.

Given the target string T=t1t2…tm

, determine if Bobo can transform the string S

into T

.

Input

The input consists of several test cases and is
terminated by end-of-file.

The first line of each test case contains a
string s1s2…sn

.
The second line contains a string t1t2…tm

.

Output

For each test case, print `Yes` if Bobo can. Print `No`
otherwise.

## Constraint

* 1≤n,m≤104

* s1,s2,…,sn,t1,t2,…,tm∈{a,b,c}

* The sum of n

and m

does not exceed 250,000

.

Sample Input

ab
ba
ac
ca
a
ab

Sample Output

Yes
No
No

Hint

For the first sample, Bobo can transform as `ab => aababb => babb => ba`.

Source

CCPC2018-湖南全国邀请赛-重现赛(感谢湘潭大学)

     麻烦的模拟题,不管多麻烦的ababa的式子(不含c时)最终只会化成三种形式:a,b,ab(或ba),题目中插入删除abab的意义所在就是告诉我们ab能够转化成ba

    我的思路:将两个式子化解成最优。

eg:abaabcaacabc  化简 accabc,化简使用队列,边放进去边判,队末尾是a,要放的也是a,那就pop(a)

        ababaccbac      化简 accbac

然后在从队首把他们取出来进行比较,特判一下ab和ba是一样的。

#include <iostream>
#include<cstring>
#include<string>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<deque>
#define ll long long
using namespace std;
char a[10005];
char b[10005];
deque<int>q1,q2;
int main()
{
    while(cin>>a>>b)
    {
        while(!q1.empty ()) q1.pop_back();
        while(!q2.empty ()) q2.pop_back();
        int la=strlen(a);
        int lb=strlen(b);
        int c1=0;
        int c2=0;
        for(int i=0;i<la;i++)
        {
            if(a[i]==‘c‘)
            {
                q1.push_back(3);
                c1++;
            }
            else if(a[i]==‘a‘)
            {
                if(q1.empty ())
                {
                    q1.push_back(1);
                    continue;
                }
                if(q1.back()==1)
                {
                    q1.pop_back();
                }
                else if(q1.back()==2)
                {
                    if(i<la-1&&a[i+1]==‘b‘)
                    {
                        q1.pop_back();
                        i++;
                        if(q1.empty ()||q1.back ()!=1)
                        {
                            q1.push_back (1);
                        }
                        else if(q1.back ()==1)
                        {
                            q1.pop_back();
                        }

                    }
                    else q1.push_back (1);
                }
                else q1.push_back (1);

            }
            else if(a[i]==‘b‘)
            {
                if(q1.empty ())
                {
                    q1.push_back(2);
                    continue;
                }
                if(q1.back()==2)
                {
                    q1.pop_back();
                }
                else if(q1.back()==1)
                {
                    if(i<la-1&&a[i+1]==‘a‘)
                    {
                        q1.pop_back();
                        i++;
                        if(q1.empty ()||q1.back ()!=2)
                        {
                            q1.push_back (2);
                        }
                        else if(q1.back ()==2)
                        {
                            q1.pop_back();
                        }

                    }
                    else q1.push_back(2);
                }
                else q1.push_back(2);
            }
        }
        for(int i=0;i<lb;i++)
        {
            if(b[i]==‘c‘)
            {
                q2.push_back(3);
                c2++;
            }
            else if(b[i]==‘a‘)
            {
                if(q2.empty ())
                {
                    q2.push_back(1);
                    continue;
                }
                if(q2.back()==1)
                {
                    q2.pop_back();
                }
                else if(q2.back()==2)
                {
                    if(i<lb-1&&b[i+1]==‘b‘)
                    {
                        q2.pop_back();
                        i++;
                        if(q2.empty ()||q2.back ()!=1)
                        {
                            q2.push_back (1);
                        }
                        else if(q2.back ()==1)
                        {
                            q2.pop_back();
                        }

                    }
                    else q2.push_back (1);
                }
                else q2.push_back (1);

            }
            else if(b[i]==‘b‘)
            {
                if(q2.empty ())
                {
                    q2.push_back(2);
                    continue;
                }
                if(q2.back()==2)
                {
                    q2.pop_back();
                }
                else if(q2.back()==1)
                {
                    if(i<lb-1&&b[i+1]==‘a‘)
                    {
                        q2.pop_back();
                        i++;
                        if(q2.empty ()||q2.back ()!=2)
                        {
                            q2.push_back (2);
                        }
                        else if(q2.back ()==2)
                        {
                            q2.pop_back();
                        }
                    }
                    else q2.push_back(2);

                }
                else q2.push_back(2);
            }
        }
        bool f=1;
        if(c1!=c2||q1.size()!=q2.size()) f=0;
        else
        {
            while(!q1.empty ())
            {
                if(q1.front() ==1&&q2.front() ==2)
                {
                    q1.pop_front ();
                    q2.pop_front ();
                    if(q1.empty ())
                    {
                        f=0;
                        break;
                    }
                    else if(q1.front() ==2&&q2.front() ==1)
                    {
                        q1.pop_front ();
                        q2.pop_front ();
                    }
                    else
                    {
                        f=0;
                        break;
                    }
                }
                else if(q1.front() ==2&&q2.front() ==1)
                {
                    q1.pop_front ();
                    q2.pop_front ();
                    if(q1.empty ())
                    {
                        f=0;
                        break;
                    }
                    else if(q1.front() ==1&&q2.front() ==2)
                    {
                        q1.pop_front ();
                        q2.pop_front ();
                    }
                    else
                    {
                        f=0;
                        break;
                    }
                }
                else if(q1.front()==q2.front ())
                {
                    q1.pop_front();
                    q2.pop_front();
                }
                else
                {
                    f=0;
                    break;
                }
            }
        }
        if(f) printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}

原文地址:https://www.cnblogs.com/caiyishuai/p/9062114.html

时间: 2024-11-08 21:47:23

CCPC2018-湖南全国邀请赛 G String Transformation的相关文章

hdu - 6276,2018CCPC湖南全国邀请赛A题,水题,二分

题意: 求H的最大值,  H是指存在H篇论文,这H篇被引用的次数都大于等于H次. 思路:题意得,  最多只有N遍论文,所以H的最大值为N, 常识得知H的最小值为0. 所以H的答案在[0,N]之间,二分搜一下,如果满足就提高下限,不满足则降低上限. 嗯就这样!!!! AC code: #include<bits/stdc++.h> using namespace std; int n; vector<int> cc(200005); int main() { bool check(i

[Training]CCPC2018-湖南全国邀请赛

Rank Solved A B C D E F G H I J K --/-- 8/11 O O O . O O O . . O O O: 当场通过 ?: 赛后通过 .: 尚未通过 A Easy h-index solved by chelly chelly's solution 签到 B Higher h-index solved by chelly&ch chelly's solution 最优策略是分成n个部分,每个都是1 C Just h-index solved by chelly c

CCPC2018-湖南全国邀请赛

传送门 A - Easy \(h\)-index 签到. Code /* * Author: heyuhhh * Created Time: 2019/10/29 11:58:23 */ #include <bits/stdc++.h> #define MP make_pair #define fi first #define se second #define sz(x) (int)(x).size() #define all(x) (x).begin(), (x).end() #defin

2013 ACM-ICPC南京赛区全国邀请赛

题目链接:http://acm.hdu.edu.cn/search.php?field=problem&key=2013 ACM-ICPC南京赛区全国邀请赛--题目重现&source=1&searchmode=source A(HDU4586) Play the Dice Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Total Submission(s): 1

2013ACM-ICPC杭州赛区全国邀请赛——Random Walk

题目链接 题意: n个点,按照题中给的公式可以求出任意两个点转移的概率.求从1到n的期望转移次数 分析: 设dp[i]为从i到n的期望,那么可以得到公式dp[i] = sigma(dp[i + j] * p(i + j, i)),1 <= j <= m 把这个式子展开来:dp[i - m] * p(i - m, i) + dp[i - m + 1] * dp(i - m + 1, i) + ... + dp[i] * p(i, i) + ... + dp[i + m] * p(i + m, i

2013 ACM-ICPC长沙赛区全国邀请赛——Travel in time

题目链接 题意: 给n个点,m条边的无向图,一个起点和一个终点.每边都有消耗,经过就要付出代价:每个点有消耗和价值,只有消耗了才会获得价值,如果不消耗就不会获得价值,且下一次消耗的点的价值一定要严格大于之前消耗过的点的价值 求:起点到终点消耗不超过给定值T时的价值最大值 1 < N < 100,0 < M < 1000,0 < T <= 300 分析: 对于不进行点的消耗的操作,就是求两点的最短路,floyd求 表示一下状态: 可以粗率表示为:当前所在点.总消耗值.总价

hihocoder 1084 扩展KMP &amp;&amp; 2014 北京邀请赛 Justice String

hihocoder 1084 : http://hihocoder.com/problemset/problem/1084 北京邀请赛 Just  String http://www.bnuoj.com/v3/problem_show.php?pid=34990 两道题同样的做法,题目基本内容是找到A的字串中和B串长度一样,且不同的字符个数不超过k个的置. 以hihocoder 1084为例, 是求有多少个A的字串的,与B串长度一样,且不同的字符个数不超过k. 分析:预处理hash,然后对每个字

HDU 4573 Throw the Stones(动态三维凸包)(2013 ACM-ICPC长沙赛区全国邀请赛)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4573 Problem Description Remember our childhood? A few naked children throw stones standing on the same position, the one throws farther win the game. Aha, of course, there are some naughty boys who care

2014湘潭全国邀请赛I题 Intervals /POJ 3680 / 在限制次数下取有权区间使权最大/小问题(费用流)

先说POJ3680:给n个有权(权<10w)开区间(n<200),(区间最多数到10w)保证数轴上所有数最多被覆盖k次的情况下要求总权最大,输出最大权. 思路:       限制的处理:s-->开始流量为k,要求总权最大,即费用最大,所以费用取负,最小费用最大流即可.对于输入区间[a,b]:w,添加边:a-->b,流量为1,费用为-w. 对于点i,i+1,添加边,费用为0,流量无穷.显然这种处理,限制了区间最多取k次,(流量控制),跑最大流能走添加的边尽量走,且越大越好(负数刚刚是