Problem:


Score : 600 points

Problem Statement

There is a game that involves three variables, denoted A, B, and C.

As the game progresses, there will be N events where you are asked to make a choice.
Each of these choices is represented by a string s_i. If s_i is AB, you must add 1 to A or B then subtract 1 from the other; if s_i is AC, you must add 1 to A or C then subtract 1 from the other; if s_i is BC, you must add 1 to B or C then subtract 1 from the other.

After each choice, none of A, B, and C should be negative.

Determine whether it is possible to make N choices under this condition. If it is possible, also give one such way to make the choices.

Constraints

1 \leq N \leq 10^5

0 \leq A,B,C \leq 10^9

N, A, B, C are integers.

s_i is AB, AC, or BC.

Input

Input is given from Standard Input in the following format:

N A B C
s_1
s_2
:
s_N

Output

If it is possible to make N choices under the condition, print Yes; otherwise, print No.

Also, in the former case, show one such way to make the choices in the subsequent N lines. The (i+1)-th line should contain the name of the variable (A, B, or C) to which you add 1 in the i-th choice.

Sample Input 1

2 1 3 0
AB
AC

Sample Output 1

Yes
A
C

You can successfully make two choices, as follows:

In the first choice, add 1 to A and subtract 1 from B. A becomes 2, and B becomes 2.

In the second choice, add 1 to C and subtract 1 from A. C becomes 1, and A becomes 1.

Sample Input 2

3 1 0 0
AB
BC
AB

Sample Output 2

No

Sample Input 3

1 0 9 0
AC

Sample Output 3

No

Sample Input 4

8 6 9 1
AC
BC
AB
BC
AC
BC
AB
AB

Sample Output 4

Yes
C
B
B
C
C
B
A
A



Sample input:
2 1 3 0
AB
AC


Sample output:
Yes
A
C

Submission status: Accepted

Solution code:
N,A,B,C=map(int,input().split())
S = [input() for _ in range(N)]
table = [A,B,C]
ans = []

def ci(s):
    if s == 'AB':
        return 0,1
    elif s == 'BC':
        return 1,2
    else:
        return 0,2

if A+B+C == 0:
    print('No')
    exit()
elif A+B+C == 1:
    for s in S:
        i,j = ci(s)
        if table[i] == 0 and table[j] == 0:
            print('No')
            exit()
        else:
            if table[i] == 0:
                table[i] = 1
                table[j] = 0
                ans.append(i)
            else:
                table[j] = 1
                table[i] = 0
                ans.append(j)

else:
    for k in range(N):
        i,j= ci(S[k])
        if table[i] > table[j]:
            i,j = j,i
        # print(table,i,j)
        if k + 1 < N:
            i2,j2 = ci(S[k+1])
        if table[i] == 0 and table[j] == 0:
            print('No')
            exit()
        elif table[i] == 0 and table[j] > 0:
            table[i] += 1
            table[j] -= 1
            ans.append(i)
        else:
            table[i] += 1
            table[j] -= 1
            if k + 1 < N:
                if table[i2] == 0 and table[j2] == 0:
                    table[i] -= 2
                    table[j] += 2
                    ans.append(j)
                else:
                    ans.append(i)
            else:
                ans.append(i)

print('Yes')
L = ['A','B','C']
for a in ans:
    print(L[a])

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

N, A, B, C = (int(_) for _ in input().split())
status = [A, B, C]
name = ['A', 'B', 'C']
sel_num = {'AB': (0, 1),
           'BC': (1, 2),
           'AC': (2, 0)}

S = []
for n in range(N):
    S.append(sel_num[input()])

if A + B + C > 2:
    difficult = False
else:
    difficult = True

ret = []
try:
    for i in range(len(S)):
        a1, a2 = S[i]
        if status[a2] < status[a1]:
            a1, a2 = a2, a1
        if (difficult and
            (status[a1] == 1) and
            (status[a2] == 1) and
            (i + 1 < len(S)) and
            S[i] != S[i + 1]):
            b1, b2 = S[i + 1]
            if a2 == b1:
                a1, a2 = a2, a1
        ret.append(name[a1])
        status[a1] += 1
        status[a2] -= 1
        assert status[a2] >= 0
except:
    print('No')
    exit(0)

print('Yes')
for r in ret:
    print(r)

Submission status: Accepted

Solution code:
var = [0]*3
n, var[0], var[1], var[2] = list(map(int, input().split()))
choice = [input() for i in range(n)]
selVar = []
addVar = 0
res = []
flag = True

for i in range(len(choice)):
    if choice[i] == 'AB':
        selVar = [0,1]
    elif choice[i] == 'BC':
        selVar = [1,2]
    else:
        selVar = [0,2]
    if var[0]+var[1]+var[2] == 0:
        flag = False
        break
    elif var[0]+var[1]+var[2] == 1:
        if var[selVar[0]] == 0 and var[selVar[1]] == 0:
            flag = False
            break
        elif var[selVar[0]] == 0:
            var[selVar[0]] += 1
            var[selVar[1]] -= 1
            addVar = selVar[0]
        else:
            var[selVar[0]] -= 1
            var[selVar[1]] += 1
            addVar = selVar[1]
    elif var[0]+var[1]+var[2] >= 2:
        if var[selVar[0]] == 0 and var[selVar[1]] == 0:
            flag = False
            break
        elif var[selVar[0]] == 0:
            var[selVar[0]] += 1
            var[selVar[1]] -= 1
            addVar = selVar[0]
        elif var[selVar[1]] == 0:
            var[selVar[0]] -= 1
            var[selVar[1]] += 1
            addVar = selVar[1]
        elif var[0]+var[1]+var[2] == 2:
            if i < len(choice) - 1:
                if choice[i] != choice[i+1]:
                    commonLet = set(list(choice[i])) & set(list(choice[i+1]))
                    if 'A' in commonLet:
                        var[0] += 1
                        addVar = 0
                        if selVar[0] == 0:
                            var[selVar[1]] -= 1
                        else:
                            var[selVar[0]] -= 1
                    if 'B' in commonLet:
                        var[1] += 1
                        addVar = 1
                        if selVar[0] == 1:
                            var[selVar[1]] -= 1
                        else:
                            var[selVar[0]] -= 1
                    if 'C' in commonLet:
                        var[2] += 1
                        addVar = 2
                        if selVar[0] == 2:
                            var[selVar[1]] -= 1
                        else:
                            var[selVar[0]] -= 1
                else:
                    var[selVar[0]] -= 1
                    var[selVar[1]] += 1
                    addVar = selVar[1]
            else:
                var[selVar[0]] -= 1
                var[selVar[1]] += 1
                addVar = selVar[1]
        else:
            if var[selVar[0]] < var[selVar[1]]:
                var[selVar[0]] += 1
                var[selVar[1]] -= 1
                addVar = selVar[0]
            else:
                var[selVar[0]] -= 1
                var[selVar[1]] += 1
                addVar = selVar[1]
    if addVar == 0:
        res.append('A')
    elif addVar == 1:
        res.append('B')
    else:
        res.append('C')

if not flag:
    print('No')
else:
    print('Yes')
    for re in res:
        print(re)

Submission status: Accepted

Solution code:


def read_int():
    return int(input().strip())


def read_ints():
    return list(map(int, input().strip().split(' ')))

def third(x, y):
    return (set('ABC')-set([x,y])).pop()

def other(S, c):
    if S[0] == c:
        return S[1]
    return S[0]

def _solve(A, B, C, S):
    counter = {'A': A, 'B': B, 'C': C}
    answer = []
    i = 0
    while i < len(S):
        s = S[i]
        if counter[s[0]] > 0:
            counter[s[0]] -= 1
            counter[s[1]] += 1
            answer.append(s[1])
        elif counter[s[1]] > 0:
            counter[s[0]] += 1
            counter[s[1]] -= 1
            answer.append(s[0])
        else:
            if i == 0:
                return None
            if S[i-1][0] in s:
                prev_dest = S[i-1][1]
                prev_src = S[i-1][0]
            else:
                prev_dest = S[i-1][0]
                prev_src = S[i-1][1]
            answer.pop()
            answer.append(prev_src)
            counter[prev_dest] -= 2
            counter[prev_src] += 2
            if counter[prev_dest] < 0:
                return None
            i -= 1
        i += 1
    return answer



def solve():
    N, A, B, C = read_ints()
    S = []
    for _ in range(N):
        S.append(input().strip())
    answer = _solve(A, B, C, S)
    if answer is None:
        print('No')
        return
    print('Yes')
    for a in answer:
        print(a)


if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
import sys

YES = "Yes"  # type: str
NO = "No"  # type: str


def solve(N: int, A: int, B: int, C: int, s: "List[int]"):
    v = [A, B, C]
    ans = []
    for i in range(N):
        l, r = s[i]
        if v[l] + v[r] == 0:
            return None
        if v[l] > v[r] or v[l] == v[r] and i != N - 1 and r in s[i + 1]:
            ans.append(r)
            v[l] -= 1
            v[r] += 1
        else:
            ans.append(l)
            v[l] += 1
            v[r] -= 1
    return ans


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word

    def s2index(s: "List[str]"):
        return [ord(c)-ord('A') for c in s]

    def index2s(i: int):
        return chr(i + ord('A'))

    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    s = [s2index(next(tokens)) for _ in range(N)]  # type: "List[int]"
    ans = solve(N, A, B, C, s)

    if ans == None:
        print(NO)
    else:
        print(YES)
        print("\n".join(list(map(index2s, ans))))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
import sys

YES = "Yes"  # type: str
NO = "No"  # type: str


def solve(N: int, A: int, B: int, C: int, s: "List[int]"):
    v = [A, B, C]
    ans = []
    for i in range(N):
        l, r = s[i]
        if v[l] + v[r] == 0:
            return None
        if v[r] == 0 or v[l] >= v[r] and i != N - 1 and r in s[i + 1]:
            ans.append(r)
            v[l] -= 1
            v[r] += 1
        else:
            ans.append(l)
            v[l] += 1
            v[r] -= 1
    return ans


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word

    def s2index(s: "List[str]"):
        return [ord(c)-ord('A') for c in s]

    def index2s(i: int):
        return chr(i + ord('A'))

    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    s = [s2index(next(tokens)) for _ in range(N)]  # type: "List[int]"
    ans = solve(N, A, B, C, s)

    if ans == None:
        print(NO)
    else:
        print(YES)
        print("\n".join(list(map(index2s, ans))))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

n, a, b, c = map(int, readline().split())
s = [readline().rstrip().decode() for _ in range(n)] + ['']
ans = [''] * n
for i, (bf, af) in enumerate(zip(s, s[1:])):
    if bf == 'AB':
        if a > b or (a == b and i != n - 1 and 'B' in af):
            b += 1
            a -= 1
            ans[i] = 'B'
        else:
            a += 1
            b -= 1
            ans[i] = 'A'
    elif bf == 'AC':
        if a > c or (a == c and i != n - 1 and 'C' in af):
            c += 1
            a -= 1
            ans[i] = 'C'
        else:
            c -= 1
            a += 1
            ans[i] = 'A'
    else:
        if b > c or (b == c and i != n - 1 and 'C' in af):
            c += 1
            b -= 1
            ans[i] = 'C'
        else:
            c -= 1
            b += 1
            ans[i] = 'B'
    if a < 0 or b < 0 or c < 0:
        print('No')
        exit()
print('Yes')
print('\n'.join(ans))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
import sys

YES = "Yes"  # type: str
NO = "No"  # type: str


def solve(N: int, A: int, B: int, C: int, s: "List[int]"):
    v = [A, B, C]
    ans = []
    if sum(v) == 0:
        return None
    if sum(v) == 1:
        for l, r in s:
            if v[l] + v[r] == 0:
                return None
            if v[l] == 0:
                ans.append(l)
            else:
                ans.append(r)
            v[l], v[r] = v[r], v[l]
        return ans
    if sum(v) > 1:
        for i in range(N):
            l, r = s[i]
            if v[l] + v[r] == 0:
                return None
            if v[r] == 0 or v[l] >= v[r] and i != N - 1 and r in s[i + 1]:
                ans.append(r)
                v[l] -= 1
                v[r] += 1
            else:
                ans.append(l)
                v[l] += 1
                v[r] -= 1
        return ans


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word

    def s2i(s: str):
        return ord(s[0])-ord('A'), ord(s[1])-ord('A')

    def i2s(i: int):
        return chr(i + ord('A'))

    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    s = [s2i(next(tokens)) for _ in range(N)]  # type: "List[int]"
    ans = solve(N, A, B, C, s)
    if ans == None:
        print(NO)
    else:
        print(YES)
        print("\n".join(list(map(i2s, ans))))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
import sys

YES = "Yes"  # type: str
NO = "No"  # type: str


def solve(N: int, A: int, B: int, C: int, s: "List[int]"):
    v = [A, B, C]
    ans = []
    if sum(v) == 0:
        return None
    if sum(v) == 1:
        for l, r in s:
            if v[l] + v[r] == 0:
                return None
            if v[l] == 0:
                ans.append(l)
            else:
                ans.append(r)
            v[l], v[r] = v[r], v[l]
        return ans
    if sum(v) > 1:
        for i in range(N):
            l, r = s[i]
            if v[l] + v[r] == 0:
                return None
            if v[r] == 0 or v[l] > v[r] or (v[r] == v[l] and i != N - 1 and r in s[i + 1]):
                ans.append(r)
                v[l] -= 1
                v[r] += 1
            else:
                ans.append(l)
                v[l] += 1
                v[r] -= 1
        return ans


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word

    def s2i(s: str):
        return ord(s[0])-ord('A'), ord(s[1])-ord('A')

    def i2s(i: int):
        return chr(i + ord('A'))

    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    s = [s2i(next(tokens)) for _ in range(N)]  # type: "List[int]"
    ans = solve(N, A, B, C, s)
    if ans == None:
        print(NO)
    else:
        print(YES)
        print("\n".join(list(map(i2s, ans))))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
def input() : return sys.stdin.readline().strip()

def main():
    N, A, B, C = map(int, input().split())
    s = list(input() for _ in range(N))
    d = {}
    d["A"] = A
    d["B"] = B
    d["C"] = C
    
    ans = []
    s.append("XX")
    for i in range(N):
        l1, r1 = s[i]
        l2, r2 = s[i+1]

        def func(a, b):
            d[a] += 1
            d[b] -= 1
            ans.append(a)

        if d[l1] == 0 and d[r1] == 0:
            print("No")
            exit()
        
        if d[l1] == 0:
            func(l1, r1)
        elif d[r1] == 0:
            func(r1, l1)
        else:
            if l1 in [l2, r2]:
                func(l1, r1)
            else:
                func(r1, l1)

    print("Yes")
    print(*ans, sep="\n")

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
import sys

YES = "Yes"  # type: str
NO = "No"  # type: str


def solve(N: int, A: int, B: int, C: int, s: "List[int]"):
    v = [A, B, C]
    ans = []
    if sum(v) == 0:
        return None
    if sum(v) == 1:
        for l, r in s:
            if v[l] + v[r] == 0:
                return None
            if v[l] == 0:
                ans.append(l)
            else:
                ans.append(r)
            v[l], v[r] = v[r], v[l]
        return ans
    if sum(v) > 1:
        for i in range(N):
            l, r = s[i]
            if v[l] + v[r] == 0:
                return None
            if v[r] == 0 or v[l] > v[r] or (v[r] == 1 and v[l] == 1 and i != N - 1 and r in s[i + 1]):
                ans.append(r)
                v[l] -= 1
                v[r] += 1
            else:
                ans.append(l)
                v[l] += 1
                v[r] -= 1
        return ans


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word

    def s2i(s: str):
        return ord(s[0])-ord('A'), ord(s[1])-ord('A')

    def i2s(i: int):
        return chr(i + ord('A'))

    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    s = [s2i(next(tokens)) for _ in range(N)]  # type: "List[int]"
    ans = solve(N, A, B, C, s)
    if ans == None:
        print(NO)
    else:
        print(YES)
        print("\n".join(list(map(i2s, ans))))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
import sys

YES = "Yes"  # type: str
NO = "No"  # type: str


def solve(N: int, A: int, B: int, C: int, s: "List[int]"):
    v = [A, B, C]
    ans = []
    if sum(v) == 0:
        return None
    if sum(v) == 1:
        for l, r in s:
            if v[l] + v[r] == 0:
                return None
            if v[l] == 0:
                ans.append(l)
            else:
                ans.append(r)
            v[l], v[r] = v[r], v[l]
        return ans
    if sum(v) > 1:
        for i in range(N):
            l, r = s[i]
            if v[l] + v[r] == 0:
                return None
            if v[r] == 1 and v[l] == 1 and i != N - 1:
                if r in s[i + 1]:
                    ans.append(r)
                    v[l] -= 1
                    v[r] += 1
                else:
                    ans.append(l)
                    v[l] += 1
                    v[r] -= 1
            elif v[r] == 0 or v[l] > v[r]:
                ans.append(r)
                v[l] -= 1
                v[r] += 1
            else:
                ans.append(l)
                v[l] += 1
                v[r] -= 1
        return ans


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word

    def s2i(s: str):
        return ord(s[0])-ord('A'), ord(s[1])-ord('A')

    def i2s(i: int):
        return chr(i + ord('A'))

    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    s = [s2i(next(tokens)) for _ in range(N)]  # type: "List[int]"
    ans = solve(N, A, B, C, s)
    if ans == None:
        print(NO)
    else:
        print(YES)
        print("\n".join(list(map(i2s, ans))))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
import sys

YES = "Yes"  # type: str
NO = "No"  # type: str


def solve(N: int, A: int, B: int, C: int, s: "List[int]"):
    v = [A, B, C]
    ans = []
    if sum(v) == 0:
        return None
    if sum(v) == 1:
        for l, r in s:
            if v[l] + v[r] == 0:
                return None
            if v[l] == 0:
                ans.append(l)
            else:
                ans.append(r)
            v[l], v[r] = v[r], v[l]
        return ans
    if sum(v) > 1:
        for i in range(N):
            l, r = s[i]
            if v[l] + v[r] == 0:
                return None
            if v[r] == 1 and v[l] == 1 and i != N - 1:
                ln, rn = s[i + 1]
                if r == ln or r == rn:
                    ans.append(r)
                    v[l] -= 1
                    v[r] += 1
                else:
                    ans.append(l)
                    v[l] += 1
                    v[r] -= 1
            elif v[r] == 0 or v[l] > v[r]:
                ans.append(r)
                v[l] -= 1
                v[r] += 1
            else:
                ans.append(l)
                v[l] += 1
                v[r] -= 1
        return ans


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word

    def s2i(s: str):
        return ord(s[0])-ord('A'), ord(s[1])-ord('A')

    def i2s(i: int):
        return chr(i + ord('A'))

    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    s = [s2i(next(tokens)) for _ in range(N)]  # type: "List[int]"
    ans = solve(N, A, B, C, s)
    if ans == None:
        print(NO)
    else:
        print(YES)
        print("\n".join(list(map(i2s, ans))))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
import sys

YES = "Yes"  # type: str
NO = "No"  # type: str


def solve(N: int, A: int, B: int, C: int, s: "List[int]"):
    v = [A, B, C]
    ans = []
    if sum(v) == 0:
        return None
    if sum(v) == 1:
        for l, r in s:
            if v[l] + v[r] == 0:
                return None
            if v[l] == 0:
                ans.append(l)
            else:
                ans.append(r)
            v[l], v[r] = v[r], v[l]
        return ans
    if sum(v) > 1:
        for i in range(N):
            l, r = s[i]
            if v[l] + v[r] == 0:
                return None
            if v[r] == 1 and v[l] == 1 and i != N - 1 and s[i] != s[i+1]:
                ln, rn = s[i + 1]
                if r == ln or r == rn:
                    ans.append(r)
                    v[l] -= 1
                    v[r] += 1
                else:
                    ans.append(l)
                    v[l] += 1
                    v[r] -= 1
            elif v[r] == 0 or v[l] > v[r]:
                ans.append(r)
                v[l] -= 1
                v[r] += 1
            else:
                ans.append(l)
                v[l] += 1
                v[r] -= 1
        return ans


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word

    def s2i(s: str):
        return ord(s[0])-ord('A'), ord(s[1])-ord('A')

    def i2s(i: int):
        return chr(i + ord('A'))

    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    s = [s2i(next(tokens)) for _ in range(N)]  # type: "List[int]"
    ans = solve(N, A, B, C, s)
    if ans == None:
        print(NO)
    else:
        print(YES)
        print("\n".join(list(map(i2s, ans))))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def end():
    print("No")
    exit()

n, a, b, c = map(int, input().split())
s = [input() for i in range(n)]
log = []

for i in range(n):
    if s[i] == "AB":
        # コーナーケース
        if a == 1 and b == 1:
            # aが重複 最後はどっちでもいいので
            if i == n-1 or s[i+1] == "AB" or s[i+1] == 'AC':
                a += 1
                b -= 1
                log.append("A")
            # Bが重複
            else:# "BC"
                a -= 1
                b += 1
                log.append("B")
        elif a == 0 and b == 0:
            end()
        else:
            if a>=b:
                a -= 1
                b += 1
                log.append("B")
            else:
                a += 1
                b -= 1
                log.append("A")

    elif s[i] == "AC":
        # コーナーケース
        if a == 1 and c == 1:
            # aが重複
            if i == n-1 or s[i+1] == "AC" or s[i+1] == 'AB':
                a += 1
                c -= 1
                log.append("A")
            # Cが重複
            else:# "BC"
                c += 1
                a -= 1
                log.append("C")
        elif a == 0 and c == 0:
            end()
        else:
            if a>=c:
                a -= 1
                c += 1
                log.append("C")
            else:
                a += 1
                c -= 1
                log.append("A")
    else:#BC
        # コーナーケース
        if c == 1 and b == 1:
            # Bが重複
            if i == n-1 or  s[i+1] == "BC" or s[i+1] == 'AB':
                c -= 1
                b += 1
                log.append("B")
            # Cが重複
            else:# "AC"
                c += 1
                b -= 1
                log.append("C")
        elif b == 0 and c == 0:
            end()
        else:
            if b>=c:
                b -= 1
                c += 1
                log.append("C")
            else:
                b += 1
                c -= 1
                log.append("B")
else:
    print("Yes")
    print(*log, sep='\n')

Submission status: Accepted

Solution code:
# A B C
# 1 1 1
# 2 0 1
# 2 1 0
# 1 2 1
# それぞれ1以上の場合は問題ない
# 2人以上が1以上の場合はok
# では2人以上が0の場合は？
# 1 1 0 
# 0 1 1 C
# 1 0 1 A


# 合計が0の場合
# A B C
# 0 0 0

# 合計が1の場合
# A B C
# 1 0 0
# 0 1 0 AB => B
# 0 1 0 AC => No
# ==> sによる

# 合計が2の場合
# A B C
# 2 0 0
# 1 1 0 AB => B
# 0 1 1 AC => C
# 初回で0の組み合わせが選択されなければYes

# 合計が3以上の場合も同様に、初回で2つ以上が0でなければYesになる

from typing import Tuple, List, Optional

def play(N: int, A: int, B: int, C: int, s_arr: List[str]) -> Tuple[bool, Optional[List[str]]]:
    strategies = []
    v_dict = {'A': A, 'B': B, 'C': C}

    if A + B + C == 0:
        return (False, None)
    
    elif A + B + C == 1:
        prime = 'A' if A else 'B' if B else 'C'

        for s in s_arr:
            if prime in s:
                prime = s.replace(prime, '')
                strategies.append(prime)
            else:
                return (False, None)

    else:
        # 1 1 0 AB => B
        # 0 2 0 AC => No
        # 次のターンの文字列を見る
        # 1 1 0 AB => C
        # 0 1 1 AC => A
        for i in range(N):
            s = s_arr[i]
            if len(list(filter(lambda c: v_dict[c] == 0, s))) == 2:
                return (False, None)
            else:
                n, m = v_dict[s[0]], v_dict[s[1]]
                if n < m:
                    v_dict[s[0]] += 1
                    v_dict[s[1]] -= 1
                    strategies.append(s[0])
                elif n > m:
                    v_dict[s[0]] -= 1
                    v_dict[s[1]] += 1
                    strategies.append(s[1])                
                elif i < N - 1 and n == m and s[0] in s_arr[i+1]:
                    v_dict[s[0]] += 1
                    v_dict[s[1]] -= 1
                    strategies.append(s[0])
                elif i < N - 1 and n == m and s[1] in s_arr[i+1]:
                    v_dict[s[0]] -= 1
                    v_dict[s[1]] += 1
                    strategies.append(s[1])
                else:
                    v_dict[s[0]] -= 1
                    v_dict[s[1]] += 1
                    strategies.append(s[1])


    return (True, strategies)


if __name__ == '__main__':
    N, A, B, C = map(int, input().split())
    s = [input() for _ in range(N)]

    result, strategy = play(N, A, B, C, s)
    if result:
        print('Yes')
        print('\n'.join(strategy))
    else:
        print('No')