Python Graphics.showPuzzle方法代码示例

# 需要导入模块: import Graphics [as 别名]
# 或者: from Graphics import showPuzzle [as 别名]
def minConflicts(csp, variables):
    """
    Min-conflicts approach to solving the Sudoku puzzle
    """
    
    assignment, domains = csp  # Domains not applicable for this problem, but included for readability
    
    # Iterate through list, and randomly assign numbers
    for var in variables:

        # Randomly assign number
        num = random.randint(1,9)
        
        # Update the stack to include the new number, whether it works or not
        assignment[var[0]][var[1]] = num
    
    
    # Loop while the problem is not solved
    while variables != []:
        
        Graphics.showPuzzle(assignment)
        
        print variables
        
        # Randomly choose a variable from the list
        var = random.choice(variables)
        
        # Create value for least-conflict value
        bestValue, leastConstraints = None, sys.maxsize
        
        # Loop over possible domain values, and update best value if applicable
        for value in range(1,10):
            conflicts = countConflicts(assignment, var, value)
            if conflicts < leastConstraints:
                bestValue, leastConstraints = value, conflicts
        
        # Update the state with the new value
        assignment[var[0]][var[1]] = bestValue
        
        # If the variable does not violate any constraints, remove it from conflicted
        if leastConstraints == 0:
            variables.remove(var) 
            
    print "Solution Found!"
    
    return assignment

# 需要导入模块: import Graphics [as 别名]
# 或者: from Graphics import showPuzzle [as 别名]
def betterSimulatedAnnealing(csp, variables):
    """
    Better Min-conflicts with a factor of randomness approach. Schedule is a mapping of time to temperature
    """
    # Unpack the CSP
    assignment, domains = csp
    
    # Create Dictionary of conflicted variables and number of conflicts
    
    conflicted = {}
    
     # Iterate through list, randomly assign numbers, and add conflicted variables to array
    for var in variables:

        # Randomly assign number
        num = random.choice(domains[var])
        
        # Update the stack to include the new number, whether it works or not
        assignment[var[0]][var[1]] = num
        
    for var in variables:
        conflicted[var] = countConflicts(assignment, var, assignment[var[0]][var[1]])
        
    t = 1
    
    while assessValue(assignment) != 0 and t < 1000000:
        print "Completion =", 100-assessValue(assignment),"%"
        changingVar = random.choice(conflicted.keys())

        totalConflicts = assessValue(assignment)
        
        originalVal = assignment[changingVar[0]][changingVar[1]]
        newVal = random.choice(domains[changingVar])
         
        assignment[changingVar[0]][changingVar[1]] = newVal
        newTotalConflicts = assessValue(assignment)
        deltaE = newTotalConflicts - totalConflicts
        
        if deltaE > 0:
            if random.random() > P(deltaE, T(t)):
                #reset to original
                assignment[changingVar[0]][changingVar[1]] = originalVal
                
        Graphics.showPuzzle(assignment)
        t+=1
        for var in variables:
            conflicted[var] = countConflicts(assignment, var, assignment[var[0]][var[1]])
     
        
    if t != 1000000:
        Graphics.showPuzzle(assignment)    
        print "Solution Found!"
    
        return assignment
    else:
        Graphics.showPuzzle(assignment)
        print "Failed with Completion =", 100-assessValue(assignment),"%"
        return -1

# 需要导入模块: import Graphics [as 别名]
# 或者: from Graphics import showPuzzle [as 别名]
def simulatedAnnealing(csp, variables, schedule):
    """
    Min-conflicts with a factor of randomness approach. Schedule is a mapping of time to temperature
    """
    # Unpack the CSP
    assignment, domains = csp
    
    # Create list of conflicted variables
    conflictedList = []
    
    # Iterate through list, randomly assign numbers, and add conflicted variables to array
    for var in variables:

        # Randomly assign number
        num = random.randint(1,9)
        
        # Check if random number violates constraints, and add it to list if it does
        if not isConsistant(assignment, var, num):
            conflictedList.append(var)
        
        # Update the stack to include the new number, whether it works or not
        assignment[var[0]][var[1]] = num
    
    # Duplicate the variable for readability    
    current = assignment
    
    # Initialize time variable
    t = 1
    
    # Slowly increment the time
    while t < 100**100:
        
        # Set the temperature based on the passed schedule
        temp = schedule[t]
        
        # Cannot divide by zero - return the current assignment
        if temp == 0 or assessValue(current) == 0:
            return assignment
        
        # Randomly assign number
        num = random.randint(1,9)
        
        # Randomly choose a variable from the list
        (row, column) = random.choice(variables) 
        
        # Get the random successor state, and duplicate assignment
        prospective = assignment
        prospective[row][column] = num
        
        # Find the change in E
        valueChange = assessValue(current) - assessValue(prospective)
        
        # If there is a positive energy change, then update the current state
        if valueChange > 0:
            current = prospective
        else: 
            
            # With some probability (depending on change in E and temperature), step backwards
            if random.randint(1, math.e**(valueChange/temp)) == 1:
                current = prospective  
        
        Graphics.showPuzzle(assignment)
        
        # Increment time
        t += 1
    
    # Return failure
    return -1

# 需要导入模块: import Graphics [as 别名]
# 或者: from Graphics import showPuzzle [as 别名]
def recursiveBacktracking(csp, conflicted):   
    """
    Recursive backtracking function that takes a CSP of the form (assignment, domains),
    and a list of not yet set variables (for efficiency)
    """ 

    # If every variable is assigned, return assignment (solution)
    if not conflicted:
        return csp[0]
    
    # Unpack the CSP
    assignment, domains = csp
    
    # Enforce arc consistency
    modifiedDomains = AC3(domains) if GameController.arcConsistency else domains
    
    # Return failure if any of the domains are empty
    for v in modifiedDomains:
        if domains[v] == []:
            return -1
    
    # Update the domains
    domains = modifiedDomains
    
    # Show the puzzle to the screen
    Graphics.showPuzzle(assignment)
    
    # Pop a variable (without any kind of order)
    variable = conflicted.pop()
    
    # Assign row and column for readability
    row, column = variable
    
    # Loop through all values in the variable's domain
    for value in domains[variable]:
       
        # Check if adding the value would break a constraint
        if isConsistant(assignment, variable, value):
            
            # Update the assignment
            assignment[row][column] = value   
            
            # Implement forward checking, using the getArcs() method (not elegant, but reuses function)
            pruned = []
            for arc in getArcs(domains, variable, False):
                
                # Make sure forward checking is turned on
                if not GameController.forwardChecking:
                    continue
                
                # Get the connected variable, and its components
                var = arc[0]
                tailRow, tailColumn = var
                
                # Prune its domain, if it contains the value, and is not yet assigned
                if value in domains[var] and assignment[tailRow][tailColumn] == 0:
                    domains[var].remove(value)
                    pruned.append(var)               
                    
            # Create CSP tuple for recursive call            
            csp = (assignment, domains) 
            
            # Add the recursive call
            result = recursiveBacktracking(csp, conflicted)
            
            # Only return result if it is not failure
            if result != -1:
                return result
            
            # Reset the assignment
            assignment[row][column] = 0
                       
            # Reset forward-checking
            for var in pruned:
                domains[var].append(value)           
    
    # Add back the variable that was popped off
    conflicted.append(variable)  
    
    # If it is a dead-end, return failure      
    return -1

# 需要导入模块: import Graphics [as 别名]
# 或者: from Graphics import showPuzzle [as 别名]
            if value in initialDomains[arc[0]]:
                initialDomains[arc[0]].remove(value)

# Run initialization function 
init()

# Create CSP for readability
csp = (initialAssignment, initialDomains)

# Fill the schedule for simulated annealing
schedule = []
i = 0
while i < 100*100:
    schedule.append(i/100 + 1)
    i += 1
if GameController.simulatedAnnealing:
    solution = betterSimulatedAnnealing(csp, initialVariables)
else:
    # Run the selected algorithm with the puzzle
    solution = backtrackingSearch(csp, initialVariables) if GameController.backtrackingSearch else minConflicts(csp, initialVariables)

# Show the answer on the screen
Graphics.showPuzzle(solution)

# Pause until the user exits
while True:
    time.sleep(1)