长安大学15迎新杯acm题解

由于并不能参赛，所以对于题目只能提出个人理解，实际是否能ac不能保证，若有同学有不同看法，请留言。

A-预防流感的拉面女神

这道题很明显是求n最少是由几个2的次数幂组成的。
例如3能分解为2^0+2^1
4就是2^2
8就是2^3
7分解为2^0+2^1+2^2
明显是签到题

//
// main.cpp
// 长大15acm-A
//
// Created by 袁子涵 on 15/12/7.
// Copyright © 2015年 袁子涵. All rights reserved.
//

#include <iostream>
#include <stdio.h>
#include <math.h>
using namespace std;

int main(int argc, const char * argv[]) {
    long long int t,n;
    cin >> t;
    while (t--) {
        cin >> n;
        long long int tmp=1,total=0;
        while (tmp<=n)
            tmp*=2;
        while (n) {
            while (n<tmp)
                tmp/=2;
            n-=tmp;
            total++;
        }
        cout << total << endl;
    }
    return 0;
}

B-草滩小王子与打扫卫生

这个是明显的规律题，在n小于等于m时，一定是第一个人赢，当n=m+1时，一定是第二个人赢，那么在n为m+2~2m+1时，第一个人一定能拿走n-m-1个，使得剩下m+1个，回到了n=m+1的情况，那么下个人就赢不了，由此递推，当n为m+1的倍数时，第二个人赢，其他都是第一个人赢。

//
// main.cpp
// 长大15acm-B
//
// Created by 袁子涵 on 15/12/7.
// Copyright © 2015年 袁子涵. All rights reserved.
//

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
using namespace std;

int main(int argc, const char * argv[]) {
    long long int t;
    cin >> t;
    while (t--) {
        long long int n,m;
        cin >> n >> m;
        if (n%(m+1)==0)
            cout << "Bob" << endl;
        else
            cout << "Alex" << endl;
    }
    return 0;
}

C-草滩小王子与化学实验

此题其实就是个边权只能为1或0的最大生成树问题，因此直接化简为并查集来做，在录入能发生反应的试剂时，不在相同集合就把结果加一，并且合并集合。

//
// main.cpp
// 长大15acm-C
//
// Created by 袁子涵 on 15/12/7.
// Copyright © 2015年 袁子涵. All rights reserved.
//

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
#define MAXN 1000005
using namespace std;

long long int pre[MAXN],n,m;
void init()
{
    for (long long int i=1; i<=n; i++)
        pre[i]=i;
}
long long int find(long long int num)
{
    if (pre[num]!=num)
        pre[num]=find(pre[num]);
    return pre[num];
}
void join(long long int num1,long long int num2)
{
    long long int pre1=find(num1),pre2=find(num2);
    if (pre1==pre2) {
        return;
    }
    pre[pre1]=pre2;
}
int main(int argc, const char * argv[]) {
    long long int a,b,pre1,pre2,out=0;
    int t;
    cin >> t;
    while (t--) {
        out=0;
        cin >> n >> m;
        init();
        for (long long int i=1; i<=m; i++) {
            scanf("%lld%lld",&a,&b);
            pre1=find(a);
            pre2=find(b);
            if (pre1!=pre2) {
                out++;
                join(pre1, pre2);
            }
        }
        cout << out << endl;
    }
    return 0;
}

D-草滩小王子与天行健

剪枝dfs+枚举吧，算了下时间复杂度应该刚刚够。

//
// main.cpp
// 长大15acm-D
//
// Created by 袁子涵 on 15/12/7.
// Copyright © 2015年 袁子涵. All rights reserved.
//

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <algorithm>

using namespace std;
int num[6];
long long int mins,maxs,out,now;
int price[6][11];
long long int temp[100005];

void dfs(int n,int next,long long int pre)
{
    if (n>5)
        return;
    for (int i=next; i<=num[n]; i++) {
        long long int tmp=pre+price[n][i];
        if (tmp<=maxs) {
            dfs(n+1,1,tmp);
            if (next==1)
                dfs(n, i+1, tmp);
            if (n==5)
                temp[++now]=tmp;
        }
    }
}
int main(int argc, const char * argv[]) {
    int t;
    cin >> t;
    while (t--) {
        out=0;
        now=0;
        for (int i=1; i<=5; i++)
            cin >> num[i];
        for (int i=1; i<=5; i++)
            for (int j=1; j<=num[i]; j++)
                cin >> price[i][j];
        cin >> mins >> maxs;
        dfs(4, 1, 0);
        for (int i=1; i<=num[3]; i++)
            for (long long int j=1; j<=now; j++) {
                long long int tmp=price[3][i]+temp[j];
                if (tmp>=mins && tmp<=maxs)
                    out++;
            }
        for (int i=1; i<=num[1]; i++)
            for (int j=1; j<=num[2]; j++)
                for (long long int x=1; x<=now; x++) {
                    long long int tmp=price[1][i]+price[2][j]+temp[x];
                    if (tmp>=mins && tmp<=maxs)
                        out++;
                }
        cout << out << endl;
    }
    return 0;
}

E-草滩小王子与黄牛票

分治，先找最大值，最大值之前一定都是买，到了最大时卖，然后最大值之后的同理分治，直到末尾。

//
// main.cpp
// 长大15acm-E
//
// Created by 袁子涵 on 15/12/7.
// Copyright © 2015年 袁子涵. All rights reserved.
//

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <algorithm>

using namespace std;
long long int n;
long long int price[100005];
int main(int argc, const char * argv[]) {
    int t;
    cin >> t;
    while (t--) {
        long long int out=0,now=0,maxs=0,pre=0;
        cin >> n;
        for (long long int i=1; i<=n; i++) {
            scanf("%lld",&price[i]);
            if (price[i]>=maxs) {
                maxs=price[i];
                now=i;
            }
        }
        for (long long int i=1; i<=now; i++)
            out+=maxs-price[i];
        while (now!=n) {
            pre=now;
            maxs=0;
            for (long long int i=now+1; i<=n; i++) {
                if (price[i]>=maxs) {
                    maxs=price[i];
                    now=i;
                }
            }
            for (long long int i=pre+1; i<=now; i++)
                out+=maxs-price[i];
        }
        cout << out << endl;
    }
    return 0;
}

F-无奈自习的草滩小王子

从给的样例能看出每件事只能干一次，令当前效率为k，时间为t。
则成了01背包问题。
dp[i][j]存的是在选择第i个事件，剩余时间为j时，所能获得的最大效益。
由于这里非常大，正常情况下用二维会爆空间，（并不清楚比赛具体空间限制），所以用滚动数组优化空间。

//
// main.cpp
// 长大15acm-F
//
// Created by 袁子涵 on 15/12/7.
// Copyright © 2015年 袁子涵. All rights reserved.
//

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
using namespace std;
int t,n;
int a[10005],b[10005];
long long int dp[2][1005];
bool flag=1;
int main(int argc, const char * argv[]) {
    int T;
    cin >> T;
    while (T--) {
        cin >> t >> n;
        flag=1;
        memset(dp, 0, sizeof(dp));
        for (int i=1; i<=t; i++)
            dp[0][i]=t;
        long long int out=t;
        for (int i=1; i<=n; i++)
            scanf("%d%d",&a[i],&b[i]);
        for (int i=1; i<=n; i++) {
            for (int j=t-a[i]; j>=1; j--) {
                dp[flag][j]=max(dp[!flag][j],(dp[!flag][j+a[i]]/(j+a[i])+b[i])*j);
                out=max(out,dp[flag][j]);
            }
            flag=!flag;
        }
        cout << out << endl;
    }
    return 0;
}

G-拉面女神的生日派对

先将所有蛋糕加起来，除以n得商，这是可能的最大蛋糕大小，然后依次与每一块的蛋糕相除求商，所有商之和大于等于人数即可，小于人数的话，进行二分继续查找。

//
// main.cpp
// 长大15acm-G
//
// Created by 袁子涵 on 15/12/7.
// Copyright © 2015年 袁子涵. All rights reserved.
//

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
using namespace std;
long long int n,m,c[20005],mins,maxs;
int main(int argc, const char * argv[]) {
    int T;
    cin >> T;
    while (T--) {
        mins=0;
        cin >> n >> m;
        long long int sum=0,re,total=0;
        for (long long int i=1; i<=m; i++)
        {
            scanf("%lld",&c[i]);
            sum+=c[i];
        }
        re=sum/n;
        if (re==0) {
            cout << 0 << endl;
            continue;
        }
        maxs=re;
        for (long long int i=1; i<=m; i++)
            total+=c[i]/re;
        while (1) {
            total=0;
            if (mins==maxs-1) {
                for (long long int i=1; i<=m; i++) {
                    total+=c[i]/maxs;
                }
                if (total>=n) {
                    re=maxs;
                    break;
                }
                else
                {
                    re=mins;
                    break;
                }
            }
            re=(maxs+mins)/2;
            for (long long int i=1; i<=m; i++)
                total+=c[i]/re;
            if (total>=n) {
                mins=re;
            }
            else
                maxs=re;
        }
        cout << re << endl;
    }
    return 0;
}

H-拉面女神的魔盒

有起点有终点，用双向BFS跑了一发，也不知对不对，花了点时间把99w组数据都跑了一次，应该没啥大问题。

//
// main.cpp
// 长大15acm-H
//
// Created by 袁子涵 on 15/12/8.
// Copyright © 2015年 袁子涵. All rights reserved.
//

#include <iostream>
#include <cstring>
#include <cstdio>
#include <map>
#include <vector>
#include <cmath>
#include <iomanip>
#include <algorithm>
#include <queue>
using namespace std;

struct VIS{
    int flag;
    int step;
}vis[1000001];

int dis[2] = {1, -1};

struct num{
    int n[6];
    int step;
    friend bool operator <(num a, num b)
    {
        return a.step < b.step;
    }
};

int ans[6];
int init[6];
int total(num a){
    int i, sum;
    sum = 0;
    for(i = 0; i < 6; i ++)
        sum = sum * 10 + a.n[i];
    return sum;
}

int bfs(void){
    memset(vis, 0, sizeof(vis));
    queue<num> q;
    queue<num> p;
    num pre, lst;
    int i, t,  sp = 0;
    long sum;

    for(i = 0; i < 6; i ++)
        pre.n[i] = init[i];
    sum = total(pre);
    vis[sum].flag = 1;
    vis[sum].step = 0;
    pre.step = 0;
    q.push(pre);

    for(i = 0; i < 6; i ++)
        lst.n[i] = ans[i];
    sum = total(lst);
    vis[sum].flag = 2;
    vis[sum].step = 0;
    lst.step = 0;
    p.push(lst);

    while(!q.empty() && !p.empty()){
        while(q.front().step == sp){
            pre = q.front();
            q.pop();
            for(i = 0; i < 6; i ++){
                if(i == 0){
                    for(t = 0; t < 2; t ++){
                        lst = pre;
                        lst.n[0] = pre.n[0] + dis[t];
                        if(lst.n[i] < 0)
                            lst.n[i] += 10;
                        else if(lst.n[i] >= 10)
                            lst.n[i] -= 10;
                        sum = total(lst);
                        lst.step = pre.step + 1;
                        if(vis[sum].flag == 1)
                            continue;
                        if(vis[sum].flag == 2)
                            return lst.step + vis[sum].step;
                        vis[sum].flag = 1;
                        vis[sum].step = lst.step;
                        q.push(lst);
                    }
                }
                else if(i == 1){
                    int temp = 0;
                    for(int j = 0; j < 6; j ++){
                        if(pre.n[j] % 2)
                            temp ++;
                        else
                            temp --;
                    }
                    if(temp != 0)
                        continue;
                    for(t = 0; t < 2; t ++){
                        lst = pre;
                        lst.n[1] = pre.n[1] + dis[t];
                        if(lst.n[i] < 0)
                            lst.n[i] += 10;
                        else if(lst.n[i] >= 10)
                            lst.n[i] -= 10;
                        sum = total(lst);
                        lst.step = pre.step + 1;
                        if(vis[sum].flag == 1)
                            continue;
                        if(vis[sum].flag == 2)
                            return lst.step + vis[sum].step;
                        vis[sum].flag = 1;
                        vis[sum].step = lst.step;
                        q.push(lst);
                    }
                }
                else if(i == 2){
                    lst = pre;
                    lst.n[2] = pre.n[2] + 7;
                    if(lst.n[i] < 0)
                        lst.n[i] += 10;
                    else if(lst.n[i] >= 10)
                        lst.n[i] -= 10;
                    sum = total(lst);
                    lst. step = pre.step + 1;
                    if(vis[sum].flag == 1)
                        continue;
                    if(vis[sum].flag == 2)
                        return lst.step + vis[sum].step;
                    vis[sum].flag = 1;
                    vis[sum].step = lst.step;
                    q.push(lst);
                }
                else if(i == 3){
                    lst = pre;
                    int temp = 0;
                    for(int j=0; j<6; j++)
                        temp += lst.n[j];
                    temp = temp % 9 + 1;
                    lst.n[3] = pre.n[3] + temp;
                    if(lst.n[i] < 0)
                        lst.n[i] += 10;
                    else if(lst.n[i] >= 10)
                        lst.n[i] -= 10;
                    sum = total(lst);
                    lst. step = pre.step + 1;
                    if(vis[sum].flag == 1)
                        continue;
                    if(vis[sum].flag == 2)
                        return lst.step + vis[sum].step;
                    vis[sum].flag = 1;
                    vis[sum].step = lst.step;
                    q.push(lst);
                }
                else if(i == 4 && (pre.n[0] + pre.n[2] + pre.n[4] == 9)){
                    for(t = 0; t < 2; t ++){
                        lst = pre;
                        lst.n[4] = pre.n[4] + dis[t];
                        if(lst.n[i] < 0)
                            lst.n[i] += 10;
                        else if(lst.n[i] >= 10)
                            lst.n[i] -= 10;
                        sum = total(lst);
                        lst.step = pre.step + 1;
                        if(vis[sum].flag == 1)
                            continue;
                        if(vis[sum].flag == 2)
                            return lst.step + vis[sum].step;
                        vis[sum].flag = 1;
                        vis[sum].step = lst.step;
                        q.push(lst);
                    }
                }
                else if(i == 5 && pre.n[1] == 0){
                    lst = pre;
                    lst.n[5] = pre.n[5] - 3;
                    if(lst.n[i] < 0)
                        lst.n[i] += 10;
                    else if(lst.n[i] >= 10)
                        lst.n[i] -= 10;
                    sum = total(lst);
                    lst. step = pre.step + 1;
                    if(vis[sum].flag == 1)
                        continue;
                    if(vis[sum].flag == 2)
                        return lst.step + vis[sum].step;
                    vis[sum].flag = 1;
                    vis[sum].step = lst.step;
                    q.push(lst);
                }
            }
        }


        while(p.front().step == sp){
            pre = p.front();
            p.pop();

            for(i = 0; i < 6; i ++){
                if(i == 0){
                    for(t = 0; t < 2; t ++){
                        lst = pre;
                        lst.n[0] = pre.n[0] + dis[t];
                        if(lst.n[i] < 0)
                            lst.n[i] += 10;
                        else if(lst.n[i] >= 10)
                            lst.n[i] -= 10;
                        sum = total(lst);
                        lst.step = pre.step + 1;
                        if(vis[sum].flag == 2)
                            continue;
                        if(vis[sum].flag == 1)
                            return lst.step + vis[sum].step;
                        vis[sum].flag = 2;
                        vis[sum].step = lst.step;
                        p.push(lst);
                    }
                }
                else if(i == 1){
                    for(t = 0; t < 2; t ++){
                        lst = pre;
                        lst.n[1] = pre.n[1] + dis[t];
                        if(lst.n[i] < 0)
                            lst.n[i] += 10;
                        else if(lst.n[i] >= 10)
                            lst.n[i] -= 10;
                        int temp = 0;
                        for(int j = 0; j < 6; j ++)
                            if(lst.n[j] % 2)
                                temp ++;
                            else
                                temp --;
                        if(temp != 0)
                            continue;
                        sum = total(lst);
                        lst.step = pre.step + 1;
                        if(vis[sum].flag == 2)
                            continue;
                        if(vis[sum].flag == 1)
                            return lst.step + vis[sum].step;
                        vis[sum].flag = 2;
                        vis[sum].step = lst.step;
                        p.push(lst);
                    }
                }
                else if(i == 2){
                    lst = pre;
                    lst.n[2] = pre.n[2] - 7;
                    if(lst.n[i] < 0)
                        lst.n[i] += 10;
                    else if(lst.n[i] >= 10)
                        lst.n[i] -= 10;
                    sum = total(lst);
                    lst. step = pre.step + 1;
                    if(vis[sum].flag == 2)
                        continue;
                    if(vis[sum].flag == 1)
                        return lst.step + vis[sum].step;
                    vis[sum].flag = 2;
                    vis[sum].step = lst.step;
                    p.push(lst);
                }
                else if(i == 3){
                    for(t = 0; t < 10; t ++){
                        lst.n[3] = pre.n[3] - t;
                        if(lst.n[i] < 0)
                            lst.n[i] += 10;
                        else if(lst.n[i] >= 10)
                            lst.n[i] -= 10;
                        int temp = 0;
                        for(int j = 0; j < 6; j ++)
                            temp += lst.n[j];
                        if(temp % 9 + 1 != i)
                            continue;
                        sum = total(lst);
                        lst.step = pre.step + 1;
                        if(vis[sum].flag == 2)
                            continue;
                        if(vis[sum].flag == 1)
                            return lst.step + vis[sum].step;
                        vis[sum].flag = 2;
                        vis[sum].step = lst.step;
                        p.push(lst);
                    }
                }
                else if(i == 4){
                    for(t = 0; t < 2; t ++){
                        lst = pre;
                        lst.n[4] = pre.n[4] + dis[t];
                        if(lst.n[i] < 0)
                            lst.n[i] += 10;
                        else if(lst.n[i] >= 10)
                            lst.n[i] -= 10;
                        if(lst.n[0] + lst.n[2] + lst.n[4] != 9)
                            continue;
                        sum = total(lst);
                        lst.step = pre.step + 1;
                        if(vis[sum].flag == 2)
                            continue;
                        if(vis[sum].flag == 1)
                            return lst.step + vis[sum].step;
                        vis[sum].flag = 2;
                        vis[sum].step = lst.step;
                        p.push(lst);
                    }
                }
                else if(i == 5 && pre.n[1] == 0){
                    lst = pre;
                    lst.n[5] = pre.n[5] + 3;
                    if(lst.n[i] < 0)
                        lst.n[i] += 10;
                    else if(lst.n[i] >= 10)
                        lst.n[i] -= 10;
                    sum = total(lst);
                    lst.step = pre.step + 1;
                    if(vis[sum].flag == 2)
                        continue;
                    if(vis[sum].flag == 1)
                        return lst.step + vis[sum].step;
                    vis[sum].flag = 2;
                    vis[sum].step = lst.step;
                    p.push(lst);
                }
            }
        }
        ++sp;
    }
    return -1;
}

int main(int argc, const char * argv[]) {
    int T;
    cin >> T;
    while(T --){
        bool flag = false;
        for(int i = 0; i < 6; i ++){
            cin >> ans[i];
            init[i] = 0;
            if(ans[i])
                flag = true;
        }
        if(!flag)
            cout << "0" << endl;
        int res = bfs();
        cout << res << endl;
    }
    return 0;
}

I-草滩小王子与测量误差

模拟即可，就是麻烦了点。
首先算误差，如果不在要求内就输出并进入下组数据。
若在要求范围内，就先进行粗分配，即将误差f除以n得到每个要分配的fix量，这里一定要注意正负。
若f%n不为0，则再进行精分配，依次找最小的边，找到没有精调整过的点，进行精调整，然后标记，并将f减一，直到f%n为0。
稍微麻烦一点的是角度结构体的操作和误差正负的判断。

//
// main.cpp
// 长大15acm-I
//
// Created by 袁子涵 on 15/12/7.
// Copyright © 2015年 袁子涵. All rights reserved.
//

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
using namespace std;
struct cor
{
    int degree,min,sec;
};
int n;
struct cor c[20];
double edge[20];
bool flag=0,vis[20];
struct cor total,f,tmp;
struct edge
{
    int u,v;
    double w;
};
struct edge E[20];
void update(struct cor *x)
{
    if (x->sec>=60) {
        x->min+=x->sec/60;
        x->sec%=60;
    }
    if (x->min>=60) {
        x->degree+=x->min/60;
        x->min%=60;
    }
}
bool cmp(struct cor a,struct cor b)
{
    if (a.degree>b.degree)
        return 1;
    if (a.min>b.min)
        return 1;
    if (a.sec>b.sec)
        return 1;
    return 0;
}
bool limit()
{
    tmp.degree=tmp.min=tmp.sec=0;
    if (total.degree<(n-2)*180) {
        tmp.degree=(n-2)*180-total.degree-1;
        tmp.min=60-total.min-1;
        tmp.sec=60-total.sec;
        flag=1;
    }
    else
    {
        tmp.degree=total.degree-(n-2)*180;
        tmp.min=total.min;
        tmp.sec=total.sec;
        flag=0;
    }
    update(&tmp);
    if (cmp(f, tmp))
        return 0;
    return 1;
}
void getback(struct cor *a)
{
    a->sec+=a->degree*3600+a->min*60;
    a->degree=a->min=0;
}
bool comp(struct edge a,struct edge b)
{
    return a.w<b.w;
}
int main(int argc, const char * argv[]) {
    int T;
    cin >> T;
    while (T--) {
        cin >> n;
        total.sec=total.min=total.degree=0;
        memset(vis, 0, sizeof(vis));
        f.sec=f.min=f.degree=0;
        for (int i=1; i<=n; i++)
        {
            scanf("%d%d%d",&c[i].degree,&c[i].min,&c[i].sec);
            total.sec+=c[i].sec;
            total.min+=c[i].min;
            total.degree+=c[i].degree;
        }
        update(&total);
        for (int i=1; i<=n; i++)
        {
            scanf("%lf",&edge[i]);
            if (i==n) {
                E[i].u=n;
                E[i].v=1;
                E[i].w=edge[i];
            }
            else
            {
                E[i].u=i;
                E[i].v=i+1;
                E[i].w=edge[i];
            }
        }
        f.sec=40*sqrt((double)n);
        update(&f);
        if(limit())
        {
            cout << "Poor Prince Cao Tan" << endl;
            continue;
        }
        getback(&tmp);
        long long int fix=tmp.sec/n;
        tmp.sec%=n;
        for (int i=1; i<=n; i++) {
            if (flag)
                c[i].sec+=fix;
            else
                c[i].sec-=fix;
            update(&c[i]);
        }
        if (tmp.sec) {
            sort(E+1, E+n+1, comp);
            for (int i=1; i<=tmp.sec; i++) {
                struct edge tt=E[i];
                int pp,pt;
                if ((edge[tt.u-1]<edge[tt.v] && vis[tt.u]==0) || vis[tt.v]) {
                    pp=tt.u;
                    pt=tt.v;
                }
                else
                {
                    pp=tt.v;
                    pt=tt.u;
                }
                if (flag)
                    c[pp].sec+=1;
                else
                    c[pp].sec-=1;
                vis[pp]=1;
                update(&c[pp]);
                if(tmp.sec-1 && vis[pt]==0)
                {
                    if (flag)
                        c[pt].sec+=1;
                    else
                        c[pt].sec-=1;
                    tmp.sec--;
                }
            }
        }
        for (int i=1; i<=n; i++)
            printf("%d %d %d\n",c[i].degree,c[i].min,c[i].sec);
    }
    return 0;
}

J-草滩小王子与炫酷魔方

这道题直接模拟啊，操作数这么少。

//
// main.cpp
// 长大15acm-J
//
// Created by 袁子涵 on 15/12/8.
// Copyright © 2015年 袁子涵. All rights reserved.
//

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
#include <vector>
#include <queue>
#define on 1
#define down 2
#define left 3
#define right 4
#define front 5
#define behind 6
using namespace std;
char set[7]={' ','W','Y','O','R','G','B'};
char s[105];
typedef struct cube
{
    char color[7][3][3];
}Cube;
Cube C;
void Cube_Init()
{
    for (int i=1; i<=6; i++)
        for (int j=1; j<=2; j++)
            for (int k=1; k<=2; k++)
                C.color[i][j][k]=set[i];
}
void U()
{
    Cube tmp=C;
    tmp.color[right][1][1]=C.color[behind][1][1];
    tmp.color[right][1][2]=C.color[behind][1][2];
    tmp.color[front][1][1]=C.color[right][1][1];
    tmp.color[front][1][2]=C.color[right][1][2];
    tmp.color[left][1][1]=C.color[front][1][1];
    tmp.color[left][1][2]=C.color[front][1][2];
    tmp.color[behind][1][1]=C.color[left][1][1];
    tmp.color[behind][1][2]=C.color[left][1][2];
    tmp.color[on][1][1]=C.color[on][2][1];
    tmp.color[on][1][2]=C.color[on][1][1];
    tmp.color[on][2][1]=C.color[on][2][2];
    tmp.color[on][2][2]=C.color[on][1][2];
    C=tmp;
}
void U1()
{
    U();
    U();
    U();
}
void U2()
{
    U();
    U();
}
void R()
{
    Cube tmp=C;
    tmp.color[on][2][1]=C.color[front][2][2];
    tmp.color[on][2][2]=C.color[front][1][2];
    tmp.color[front][1][2]=C.color[down][2][1];
    tmp.color[front][2][2]=C.color[down][2][2];
    tmp.color[down][2][1]=C.color[behind][2][1];
    tmp.color[down][2][2]=C.color[behind][1][1];
    tmp.color[behind][1][1]=C.color[on][2][1];
    tmp.color[behind][2][1]=C.color[on][2][2];
    tmp.color[right][1][1]=C.color[right][2][1];
    tmp.color[right][1][2]=C.color[right][1][1];
    tmp.color[right][2][1]=C.color[right][2][2];
    tmp.color[right][2][2]=C.color[right][1][2];
    C=tmp;
}
void R1()
{
    R();
    R();
    R();
}
void R2()
{
    R();
    R();
}
void F()
{
    Cube tmp=C;
    tmp.color[right][1][1]=C.color[on][1][1];
    tmp.color[right][2][1]=C.color[on][2][1];
    tmp.color[on][1][1]=C.color[left][2][2];
    tmp.color[on][2][1]=C.color[left][1][2];
    tmp.color[left][1][2]=C.color[down][1][1];
    tmp.color[left][2][2]=C.color[down][2][1];
    tmp.color[down][1][1]=C.color[right][2][1];
    tmp.color[down][2][1]=C.color[right][1][1];
    tmp.color[front][1][1]=C.color[front][2][1];
    tmp.color[front][1][2]=C.color[front][1][1];
    tmp.color[front][2][1]=C.color[front][2][2];
    tmp.color[front][2][2]=C.color[front][1][2];
    C=tmp;
}
void F1()
{
    F();
    F();
    F();
}
void F2()
{
    F();
    F();
    F();
}
void D()
{
    Cube tmp=C;
    tmp.color[right][2][1]=C.color[front][2][1];
    tmp.color[right][2][2]=C.color[front][2][2];
    tmp.color[front][2][1]=C.color[left][2][1];
    tmp.color[front][2][2]=C.color[left][2][2];
    tmp.color[left][2][1]=C.color[behind][2][1];
    tmp.color[left][2][2]=C.color[behind][2][2];
    tmp.color[behind][2][1]=C.color[right][2][1];
    tmp.color[behind][2][2]=C.color[right][2][2];
    tmp.color[down][1][1]=C.color[down][1][2];
    tmp.color[down][1][2]=C.color[down][2][2];
    tmp.color[down][2][1]=C.color[down][1][1];
    tmp.color[down][2][2]=C.color[down][2][1];
    C=tmp;
}
void D1()
{
    D();
    D();
    D();
}
void D2()
{
    D();
    D();
}
void L()
{
    Cube tmp=C;
    tmp.color[on][1][1]=C.color[behind][1][2];
    tmp.color[on][1][2]=C.color[behind][2][2];
    tmp.color[behind][1][2]=C.color[down][1][2];
    tmp.color[behind][2][2]=C.color[down][1][1];
    tmp.color[down][1][1]=C.color[front][1][1];
    tmp.color[down][1][2]=C.color[front][2][1];
    tmp.color[front][1][1]=C.color[on][1][2];
    tmp.color[front][2][1]=C.color[on][1][1];
    tmp.color[left][1][1]=C.color[left][2][1];
    tmp.color[left][1][2]=C.color[left][1][1];
    tmp.color[left][2][1]=C.color[left][2][2];
    tmp.color[left][2][2]=C.color[left][1][2];
    C=tmp;
}
void L1()
{
    L();
    L();
    L();
}
void L2()
{
    L();
    L();
}
void B()
{
    Cube tmp=C;
    tmp.color[right][1][2]=C.color[down][2][2];
    tmp.color[right][2][2]=C.color[down][1][2];
    tmp.color[down][2][2]=C.color[left][1][2];
    tmp.color[down][1][2]=C.color[left][1][1];
    tmp.color[left][1][1]=C.color[on][2][2];
    tmp.color[left][2][1]=C.color[on][1][2];
    tmp.color[on][1][2]=C.color[right][1][2];
    tmp.color[on][2][2]=C.color[right][2][2];
    tmp.color[behind][1][1]=C.color[behind][2][1];
    tmp.color[behind][1][2]=C.color[behind][1][1];
    tmp.color[behind][2][1]=C.color[behind][2][2];
    tmp.color[behind][2][2]=C.color[behind][1][2];
    C=tmp;
}
void B1()
{
    B();
    B();
    B();
}
void B2()
{
    B();
    B();
}

int main(int argc, const char * argv[]) {
    int T,now;
    cin >> T;
    while (T--) {
        Cube_Init();
        cin >> s;
        now=0;
        while (s[now]!='\0') {
            if (s[now+1]=='2') {
                switch (s[now]) {
                    case 'U':
                        U2();
                        break;
                    case 'R':
                        R2();
                        break;
                    case 'F':
                        F2();
                        break;
                    case 'D':
                        D2();
                        break;
                    case 'L':
                        L2();
                        break;
                    case 'B':
                        B2();
                        break;
                    default:
                        break;
                }
                now+=2;
                continue;
            }
            if (s[now+1]=='\'') {
                switch (s[now]) {
                    case 'U':
                        U1();
                        break;
                    case 'R':
                        R1();
                        break;
                    case 'F':
                        F1();
                        break;
                    case 'D':
                        D1();
                        break;
                    case 'L':
                        L1();
                        break;
                    case 'B':
                        B1();
                        break;
                    default:
                        break;
                }
                now+=2;
                continue;
            }
            else
            {
                switch (s[now]) {
                    case 'U':
                        U();
                        break;
                    case 'R':
                        R();
                        break;
                    case 'F':
                        F();
                        break;
                    case 'D':
                        D();
                        break;
                    case 'L':
                        L();
                        break;
                    case 'B':
                        B();
                        break;
                    default:
                        break;
                }
                now++;
            }
        }
        for (int i=1; i<=2; i++) {
            for (int j=1; j<=2; j++) {
                printf("%c ",C.color[front][i][j]);
            }
            printf("\n");
        }
    }
    return 0;
}