Python 我不知道'；我不知道这是动态规划

我是在韩国大学学习算法的初学者。 使用动态规划而不使用递归编程，只使用python来解决问题，这是一个非常重要的任务。 问题在于，当您输入5个字母的字符串时，结果是否通过某种操作打印出“a”，这些字符串仅由“a”、“b”、“c”组成

我做到了，但我不确定这是动态规划 如果你能给我一个建议，我真的很感激你的帮助

问题

       a b c
     a b b a
     b c b a
     c a c c

有一个由三个元素组成的算术表，{a、b和c}，该表的行、列和相应的相交值为您提供一个值，如{aa=b、ab=b、ac=a}

根据这些值，打印出是否可以为任何字符串（“可能”或“不可能”）导出结果， 并且，如果可能，使用动态规划技术编写计算序列，以通过括号指示序列

范例 输入：bba。 结果：可能，（b（bb）（bb）a）） 在上例中，通过参考第一个圆括号和分析计算表， （bb）是（b）。 然后（b（b））变成（b），并且（b）a变成c，表示 满足bc=a的最终要求。 -该语言必须使用Python。 -动态规划算法是允许使用的技术（不要使用递归x）。 -输出在许多情况下获得的第一个值 -将作为输入值的字符串长度设置为5

def rule(x,y):
    if((x=='a' and y=='c') or (x=='b' and y=='c') or (x=='c' and y=='a')):
        return 'a'

    if((x=='a' and y=='a') or (x=='a' and y=='b') or (x=='b' and y=='b')):
        return 'b'

    if((x=='b' and y=='a') or (x=='c' and y=='b') or (x=='c' and y=='c')):
        return 'c'
def rule2(x,y,z):
    return rule(rule(x,y),z)
def rule3(x,y,z):
    return rule(x,rule(y,z))
def rule4(w,x,y,z):
    return rule(rule(w,x),rule(y,z))
def rule5(w,x,y,z):
    return rule(rule2(w,x,y),z)
def rule6(w,x,y,z):
    return rule(rule3(w,x,y),z)
def rule7(w,x,y,z):
    return rule(w,rule2(x,y,z))
def rule8(w,x,y,z):
    return rule(w,rule3(x,y,z))
def rule9(v,w,x,y,z):
    global k
    k='((('+v+w+')'+x+')'+y+z+')'
    return rule(rule2(v,w,x),rule(y,z))
def rule10(v,w,x,y,z):
    global k
    k='(('+v+'('+w+x+'))('+y+z+'))'
    return rule(rule3(v,w,x),rule(y,z))
def rule11(v,w,x,y,z):
    global k
    k='(('+v+w+')(('+x+y+')'+z+'))'
    return rule(rule(v,w),rule2(x,y,z))
def rule12(v,w,x,y,z):
    global k
    k='(('+v+w+')('+x+'('+y+z+')))'
    return rule(rule(v,w),rule3(x,y,z))
def rule13(v,w,x,y,z):
    global k
    k='((('+v+w+')('+x+y+'))'+z+')'
    return rule(rule4(v,w,x,y),z)
def rule14(v,w,x,y,z):
    global k
    k='(((('+v+w+')'+x+')'+y+')'+z+')'
    return rule(rule5(v,w,x,y),z)
def rule15(v,w,x,y,z):
    global k
    k='((('+v+'('+w+x+')'+y+')'+z+'))'
    return rule(rule6(v,w,x,y),z)
def rule16(v,w,x,y,z):
    global k
    k='('+v+'('+w+'(('+x+y+')'+z+')))'
    return rule(rule7(v,w,x,y),z)
def rule17(v,w,x,y,z):
    global k
    k='('+v+'('+w+'('+x+'('+y+z+'))))'
    return rule(rule8(v,w,x,y),z)
def rule18(v,w,x,y,z):
    global k
    k='('+v+'(('+w+x+')('+y+z+')))'
    return rule(v,rule4(w,x,y,z))
def rule19(v,w,x,y,z):
    global k
    k='(('+v+'(('+w+x+')'+y+')'+z+'))'
    return rule(v,rule5(w,x,y,z))
def rule20(v,w,x,y,z):
    global k
    k='('+v+'(('+w+'('+x+y+'))'+z+'))'
    return rule(v,rule6(w,x,y,z))
def rule21(v,w,x,y,z):
    k='('+v+'('+w+'(('+x+y+')'+'))'+z+')'
    return rule(v,rule7(w,x,y,z))
def rule22(v,w,x,y,z):
    global k
    k='('+v+'('+w+'('+x+'('+y+z+'))))'
    return rule(v,rule8(w,x,y,z))
def rule23(v,w,x,y,z):
    global k
    k='((('+v+w+')'+x+')'+'('+y+z+'))'
    return rule2(rule(v,w),x,rule(y,z))
def rule24(v,w,x,y,z):
    global k
    k='(('+v+w+')('+x+'('+y+z+')))'
    return rule3(rule(v,w),x,rule(y,z))

print("     input:",end='')
str=input()
str=list(str)
x=[rule9,rule10,rule11,rule12,rule13,rule14,rule15,rule16,rule17,rule18,rule19,
   rule20,rule21,rule22,rule23,rule24]
for i in range(0,16):
    y=x[i](str[0],str[1],str[2],str[3],str[4])
    if(y=='a'):
        print("possible,",end=' ')
        print(k)
        break
    if(y!='a' and i==15):
        print("impossible")

---

当然，可以有更好的方法来解决您遇到的问题，而且您可能会了解到，一旦您看到其他人的分配解决方案，但关于您遇到的递归/动态问题，您在内存中的代码执行不是递归的

这绝对是一个线性动态规划，你在上面创建的

可以肯定的是，您还可以通过递归测试的实现对其进行测试：

因此，总体而言，您可以尝试使用此示例来进行测试：

from bdb import Bdb
import sys

class RecursionDetected(Exception):
    pass

class RecursionDetector(Bdb):
    def do_clear(self, arg):
        pass

    def __init__(self, *args):
        Bdb.__init__(self, *args)
        self.stack = set()

    def user_call(self, frame, argument_list):
        code = frame.f_code
        if code in self.stack:
            raise RecursionDetected
        self.stack.add(code)

    def user_return(self, frame, return_value):
        self.stack.remove(frame.f_code)

def test_recursion(func):
    detector = RecursionDetector()
    detector.set_trace()
    try:
        func()
    except RecursionDetected:
        return True
    else:
        return False
    finally:
        sys.settrace(None)

def rule(x,y):
    if((x=='a' and y=='c') or (x=='b' and y=='c') or (x=='c' and y=='a')):
        return 'a'

    if((x=='a' and y=='a') or (x=='a' and y=='b') or (x=='b' and y=='b')):
        return 'b'

    if((x=='b' and y=='a') or (x=='c' and y=='b') or (x=='c' and y=='c')):
        return 'c'
def rule2(x,y,z):
    return rule(rule(x,y),z)
def rule3(x,y,z):
    return rule(x,rule(y,z))
def rule4(w,x,y,z):
    return rule(rule(w,x),rule(y,z))
def rule5(w,x,y,z):
    return rule(rule2(w,x,y),z)
def rule6(w,x,y,z):
    return rule(rule3(w,x,y),z)
def rule7(w,x,y,z):
    return rule(w,rule2(x,y,z))
def rule8(w,x,y,z):
    return rule(w,rule3(x,y,z))
def rule9(v,w,x,y,z):
    global k
    k='((('+v+w+')'+x+')'+y+z+')'
    return rule(rule2(v,w,x),rule(y,z))
def rule10(v,w,x,y,z):
    global k
    k='(('+v+'('+w+x+'))('+y+z+'))'
    return rule(rule3(v,w,x),rule(y,z))
def rule11(v,w,x,y,z):
    global k
    k='(('+v+w+')(('+x+y+')'+z+'))'
    return rule(rule(v,w),rule2(x,y,z))
def rule12(v,w,x,y,z):
    global k
    k='(('+v+w+')('+x+'('+y+z+')))'
    return rule(rule(v,w),rule3(x,y,z))
def rule13(v,w,x,y,z):
    global k
    k='((('+v+w+')('+x+y+'))'+z+')'
    return rule(rule4(v,w,x,y),z)
def rule14(v,w,x,y,z):
    global k
    k='(((('+v+w+')'+x+')'+y+')'+z+')'
    return rule(rule5(v,w,x,y),z)
def rule15(v,w,x,y,z):
    global k
    k='((('+v+'('+w+x+')'+y+')'+z+'))'
    return rule(rule6(v,w,x,y),z)
def rule16(v,w,x,y,z):
    global k
    k='('+v+'('+w+'(('+x+y+')'+z+')))'
    return rule(rule7(v,w,x,y),z)
def rule17(v,w,x,y,z):
    global k
    k='('+v+'('+w+'('+x+'('+y+z+'))))'
    return rule(rule8(v,w,x,y),z)
def rule18(v,w,x,y,z):
    global k
    k='('+v+'(('+w+x+')('+y+z+')))'
    return rule(v,rule4(w,x,y,z))
def rule19(v,w,x,y,z):
    global k
    k='(('+v+'(('+w+x+')'+y+')'+z+'))'
    return rule(v,rule5(w,x,y,z))
def rule20(v,w,x,y,z):
    global k
    k='('+v+'(('+w+'('+x+y+'))'+z+'))'
    return rule(v,rule6(w,x,y,z))
def rule21(v,w,x,y,z):
    k='('+v+'('+w+'(('+x+y+')'+'))'+z+')'
    return rule(v,rule7(w,x,y,z))
def rule22(v,w,x,y,z):
    global k
    k='('+v+'('+w+'('+x+'('+y+z+'))))'
    return rule(v,rule8(w,x,y,z))
def rule23(v,w,x,y,z):
    global k
    k='((('+v+w+')'+x+')'+'('+y+z+'))'
    return rule2(rule(v,w),x,rule(y,z))
def rule24(v,w,x,y,z):
    global k
    k='(('+v+w+')('+x+'('+y+z+')))'
    return rule3(rule(v,w),x,rule(y,z))

print("     input:",end='')
str=input()
str=list(str)
x=[rule9,rule10,rule11,rule12,rule13,rule14,rule15,rule16,rule17,rule18,rule19,
   rule20,rule21,rule22,rule23,rule24]
for i in range(0,16):
    assert not test_recursion(lambda: x[i](str[0],str[1],str[2],str[3],str[4]))
    y = x[i](str[0],str[1],str[2],str[3],str[4])
    if(y=='a'):
        print("possible,",end=' ')
        print(k)
        break
    if(y!='a' and i==15):
        print("impossible")

---

请更详细地解释这项任务，并举例说明。另外，在你的课程中添加动态规划的定义。不要破坏你的帖子。通过在堆栈溢出上发布，您已授予站点分发该内容的不可撤销的权利（根据）。另见：