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();
 intcx = value/ncol;
 intcy = 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");
+}