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

Solution (Python):


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)

Solution (Python):
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)

Solution (Python):


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()

Solution (Python):


import sys

YES = "Yes"  
NO = "No"  


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))  
    A = int(next(tokens))  
    B = int(next(tokens))  
    C = int(next(tokens))  
    s = [s2index(next(tokens)) for _ in range(N)]  
    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()

Solution (Python):


import sys

YES = "Yes"  
NO = "No"  


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))  
    A = int(next(tokens))  
    B = int(next(tokens))  
    C = int(next(tokens))  
    s = [s2index(next(tokens)) for _ in range(N)]  
    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()

Solution (Python):
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))

Solution (Python):


import sys

YES = "Yes"  
NO = "No"  


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))  
    A = int(next(tokens))  
    B = int(next(tokens))  
    C = int(next(tokens))  
    s = [s2i(next(tokens)) for _ in range(N)]  
    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()

Solution (Python):


import sys

YES = "Yes"  
NO = "No"  


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))  
    A = int(next(tokens))  
    B = int(next(tokens))  
    C = int(next(tokens))  
    s = [s2i(next(tokens)) for _ in range(N)]  
    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()

Solution (Python):
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()

Solution (Python):


import sys

YES = "Yes"  
NO = "No"  


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))  
    A = int(next(tokens))  
    B = int(next(tokens))  
    C = int(next(tokens))  
    s = [s2i(next(tokens)) for _ in range(N)]  
    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()

Solution (Python):


import sys

YES = "Yes"  
NO = "No"  


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))  
    A = int(next(tokens))  
    B = int(next(tokens))  
    C = int(next(tokens))  
    s = [s2i(next(tokens)) for _ in range(N)]  
    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()

Solution (Python):


import sys

YES = "Yes"  
NO = "No"  


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))  
    A = int(next(tokens))  
    B = int(next(tokens))  
    C = int(next(tokens))  
    s = [s2i(next(tokens)) for _ in range(N)]  
    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()

Solution (Python):


import sys

YES = "Yes"  
NO = "No"  


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))  
    A = int(next(tokens))  
    B = int(next(tokens))  
    C = int(next(tokens))  
    s = [s2i(next(tokens)) for _ in range(N)]  
    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()

Solution (Python):
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:
            
            if i == n-1 or s[i+1] == "AB" or s[i+1] == 'AC':
                a += 1
                b -= 1
                log.append("A")
            
            else:
                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:
            
            if i == n-1 or s[i+1] == "AC" or s[i+1] == 'AB':
                a += 1
                c -= 1
                log.append("A")
            
            else:
                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:
        
        if c == 1 and b == 1:
            
            if i == n-1 or  s[i+1] == "BC" or s[i+1] == 'AB':
                c -= 1
                b += 1
                log.append("B")
            
            else:
                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')

Solution (Python):

































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:
        
        
        
        
        
        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')

Solution (Python):


N, A, B, C = map(int,input().split())
S = []
for i in range(N):
    S.append(input()) 


num = [A, B, C]


def step():
    ans = []

    for i in range(N):
        if(ans == 'No'):
            break
        choice = S[i]
        if(i+1 == N):
            next_choice = choice
        else:
            next_choice = S[i+1]
        if(choice == 'AB'):
            if(num[0] == 0):
                
                if(num[1] == 0):
                    ans = 'No' 
                else:
                    
                    ans.append('A')
                    num[0] += 1
                    num[1] -= 1
            else:
                
                if(num[0] < num[1]):
                    
                    ans.append('A')
                    num[0] += 1
                    num[1] -= 1
                elif(num[0] > num[1]):
                    
                    
                    ans.append('B')
                    num[0] -= 1
                    num[1] += 1
                else:
                    
                    if(next_choice == 'BC'):
                        
                        ans.append('B')
                        num[0] -= 1
                        num[1] += 1
                    else:
                        
                        ans.append('A')
                        num[0] += 1
                        num[1] -= 1
        elif(choice == 'AC'):
            if(num[0] == 0):
                
                if(num[2] == 0):
                    ans = 'No' 
                else:
                    
                    ans.append('A')
                    num[0] += 1
                    num[2] -= 1
            else:
                
                if(num[0] < num[2]):
                    
                    ans.append('A')
                    num[0] += 1
                    num[2] -= 1
                elif(num[0] > num[2]):
                    
                    
                    ans.append('C')
                    num[0] -= 1
                    num[2] += 1
                else:
                    
                    if(next_choice == 'BC'):
                        
                        ans.append('C')
                        num[0] -= 1
                        num[2] += 1
                    else:
                        
                        ans.append('A')
                        num[0] += 1
                        num[2] -= 1
        else:
            
            if(num[1] == 0):
                
                if(num[2] == 0):
                    ans = 'No' 
                else:
                    
                    ans.append('B')
                    num[1] += 1
                    num[2] -= 1
            else:
                
                if(num[1] < num[2]):
                    
                    ans.append('B')
                    num[1] += 1
                    num[2] -= 1
                elif(num[1] > num[2]):
                    
                    
                    ans.append('C')
                    num[1] -= 1
                    num[2] += 1
                else:
                    
                    if(next_choice == 'AB'):
                        
                        ans.append('B')
                        num[1] += 1
                        num[2] -= 1
                    else:
                        
                        ans.append('C')
                        num[1] -= 1
                        num[2] += 1
        
    return ans

answer = step()

if(type(answer) == list):
    print('Yes')
    for i in range(len(answer)):
        print(answer[i])
else:
    print('No')

Solution (Python):
from bisect import bisect_left, bisect_right

INF = float("inf")
n, *s = map(int, input().split())
toidx = {"AB": (0, 1), "BC": (1, 2), "AC": (0, 2)}
toalp = lambda x: chr(ord("A") + x)
m = sum(s)
q = [toidx[input()] for _ in range(n)]

def solve():
    res = []
    if m == 0 or (not s[q[0][0]] and not s[q[0][1]]):
        print("No")
        return
    elif m == 1:
        for i, j in q:
            if not s[i] and not s[j]:
                print("No")
                return
            elif s[i]:
                s[j] += 1; s[i] -= 1
                res.append(toalp(j))
            elif s[j]:
                s[i] += 1; s[j] -= 1
                res.append(toalp(i))
    elif m == 2:
        d = {(0, 1): [], (0, 2): [], (1, 2): []}
        for i in range(n): d[q[i]].append(i)
        for key in d.keys(): d[key].append(INF)
        for idx, (i, j) in enumerate(q):
            if s[i] and s[j]:
                k = [x for x in range(3) if i != x and j != x][0]
                key1 = tuple(sorted([i, k]))
                key2 = tuple(sorted([j, k]))
                nik = d[key1][bisect_left(d[key1], idx)]
                njk = d[key2][bisect_left(d[key2], idx)]
                if nik <= njk:
                    s[i] += 1; s[j] -= 1
                    res.append(toalp(i))
                else: 
                    s[j] += 1; s[i] -= 1
                    res.append(toalp(j))
            elif s[i]:
                s[j] += 1; s[i] -= 1
                res.append(toalp(j))
            elif s[j]:
                s[i] += 1; s[j] -= 1
                res.append(toalp(i))
    else:
        for i, j in q:
            if s[i] >= s[j]:
                s[j] += 1; s[i] -= 1
                res.append(toalp(j))
            else:
                s[i] += 1; s[j] -= 1
                res.append(toalp(i))
    print("Yes")
    print(*res, sep="\n")

solve()