解决数独问题用人工智能还是量子计算?

#Forthesakeofcaluclationwetakerowsasalphaneumericandcolumnsasnumeric.
rows='ABCDEFGHI'columns='123456789'boxes= [r+cforrinrowsforcincolumns] #everypossiblecellcombinationinthegrid.
defgrid_values(grid):
"""Take in the Unsolved Sudoku Sequence and replaces the unsolved boxes initially with allpossible values which can get into that cell. Lastly returns a dictionary containing thevalues at all cell positions along with cells."""values= []
every_digits='123456789'forningrid:
ifc=='.':   #replacingeveryunsolvedvaluewitheverypossiblevalueinitially.
values.append(every_digits)
else:         #ifalreadysolved, causingitnochange.
values.append(c)
assertlen(values) ==81returndict(zip(boxes, values)) #returningthesudokugridwithallpossiblecellvalues.

columns_reversed=columns[::-1] #reversingthecolumnsforcalculatingtheDiagonalUnits.
defmake_combinations(m, n):
"""Takes in input of generally iterables and creates all possible combintation out of them.args:a: string iterableb: string iterablereturn : list of all possible combination."""return [x+yforxinmforyinn]
row_units= [make_combinations(r, columns) forrinrows]
column_units= [make_combinations(rows, c) forcincolumns]
sub_square_units= [make_combinations(m, n) formin ('ABC', 'DEF', 'GHI')
fornin ('123','456','789')]
diagonal_1_units= [[rows[i]+columns[i] foriinrange(len(rows))]]
diagonal_2_units= [[rows[i]+columns_reversed[i] foriinrange(len(rows))]]
diagonal_units=diagonal_1_units+diagonal_2_unitsall_units=row_units+column_units+square_units+diagonal_unitsunits=dict((b, [uforuinall_unitsifbinu]) forbinboxes)
peers=dict((b, set(sum(units[b], [])) - {b}) forbinboxes)
defeliminate(values):
"""Eliminate the redundant numbers from the unsolved cells if the number already appeared oncein the peer of the current cell.What we do here is we erase that redundant number from the unsolved value cells if appeared once."""solved_cells= [boxforboxinvalues.keys() iflen(values[box]) ==1] #cellissolvedifthere's only one digitfor box in solved_cells:value_at_cell = values[box]   # retrieve the current value at that cell.for peer in peers[box]:       # check for the cell'speersifthevalueappearsagain.
values[peer] =values[peer].replace(value_at_cell, '')
returnvalues#returnthemodifiedvaluesdictionary.

defonly_choice(values):
"""If in order to satisfy the constraints of the Sudoku Puzzle there is only a single viable optionwe fill in the Cell with that option only and thereby obtain a solve for the cell."""forunitinall_units:     #searchingacrossallthevicinityofthecell.
fordigitin'123456789':  
to_be_filled= [cellforcellinunitifunitinvalues[unit]]
iflen(to_be_filled) ==1: #ifthereexistsonlyasinglecellintheunitwhichisnotsolvedvalues[to_be_filled[0]] =digit#Wefillinthecellwithitsproperanswer.    
returnvalues

defnaked_twins(values):
"""If there are two unsolved cells in a same unit exist such that it can only be filled by onlytwo specific digits, then those two digits can be safely removed from all other cells in the same unit."""twins_possible= [unitforunitinvalues.keys() iflen(values[unit]) ==2]  
twins= [[unit1, unit2] forunit1intwins_possibleforunit2inpeers[unit1]
ifset(values[unit1]) == (set(values[unit2]))]   #confimedNakedTwinsfortwinintwins:
unit1=twin[0]
unit2=twin[2]
peers1=set(peers[unit1])  
peers2=set(peers[unit2])
common_peers=peers1&peers2#findingtheintersectionbetweenthepeersofthetwonakedtwinelementforpeerincommon_peers:
iflen(values[peer]) >1:
forvalueinvalues[unit1]:
values[peer] =values[peer].replace(val, '')) #Erasingthevalues.
returnvalues

defreduce_puzzle(values):
"""Applying the 4 Constraint Satisfaction Algorithms until it is not further reducible.Checking if the Number of Solved Cells between the iteration."""solved_values= [unitforunitinvalues.keys() iflen(values[unit]) ==1] #consideringsolvedcellsstuck=False#booleanflagtodeterminetheendofloopwhilenotstuck:
prev_solved_values=len([unitforunitinvalues.keys() iflen(values[unit]) ==1]) #checkpoint1values=eliminate(values) #applyingEliminationCSPvalues=only_choice(values) #applyingOnlyChoiceCSPvalues=naked_twins(values) #applyingNakedTwinsCSPafter_solved_values=len([unitforunitinvalues.keys() iflen(values[unit]) ==1])
stuck=after_solved_values==prev_solved_values#Gettingoutofloopisthenumberofsolvedcellisstillthesameasthepreviousiteration.
iflen([unitforunitinvalues.keys() iflen(values[unit]) ==0]):
returnFalse#ifthere's problems in the internal representation of the sudoku grid return False.return values# return the reduced grid values.

defsearch(values):
"""Recursive Depth-First Search: If the sudoku grid is not further reducible by constraint satisfactiona few of the cells will be left with different options and with DFS with search for the optimalvalues for those yet-unsolved cells.  """values=reduce_puzzle(values) #WecalltheReductionFunctiontoreducethepuzzlefurtherbasedonthesearchresultsacrossiterations.
ifvaluesisFalse:
returnFalseifall(len(values[b]) ==1forbinboxes):
print("Sudoku Problem Solved!")
returnvaluesm, n=min((len(values[b]), b) forbinboxesiflen(values[b]) >1)
forvalueinvalues[n]:
new_sudoku=values.copy()
new_sudoku[n] =valueattempted=search(new_sudoku)
ifattempted:
returnattempted

defdisplay(values):
"""Display the values as a 2-D grid.Input: The sudoku in dictionary form"""width=1+max(len(values[b]) forbinboxes)
line='+'.join(['-'* (width*3)] *3)
forrinrows:
print(''.join(values[r+c].center(width) + ('|'ifcin'36'else'')
forcincols))
ifrin'CF':
print(line)
return

if__name__=="__main__":
diag_sudoku_grid='2.............62....1....7...6..8...3...9...7...6..4...4....8....52.............3'values=grid_values(diag_sudoku_grid)
values=reduce_puzzle(values)
values=search(values)
display(values)

python-mpipinstall--upgradepippipinstalldwave-ocean-sdk

importdimodimportmathimportsysimportdimod.generators.constraintsimportcombinationsfromhybrid.referenceimportKerberosSamplerdefprettify(row, col, digit):
return"{row}, {col}_{digit}".format(row, col, digit)
defread_matrix(filename):
withopen(filename, 'r') asf:
all_lines=f.read()
lines= []
forlineinall_lines:
new_line=line.rstrip()
ifnew_line:
new_line=list(map(int, new_line.split(' ')))
lines.append(new_line)
returnlinesdefsanity_check(matrix):
n=len(matrix)
m=int(math.sqrt(n))
unique_digits=set(range(1, 1+n))
forrowinmatrix:
ifset(row) !=unique_digits:
print("Error in row", row)
returnfalseforjinrange(n):
col= [matrix[i][j] foriinrange(n)]
ifset(col) !=unique_digits:
print("Error in column", col)
subsquare_idx= [(i, j) foriinrange(m) forjinrange(m)]
forr_scalarinrange(m):
forc_scalarinrange(m):
subsquare= [matrix[i+r_scalar*m ][j+c_scalar*m] fori, jinsubsquare_idx]
ifset(subsquare) !=unique_digits:
print('Error in sub-square', subsquare)
returnTruereturnTrue

defmain():
iflen(sys.argv) >1:
filename=sys.argv[1]
matrix=read_matrix(filename)
n=len(matrix)
m=int(math.sqrt(n))
digits=range(1, n+1)
bqm=dimod.BinaryQuadraticModel({}, {}, 0.0, dimod.SPIN)
forrowinrange(n):
forcolinrange(n):
node_digits= [prettify(row, col, digit) fordigitindigits]
one_digit_bqm=combinations(node_digits, 1)
bqm.update(one_digit_bqm)
forrowinrange(n):
fordigitindigits:
row_nodes= [prettify(row, col, digit) forcolinrange(n)]
row_bqm=combinations(row_nodes, 1)
bqm.update(row_bqm)
forcolinrange(n):
fordigitindigits:
col_nodes= [prettify(row, col, digit) forrowinrange(n)]
col_bqm=combinations(col_nodes, 1)
bqm.update(col_bqm)
if__name__=="__main__":
main()