Merge branch 'master' into develop

Author: xtaci

Makefile

@@ -66,7 +66,9 @@ PROGRAMS =  m_based_demo \
 			scc_demo \
 			sort_demo \
 			bubble_sort_demo \
-			selection_sort_demo
+			selection_sort_demo	\
+			8queue_demo \
+			palindrome_demo
 
 all: $(PROGRAMS)
 

README.md

@@ -88,6 +88,8 @@
     K-Means
     Knuth–Morris–Pratt algorithm
     Disjoint-Set
+	8-Queue Problem
+	Palindrome
 
 ####贡献者 ( Contributors ) :  
     Samana :  for heavy work of MSVC compatability

include/8queen.h

@@ -0,0 +1,87 @@
+/*******************************************************************************
+ * DANIEL'1'S ALGORITHM IMPLEMENTAIONS
+ *
+ *  /\  |  _   _  ._ o _|_ |_  ._ _   _ 
+ * /--\ | (_| (_) |  |  |_ | | | | | _> 
+ *         _|                      
+ * 8-Queue 
+ *
+ * http://en.wikipedia.org/wiki/Eight_queens_puzzle
+ ******************************************************************************/
+
+#ifndef __8QUEEN_H__
+#define __8QUEEN_H__
+
+#include <stdio.h>
+#include <string.h>
+
+namespace alg {
+	class Queen8 {
+		private:
+			char board[8][8];
+			int cnt;
+		public:
+			void solve() {
+				memset(board, '0', sizeof(board));
+				cnt = 0;
+				_solve(0);
+			}
+		private:
+			void _solve(int row) {	// start from 0
+				int i;
+				for (i=0;i<8;i++) {
+					board[row][i] = '1';
+					if (check(row, i)) {
+						if (row == 7) print();
+						else _solve(row+1);
+					}
+					board[row][i] = '0';	// rollback
+				}
+			}
+
+			void print() {
+				printf("chessboard: %d\n",++cnt);
+				int i,j;
+				for (i=0;i<8;i++) {
+					for (j=0;j<8;j++) {
+						printf("%c ", board[i][j]);
+					}
+					printf("\n");
+				}
+			}
+
+			bool check(int row, int col) {
+				int i,j;
+
+				// cannot be same column
+				for (i=0;i<row;i++) {
+					if (board[i][col] == '1') {
+						return false;
+					}
+				}
+
+				// cannot be diagnal
+				i = row-1, j = col-1;
+				while (i>=0 && j >=0) {
+					if (board[i][j] == '1') {
+						return false;
+					}
+					i--;
+					j--;
+				}
+
+				i = row-1, j = col+1;
+				while (i>=0 && j <8) {
+					if (board[i][j] == '1') {
+						return false;
+					}
+					i--;
+					j++;
+				}
+
+				return true;
+			}
+	};
+}
+
+#endif //__8QUEEN_H__

include/astar.h

@@ -107,13 +107,14 @@ namespace alg {
 				as->path = NULL;
 				as->num_nodes = 0;
 
+				// the main A*algorithm
 				while(!m_openset.is_empty()) {
 					uint32_t value = m_openset.min_value();
 					int	cx = value/ncol;
 					int	cy = value%ncol;
 
-					if(cx == (int)x2 && cy==(int)y2) {	// we reached (x2,y2)
-						// reconstruct path & return
+					if(cx == (int)x2 && cy==(int)y2) {	// great! we've reached the target position (x2,y2)
+						// reconstruct path
 						as->num_nodes = 2;
 						uint32_t tmp = x2*ncol+y2;
 						while((tmp=came_from[tmp]) != x1*ncol+y1) {
@@ -135,47 +136,55 @@ namespace alg {
 						return as;
 					}
 
+					// delete current positon from openset and move it into closed set.
 					m_openset.delete_min();
 					m_closedset(cx, cy) = true;
 					m_openset_grid(cx, cy) = false;
 
-					// for each neighbor
+					// for each valid neighbor of current position
 					int nx, ny;
 					for(nx=cx-1;nx<=cx+1;nx++) {
-						if (nx<0 || nx>=(int)ncol) continue;
 						for(ny=cy-1;ny<=cy+1;ny++) {
-							if (ny<0 || ny>=(int)nrow) continue;
-
-							// except the wall;
-							if(m_grid(nx,ny) == WALL) continue;
+							// exclude invalid position
+							if (nx<0 || nx>=(int)ncol || ny<0 || ny>=(int)nrow) continue;
 							// except the cur itself
 							if(nx == cx && ny==cy) continue;
-							// if neighbour in the closed set	
+							// except the wall;
+							if(m_grid(nx,ny) == WALL) continue;
+							// exclude the neighbour in the closed set	
 							if(m_closedset(nx,ny)) continue;
 
+							// ok, we got a valid neighbour
 							float tentative = g_score(cx,cy);
-							if (nx == cx || ny == cy) {
-								tentative += 1 + m_grid(nx,ny);
-							} else {
-								tentative += (1 + m_grid(nx,ny)) * SQRT2;
+							if (nx == cx || ny == cy) {	// horizontal/vertical neighbour is near
+								tentative += 1;
+							} else { // diagonal neighbour is farther.
+								tentative += SQRT2;
 							}
 
 							// if neighbour not in the openset or dist < g_score[neighbour]	
 							if (!m_openset_grid(nx,ny) || tentative < g_score(nx,ny)) {
-								came_from[nx*ncol+ny] = cx*ncol+cy; // record path
-								g_score(nx,ny) = tentative;
-								f_score(nx,ny) = tentative + estimate(nx,ny,x2,y2);
-								if (!m_openset_grid(nx,ny)) {
+								came_from[nx*ncol+ny] = cx*ncol+cy; // record the path
+								g_score(nx,ny) = tentative;			// update path cost for current position
+								f_score(nx,ny) = tentative + estimate(nx,ny,x2,y2);	// record path cost to this neighbour
+								if (!m_openset_grid(nx,ny)) {	// only insert the neighbour if it hasn't been add to the openset.
 									m_openset.insert(f_score(nx,ny), nx*ncol+ny);
 									m_openset_grid(nx,ny) = true;
 								}
 							}
 						}
 					}
 				}
+
+				// haven't reached target
 				return as;
 			}
 		private:
+			/**
+			 * Estimate the cost for going this way, such as:
+			 * acrossing the swamp will be much slower than walking on the road.
+			 * design for you game.
+			 */
 			inline float estimate(int x1, int y1, int x2, int y2) const {
 				return sqrtf((x2-x1) * (x2-x1) + (y2-y1)*(y2-y1));
 			}

include/palindrome.h

@@ -0,0 +1,79 @@
+/*******************************************************************************
+ * DANIEL'S ALGORITHM IMPLEMENTAIONS
+ *
+ *  /\  |  _   _  ._ o _|_ |_  ._ _   _ 
+ * /--\ | (_| (_) |  |  |_ | | | | | _> 
+ *         _|                      
+ *
+ * PALINDROMES
+ *
+ * WORDS LIKE:
+ * 	RACECAR	DEED	LEVEL	PIP
+ * 	ROTOR	CIVIC	POP		MADAM
+ * 	EYE		NUN		RADAR	TOOT
+ * 
+ * This program will find the longest part of mirror.
+ *
+ * http://en.wikipedia.org/wiki/Palindrome
+ ******************************************************************************/
+
+#ifndef _PALINDROME_H_
+#define _PALINDROME_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+namespace alg {
+	static void palindrome(const char * S) {
+		char *R= strdup(S);
+		int len = strlen(S);
+		// reverse
+		for(int i=0;i<len;i++) {
+			R[len-i-1] = S[i];
+		}
+
+		int middle = 0;
+		int maxlen = 0;
+		for(int i=0;i<len;i++) {
+			// compare S[0:i] with R[0:length-i-1] in reverse order
+			int offset = 0;
+			int curlen = 0;
+
+			// try odd
+			while (i-offset>= 0 && len-i-1-offset >= 0) {
+				if (S[i-offset] == R[len-i-1-offset]) {
+					curlen++;
+				} else {
+					break;
+				}
+				offset++;
+			}
+
+			if (curlen > maxlen) {
+				maxlen = curlen;
+				middle = i;
+			}
+
+			// try even
+			while (i-offset>= 0 && len-i-2-offset >= 0) {
+				if (S[i-offset] == R[len-i-2-offset]) {
+					curlen++;
+				} else {
+					break;
+				}
+				offset++;
+			}
+
+			if (curlen > maxlen) {
+				maxlen = curlen;
+				middle = i;
+			}
+		}
+
+		printf("str:%s len:%d middle:%d\n",S, maxlen, middle);
+		free(R);
+	}
+}
+
+#endif //

include/quick_sort.h

@@ -19,42 +19,63 @@
 #define __QUICKSORT_H__
 
 #include <generic.h> 
+#include <cassert>
 
 namespace alg {
+
+	/**
+     * Return median of begin, middle, and end.
+	 * Order these and hide the pivot.
+     */
+	template<typename T>
+	static const T & __median3(T list[], int begin, int end) {
+		assert(begin + 2 <= end);
+		int middle = end - (end - begin) / 2;
+		if (list[middle] < list[begin])
+			swap(list[middle], list[begin]);
+		if (list[end] < list[begin])
+			swap(list[end], list[begin]);
+		if (list[end] < list[middle])
+			swap(list[end], list[middle]);
+	
+		//Place pivot at position [end - 1]
+		swap(list[middle], list[end - 1]);
+		return list[end - 1];
+	}
+	
 	/**
 	 * the quick-sort partition routine
 	 */
 	template<typename T>
 		static int __partition(T list[],int begin, int end) {
-			int pivot_idx = RANDOM(begin,end);
-			T pivot = list[pivot_idx];
-			swap(list[begin], list[pivot_idx]);
-
-			int i = begin + 1;
-			int j = end;
-
-			while(i <= j) {
-				while((i <= end) && (list[i] <= pivot))
-					i++;
-				while((j >= begin) && (list[j] > pivot))
-					j--;
+			T pivot = __median3<T>(list, begin, end);
+
+			int i = begin;
+			int j = end - 1;
+
+			while(i < j) {
+				while(list[++i] < pivot) {}
+				while(pivot < list[--j]) {}
 				if(i < j)
 					swap(list[i],list[j]);
 			}
 
-			swap(list[begin],list[j]);
-			return j; // final pivot position
+			swap(list[i],list[end - 1]);
+			return i; // final pivot position
 		}
 
 	/**
 	 * quick sort an array of range [begin, end]
 	 */
 	template<typename T>
 		static void quicksort(T list[],int begin,int end) {
-			if( begin < end) {
+			if( begin + 1 < end) {
 				int pivot_idx = __partition<T>(list, begin, end);
 				quicksort(list, begin, pivot_idx-1);
 				quicksort(list, pivot_idx+1, end);
+			} else if ( begin + 1 == end) {
+				if (list[begin + 1] > list[end])
+					swap(list[begin + 1], list[end]);
 			}
 		}
 }

include/scc.h

@@ -38,15 +38,15 @@ namespace alg {
 		// step 1. discover vertices of G in decreasing of u.f
 		Heap<int32_t> Q(g.vertex_count()) ;
 		Graph::Adjacent * a;
-        list_for_each_entry(a, &g.list(), a_node) {
+		list_for_each_entry(a, &g.list(), a_node) {
 			Q.insert(INT_MAX - a->f, a->v.id);	// descending order of a->f
-        }
+		}
 
 		// step 2. discover 
-        // mark all vertex color to WHITE   
-        list_for_each_entry(a, &GT->list(), a_node) {
-            a->color = Graph::WHITE;
-        }
+		// mark all vertex color to WHITE   
+		list_for_each_entry(a, &GT->list(), a_node) {
+			a->color = Graph::WHITE;
+		}
 
 		// step 3. call DFS(GT), but in the main loop of DFS, consider the vertices
 		// in order of decreasing u.f (as computed in line 1)

src/8queue_demo.cpp

@@ -0,0 +1,8 @@
+#include <stdio.h>
+#include <8queen.h>
+
+int main(void) {
+	alg::Queen8 q;
+	q.solve();
+}
+

src/palindrome_demo.cpp

@@ -0,0 +1,8 @@
+#include "palindrome.h"
+#include <stdio.h>
+
+int main() {
+	alg::palindrome("banana");
+	alg::palindrome("abba");
+	alg::palindrome("aaaaa");
+}