QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#23832#2968. Team ChangeGeorge_Plover#AC ✓6ms4128kbC++204.8kb2022-03-19 16:59:202022-04-30 04:20:34

Judging History

你现在查看的是最新测评结果

  • [2023-08-10 23:21:45]
  • System Update: QOJ starts to keep a history of the judgings of all the submissions.
  • [2022-04-30 04:20:34]
  • 评测
  • 测评结果:AC
  • 用时:6ms
  • 内存:4128kb
  • [2022-03-19 16:59:20]
  • 提交

answer

#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define MAXN 2200
#define MAXM 110000
#define INF 1000000000
using namespace std;

int lin[MAXM],to[MAXM],pre[MAXN],head[MAXN],tot=1,dis[MAXN],flow[MAXM],S,T,n,m;
queue<int> q;
int color[MAXN];
int cov[MAXN];
void init()
{
    tot=1;
    memset(pre,0,sizeof(pre));
}
void add(int a,int b,int c)
{
    //cout<<a<<"---"<<b<<endl;
    tot++;lin[tot]=pre[a];pre[a]=tot;to[tot]=b;flow[tot]=c;
    tot++;lin[tot]=pre[b];pre[b]=tot;to[tot]=a;flow[tot]=0;
}

void dfs(int x)
{
    for(int i=pre[x];i;i=lin[i])
    {
        int v=to[i];
        if(color[v]==-1)
        {
            color[v]=color[x]^1;
            dfs(v);
        }
    }
}
bool BFS()
{
    memset(dis,-1,sizeof(dis));
    memset(head,-1,sizeof(head));
    dis[S]=0;
    q.push(S);
    while(!q.empty())
    {
        int u=q.front();q.pop();
        for(int i=pre[u];i;i=lin[i])
        {
            int v=to[i];
            if(flow[i]&&dis[v]==-1)
            {
                dis[v]=dis[u]+1;
                q.push(v);
            }
        }
    }
    return dis[T]!=-1;
}
int DFS(int u,int inflow)
{
    if(u==T||!inflow)return inflow;
    int ret=0;
    for(int i=(head[u]==-1?pre[u]:head[u]);i;i=lin[i])
    {
        int v=to[i];head[u]=i;
        if(dis[v]==dis[u]+1 && flow[i])
        {
            int dlt = DFS(v,min(inflow,flow[i]));
            flow[i]-=dlt;
            flow[i^1]+=dlt;
            inflow-=dlt;
            ret+=dlt;
            if(inflow==0)return ret;
        }
    }
    return ret;
}

int maxflow(int start)
{
    int ans=0;
    while(BFS())
        ans+=DFS(S,start);
    return ans;
}
char s[MAXN];
bool vis[MAXN];
void findcov()
{
    while(!q.empty())q.pop();
    for(int i=1;i<=2*n;i++)
        if(cov[i]==1)
        {
            q.push(i);
            vis[i]=1;
        }
    while(!q.empty())
    {
       
        int u=q.front();q.pop(); //assert(cov[u]!=-1);
        for(int i=pre[u];i;i=lin[i])
        {
            int v=to[i];
            if(v!=S && v!=T && !vis[v])
            {
                vis[v]=1;
                for(int j=pre[v];j;j=lin[j])
                {
                    if(flow[j] && !vis[to[j]])
                    {
                        vis[to[j]]=1;
                        cov[to[j]]=1;
                        q.push(to[j]);
                    }
                }
                cov[v]=0;
            }
        }
    }
}
int main()
{
    init();
    memset(color,-1,sizeof(color));
    scanf("%d%d",&n,&m);
    scanf("%s",s);
    scanf("%s",s+1);
    for(int i=1;i<=m;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        if(s[x]=='?' && s[y]=='?')
        {
            add(x,y,1);
            add(x+n,y+n,1);
        }
        if(s[x]=='?' && s[y]=='A')
        {
            add(x,y,1);
        }
        if(s[x]=='?' && s[y]=='B')
        {
            add(x+n,y,1);
        }
        if(s[x]=='A' && s[y]=='A')
        {
            add(x,y,1);
        }
        if(s[x]=='B' && s[y]=='B')
        {
            add(x,y,1);
        }
        if(s[y]=='?' && s[x]=='A')
        {
            add(x,y,1);
        }
        if(s[y]=='?' && s[x]=='B')
        {
            add(x,y+n,1);
        }
    }
    int cnt=0;
    for(int i=1;i<=n;i++)
        if(s[i]=='?')
        {
            add(i,i+n,1);
            cnt++;
        }

    for(int i=1;i<=n*2;i++)
        if(color[i]==-1)
        {
            color[i]=0;
            dfs(i);
        }
    S=n*2+1;T=S+1;
    for(int i=1;i<=2*n;i++)
        for(int j=pre[i];j;j=lin[j])
        {
            int v=to[j];
            if(!color[i] && !flow[j])
            {
                swap(flow[j],flow[j^1]);
            }
        }
    for(int i=1;i<=n*2;i++)
        if(!color[i])
            add(S,i,1);
        else
            add(i,T,1);
    
    //cout<<
    maxflow(INF);//<<endl;
    memset(cov,-1,sizeof(cov));
    for(int i=1;i<=n*2;i++)
    {
        for(int j=pre[i];j;j=lin[j])
        {
            int v=to[j];
            if(v==S && flow[j^1])
            {
                cov[i]=1;
                break;
            }
        }
    }

    findcov();
    for(int i=1;i<=2*n;i++)
    {
        if(cov[i]==-1)
        {
            cov[i]=color[i];
        }
    }
    
    for(int i=1;i<=2*n;i++)
    {
        //if(cov[i]==-1)cov[i]=0;
        cov[i]^=1;
        //cout<<cov[i]<<" ";
    }//cout<<endl;
    for(int i=1;i<=n;i++)
    {
        if(s[i]=='?')
        {
            if(cov[i]&&cov[i+n])putchar('X');
            else if(cov[i])putchar('B');
            else putchar('A');
        }
        else if(cov[i])putchar('X');
        else putchar(s[i]);
    }putchar('\n');

    return 0;
}

Details

Tip: Click on the bar to expand more detailed information

Test #1:

score: 100
Accepted
time: 3ms
memory: 3728kb

input:

5 4
AAABB
??AAA
1 4
2 4
3 4
3 5

output:

BBXAA

result:

ok good plan

Test #2:

score: 0
Accepted
time: 4ms
memory: 3708kb

input:

2 1
AB
AA
1 2

output:

XA

result:

ok good plan

Test #3:

score: 0
Accepted
time: 1ms
memory: 3808kb

input:

8 8
ABBABAAA
?B?ABBAB
1 2
4 3
6 5
4 5
1 5
2 8
3 7
2 4

output:

BXBAXBAB

result:

ok good plan

Test #4:

score: 0
Accepted
time: 2ms
memory: 4064kb

input:

200 10000
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA...

output:

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

result:

ok good plan

Test #5:

score: 0
Accepted
time: 1ms
memory: 3688kb

input:

200 10000
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB...

output:

BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

result:

ok good plan

Test #6:

score: 0
Accepted
time: 4ms
memory: 4000kb

input:

200 10000
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB...

output:

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXBABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABA

result:

ok good plan

Test #7:

score: 0
Accepted
time: 5ms
memory: 3804kb

input:

200 10000
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
AAABAABBBBBBABBBABABBABBAABAABBABBABAAABBAAAAABBAAAABBAABAAAAABABAABABBABABBABBBABABAABAB...

output:

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXABBAAAAABBBABABBABAABBAABBAAAAAABBBBAABBABABABABBABBAAABBAAAAABABAAABBABAAABBBAABABABBBBABABBABAAAAB

result:

ok good plan

Test #8:

score: 0
Accepted
time: 5ms
memory: 3824kb

input:

200 10000
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
A?B?ABBA??A?B?AB?A?B?AA?B??BAAAB??BABBA???AABABBBBAAB?B?AABBBB?BBABAB?AB?AAABAB?AB??B?A?A...

output:

AAXAAXXAAAAAXAAXAAAXAAAAXAAXAAAXAAXAXXAAAAAAXAXXXXAAXAXAAAXXXXAXXAXAXAAXAAAAXAXAAXAAXAAAAXAXAXAAAAAAXBBXBBBBXBXBBXBXBXBXXBBBXXBBBXBBBBBBBBBBXXXBBBBBBXBBBBBBXBXXBXBBBBBBXBBBBXBBBBBBXXBBBBBBBXBXBXBXXXXB

result:

ok good plan

Test #9:

score: 0
Accepted
time: 0ms
memory: 3820kb

input:

1 0
A
A

output:

A

result:

ok good plan

Test #10:

score: 0
Accepted
time: 3ms
memory: 3684kb

input:

2 1
BA
BB
1 2

output:

XB

result:

ok good plan

Test #11:

score: 0
Accepted
time: 3ms
memory: 3776kb

input:

2 0
AA
BA

output:

BA

result:

ok good plan

Test #12:

score: 0
Accepted
time: 3ms
memory: 3680kb

input:

2 0
AB
B?

output:

BB

result:

ok good plan

Test #13:

score: 0
Accepted
time: 3ms
memory: 3816kb

input:

2 1
AB
B?
1 2

output:

BA

result:

ok good plan

Test #14:

score: 0
Accepted
time: 3ms
memory: 3744kb

input:

1 0
A
B

output:

B

result:

ok good plan

Test #15:

score: 0
Accepted
time: 2ms
memory: 3824kb

input:

1 0
A
?

output:

B

result:

ok good plan

Test #16:

score: 0
Accepted
time: 1ms
memory: 3684kb

input:

1 0
B
A

output:

A

result:

ok good plan

Test #17:

score: 0
Accepted
time: 1ms
memory: 3684kb

input:

1 0
B
B

output:

B

result:

ok good plan

Test #18:

score: 0
Accepted
time: 3ms
memory: 3828kb

input:

1 0
B
?

output:

B

result:

ok good plan

Test #19:

score: 0
Accepted
time: 3ms
memory: 3676kb

input:

2 0
AB
BA

output:

BA

result:

ok good plan

Test #20:

score: 0
Accepted
time: 3ms
memory: 3824kb

input:

2 1
AB
AB
1 2

output:

AB

result:

ok good plan

Test #21:

score: 0
Accepted
time: 2ms
memory: 3816kb

input:

2 1
AB
BA
1 2

output:

BA

result:

ok good plan

Test #22:

score: 0
Accepted
time: 1ms
memory: 3908kb

input:

1000 1000
ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB...

output:

XAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXAXA...

result:

ok good plan

Test #23:

score: 0
Accepted
time: 1ms
memory: 3780kb

input:

1000 1000
ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB...

output:

BXBABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABA...

result:

ok good plan

Test #24:

score: 0
Accepted
time: 3ms
memory: 3732kb

input:

1000 1000
ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB...

output:

BABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABA...

result:

ok good plan

Test #25:

score: 0
Accepted
time: 1ms
memory: 3736kb

input:

1000 1000
ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB...

output:

XBAXBXBXBXABXABABXAXBABXBABXBAXABAXBABAXAXABXAXBAXBABAXBAXBABXAXAXBXAXAXAXBXABXBXBABAXBAXABXABAXBXAXAXAXAXABABXAXAXABAXABABAXABXBXABXABABXBAXAXAXBABXAXBXBXBXABABABXAXBXBABXBAXABAXABXBAXBXABABAXBXAXBXBABXAXABXBXAXAXAXAXBXAXBXAXBABABXABXAXABXBAXBXBXAXBAXAXBXBABXABXABXBABABXABXABXBXBXAXBXBABAXBAXBXABXA...

result:

ok good plan

Test #26:

score: 0
Accepted
time: 4ms
memory: 3892kb

input:

1000 1000
ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB...

output:

ABABABXAXBABABABXBAXBXBABAXABABABABXBABABXABXBABAXABABABABABXBXBABAXBABABXXABXABABABXBXXABABAXXBABABXBABXABABABABXABABABABAXABABABXBXBABABABABABXBABABAXABXBABAXBABXBAXABXBAXABABABABAXBXABXBABAXBAXAXABABABABAXABABABABAXABABAXBABXBABABAXABAXABABXABXBAXBABXBAXBABABXAXABABABXBABAXABXABAXBAXAXBABXBXABABA...

result:

ok good plan

Test #27:

score: 0
Accepted
time: 3ms
memory: 3884kb

input:

1000 0
BABAAABBBAABBBAABAAAAAABAAABBBBBBAAAAAAAAAABBBBABAABBBABABBBABBBBBABBABBAABAAAAABBAABABBBABBBBBABABAABBBBBAABBBBAAAABBBBABBABBABBBBABABABBBBABAABAAABBBABAABBAABABABAAAABBBABBBBBAAABABBAAAAABAABBBABBAABBBBABAAAABAAAAAAAAABBABBBAAABBBABBABABBAAAAABAABBBBBABBBABABABBABBBBABAAABBAABAABBAABBABAABB...

output:

ABBBBAABBAAABBBBAAABBABABBBBABBABBBABBABABBBBBBBBABBBABBBBAABBBBBBBBBAAABAAAABBBAABBBABAABBBBBBBBBABBABBABBBBBAABABBBBAABBBBAABBBBBBAABBAAAAABBABBABBBBABBABABABBBBBABBBBBBBABAABBBAABABABABABBBBBBABABAABABABAABABBBBBBBBBBBBBAABBBBBABBBBBAAABBBBBABBABBABBABABBBBABBABBBAABBBABBBBABBBBBBBBBAABBAABABBABB...

result:

ok good plan

Test #28:

score: 0
Accepted
time: 2ms
memory: 4020kb

input:

1000 10000
ABAABBAAAABAABBBABABBABBBABBBBBBAABAAABBBBBABBAABBAAAAABBAABBBBABBBBAAABAAAABABBBBABBABAAABBBABBABAABBAABABBABAAAABABBABAABBBBBAAAAAAABAABABBABAAAAABBBBBABAABBAABBBABBBABBBBAABABABAAABAAABBABBABBBAAABBBBAABBAABABBBABBAAAABBAAABBAAAABBABBBABBBAABBBBAAAABAABABAAAAAABBBBBBBABBABBBBAAAABAAAAB...

output:

XXAAXBAAAABAXBXXAXABBAXXBXBXBBBBAXBAAABBXBBXXBAAXBXAXAXXXAABBBXXBBBXAXABAAAAXXBBBBAXXXBAAABXBABBXBAABBXXBXBBXXAXAABAXXABXABBBBBXAAAAXABXABXXBXXAXAXABBBBXABAABXAABBBAXBBXXBBBXXBABXBAAABAXABBABBAXBXAAXBBXBAAXBXABABBXXXXAXAABBXAABXAXAXBBXBXBAXXBAAXBBXXAAXXAAXAXAAXAAABBBBXBXXXXABBBXAAXABXAAAXBBBBBAABBBB...

result:

ok good plan

Test #29:

score: 0
Accepted
time: 5ms
memory: 4128kb

input:

1000 10000
BAAABBBBAAABBBBAABABBABBBBBAAAABABABBBABAAABBABABBBABAABABBAABABAAABBAABBABBBBBBBBBBBBBABAAAABABBBBAAAABBABABABBAABAAABABBBAAAABBBAAABBBBBAAAAAABABBBBBBAABABBABAAABBABAAAAABBBBBBBABBAAAAABABBBAAABAABBBAABABBBBBBBABAABABABAAAAABBBBAABAAAABBBBAAAAABABBBABABBABBAAABBBABABABBABAAAAABBABAAABBB...

output:

BAAXBBXXAXABBXXAABXXXABBBBBAXAXXABABXXAXXXABXABAXBXAXAABABBAABAXXAAXBXABBABBXBBBBBBXBBXABXXXAXABBBBAAAXXBXBABXBBAAXAAABABBBXAAAXBBAAABBBXXXXAXAABABBBBBBAABXBBXXAAXXBABXXAXABXBXXXBABXAAAXABAXXBAAXBAXXXBAAXABBBXBBBABAXBXBABXAAAABBBBAABAXAABXBXAAXAABXBBBABAXBABXAXAXBXABABXBBXBAAAAXXXABXAAXXBBAAXXABAAAX...

result:

ok good plan

Test #30:

score: 0
Accepted
time: 3ms
memory: 3956kb

input:

1000 10000
AAABABBBAABABBBBBBABBABAABBBAABBAAAAAAAABABBAABBAAABBAAAAAABBBAABAABBABAABAAABBAABABBBBBBBBAABABBABBBBABABBBAAAAABAABAAABBABAAABAAABBBAAABABBBBBBAABAABABABAABABABABAABAAABABBABBAABBAABBAAABABAABBAAAAABBBAAABBABBBABAABAAAAABABBBABBBBABAAABABBBBAABAABBBAAABAAABAABAAAABBBAAAABAABAAABBAABBBBA...

output:

XXBAXXAXBXXBAAXAXXXAABAXBAXABBXXBXBBBBBBABAABBAXBBXAAXBBBBXAXABBAXBXABABBAXXBAABXXBXAXXAAAABXABAABAAXXBXXAAABBBBBABBAXXBAXBABBBXBBBAAAXBBABAAAXAXBXABBABXBXXBABXBXBAXBXXBBXBAXBXABBAABBAABXBAXABXXXBBXBBAXAXBBXABXAABABBABBBXXXXAXAXAAAABABXXABXXAXBBABBAXXBBBAXXBABBAXBBXAAABXBXXBBAXXBXXBBAXXXBAXBAAXBBBAA...

result:

ok good plan

Test #31:

score: 0
Accepted
time: 6ms
memory: 4020kb

input:

1000 10000
BBAAAABAAAABAABAABABAAAAABABBABBABABBAAABBABBBBAAAAABAAAABBABBBBAAABBBBBBBAAABAAABABAABBBABABABAABAAABBBBABBBBAAAABBAAABABABABBBABBABBBAAABABABABABAABBABBBABBAAAAAABBAAABABBBABAAAABBBBBBBBABAABBBBAABBBBBBAABBABBAABABBABAAABABBABBBBABBBBABBABAABBABBBBBBBABABABAAAABBBBBBAABBBBBABBABAABABBBB...

output:

AXXXBXABXBBAXBABBAXABXBXXAXXXBAAXABAABXXXAXAAXABBBXXXBBBBXABAXAAXBXXAXXAXABBBAXBXABXXBXAXBABABXBBABXBAAAAXAXAXBBXBAABBXXXAXXBAAABAABAXXBBBAXXXXXABXBBAABAAABAXXBXXBBAABBXABAAXXABBBBAXAXXAXXXXBBXXAAXBXAAXXABXAABXAXBAXAAXAXXXABXXXAAAAXAXAAXXABABBAXBXAAAAXABABABXXBXBAAXAAXBBAAAAAXAXBABBABXAXAXXAAABABBXB...

result:

ok good plan

Test #32:

score: 0
Accepted
time: 3ms
memory: 3964kb

input:

1000 10000
AABAABBABBBAABAABABBAAAAAABAABABBAABAAAABBAABAABBBABBAABAABAABABBAABBABBAABAABBAABBAAAAAABAABBBBABABBBBABBBAAABBAAABBABBBAABBBBAABAAAAABBBBBABAABAABBABBBBBAAAABBAABAAAABBBABBAAAAABAAAABBAAAAABBAAABBABAABBBBBBABBABBABBAABABAABAAAABBBBAAAABBABBABBABBAAABAAAABBABABABBBBAABABBAAAABBAABABAAABB...

output:

XABAXBBABBXXAXAABXBBAAXXAABAABAXBAAXAAAXBBAAXAABXBAXBXXXXABAABXBXXABBXBXAAXAAXBAXXBAAAAAABAXBBXBXBABXBBXBBXAAABXAXXXBABXBAABBBBXABXAAAXBXBBBABAABXXBBABXBBXAAXABBAABXAAABXBABXAAAAXBAAAXBXAAXXAXBAAABBXBXXBBBBBBXXBAXBABXAAXAXXAXAAXABXBBAAAABBXBBAXBABXXXABAAAABXXBAXABBXXXABXBXXAAABBAXBXXAXABBBXXABXABXXX...

result:

ok good plan

Test #33:

score: 0
Accepted
time: 3ms
memory: 3760kb

input:

1000 999
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB...

output:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA...

result:

ok good plan

Test #34:

score: 0
Accepted
time: 0ms
memory: 3744kb

input:

1000 999
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB...

output:

BBAAAAAABAABBBBAABBBBBBBAAAAABBABAABAABBAAABBBAABAABBBAAAABABBABBAXBBABAAABBABBBBAABAAAABAABBBABBBAABAABABBABABABAAABAABAAAABABBABBAABBABAABBBAAABAABABBABBAABBABABBAAABABBBAAABABBBABBBBABBAAABBAAABAAABABBAABBBBBBAABAAAABAABAAABAAAAABABAABABBABBAAAAAAABBBBBBBAAAAAAABABABAABBBBBAABABBBBBABBBBBBBBAABAB...

result:

ok good plan

Test #35:

score: 0
Accepted
time: 3ms
memory: 3896kb

input:

1000 999
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB...

output:

BBAABBBBBAABBBBBAABAABABABBBBBBBBAABABBBBBBAABBBBBBBBAAABBBBBBBBABXBBABBBBBBABBBBBBBBBBBBBBBBABABBBBABABABABBAABAAABAABAABBBBBBABBBBBAABAABABBBBBBBABBBBAABBBABBBBABABAAABABBAAABAABABBABAABBAAABABBAAABBAABBBBBABAABBBBAABBABBAABBBBBBBBBBBABBAABBBBBBBBAAAABBBBABAAABBBBABBAAABBBBABABBABBBABABBBABBABBBBA...

result:

ok good plan