https://github.com/sdasgup3/parallel-sudoku

Parallel Sudoku Implementation using Charm++
https://github.com/sdasgup3/parallel-sudoku

charmplusplus constraints domain-decomposition graph-algorithms graph-coloring loadbalancing processor state-space-search sudoku-solver vertices

Last synced: 11 days ago
JSON representation

Parallel Sudoku Implementation using Charm++

• Host: GitHub
• URL: https://github.com/sdasgup3/parallel-sudoku
• Owner: sdasgup3
• Created: 2014-09-18T06:03:18.000Z (over 10 years ago)
• Default Branch: master
• Last Pushed: 2014-12-15T06:18:54.000Z (about 10 years ago)
• Last Synced: 2023-08-30T08:15:26.547Z (over 1 year ago)
• Topics: charmplusplus, constraints, domain-decomposition, graph-algorithms, graph-coloring, loadbalancing, processor, state-space-search, sudoku-solver, vertices
• Language: C
• Homepage:
• Size: 15.4 MB
• Stars: 1
• Watchers: 6
• Forks: 6
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
Parallel Graph Coloring

=========================

The graph coloring problem deals with assigning each vertex of the graph with a color such that the adjacent vertices have distinct colors. Many applications have been shown to be reducible to the graph coloring problem. Some of these include 1) register allocation in the back-end of a complier, and 2) scheduling of multiple tasks to resources under various constraints. Graph coloring is computationally hard. It is NP-complete to determine if a given graph admits k-coloring (except for k=1 or k=2).

State space search is a technique where successive configurations (a.k.a states) are explored until the state with desired property is found. The different states form a tree where child nodes are produced from the parent node by changing some part of the parent state. In typical problems, exploring the entire state space graph is impractical due to execution time and memory constraints. Application of heuristics has been shown to be effective in pruning the search space.

Large-scale systems with distributed memory are a natural fit to solving the

computationally complex graph coloring problem. There are two main

parallelization strategies, namely domain decomposition and state space

exploration. In domain decomposition, the graph is divided into sub-graphs, and

each of these is assigned to a processor. The sub-graph is colored locally at

each processor. The algorithm operates in time-steps, where at the end of each

time-step, the processors exchange coloring information with each other to

resolve the conflicts for the vertices on the sub-graph boundaries. State space exploration takes a

different approach to dividing work between processors. A state in the

state space tree is a partially colored input graph, and child states are

produced from parent states by coloring one of the uncolored vertices. A

solution is found if one of the leaves if a legitimately colored input graph.

Each processor is responsible for exploration of a part of the state space

tree.

ParallelSudoku (An application of graph coloring)

===================================================

https://fenix.tecnico.ulisboa.pt/downloadFile/3779576294079/projSudoku.pdf

http://www.andrew.cmu.edu/user/hmhuang/project_template/finalreport.html

http://alitarhini.wordpress.com/2011/04/06/parallel-depth-first-sudoku-solver-algorithm/