一些有趣的算法

本文专门记录一些有趣的算法。

计算二进制数中1的个数

这道题目的一个解决方案是通过％2来计算，这个比较简单。现在推荐一个快速算法，利用

n=n&(n-1);

来计算,可以这么解释这个运算的作用：一个数减1以后与自身相与，就消去了最低位的1。对于一个数而言，最后一位如果是1，减1之后前面的位并不受影响，该位的1已经被纳入统计；而如果是0，减1之后该位为1，1&0=0，该位并不受影响，但这带动了前面减1的过程，从而计算前面的位中1的个数。而只要统计过的位数，该位在之后运算中一定为0。所以，其实这个算法是从最低位到最高位按位统计1的个数的。

例题

计算两个int32整数m和n的二进制表达，有多少个位(bit)不同？

解法

public int countBitDiff(int m, int n) {

int dif=m^n;   //先将二者做异或运算，得到结果；
int cnt=0;     //这里将不同的位转换成计算1的个数
while(dif!=0){
dif=dif&(dif-1);
cnt++;
}              //统计一个整数dif含有多少个1；
return cnt;
}

此题引申自计算二进制数中有多少个1

/*
* 原理：若n最右边的1在第k个位置，那么n-1之后，第k个位置的数由1变0，k之后的由0变1，k之前的不变。
* 再把n-1和n求& ，会把该整数最右边的1变为0。因此有多少个1，就循环几次。
*/
public int count1(int n) {
//System.out.println(Integer.toBinaryString(n) );
int count = 0;
while (n != 0) {
count++;
n = n & (n - 1);
}

return count;
}

迷宫算法

迷宫算法属于一种空间路径方法，可以使用深度优先遍历或者广度优先遍历

深度优先是按照一定的顺序查找完一个分支，再查找另外一个分支，直到找到目标为止。

下面以一个实际的迷宫地图，来看一下深度优先算法在程序中如何实现。迷宫的布局如图二。



游戏规则是：

有一个起始点和终止点，分别位于图中的左上角和右下角。迷宫中白色方格是可通过区域，黑色方格是不可通过区域，迷宫以外的区域也是不可通过区域。

算法思想：

首先定义一些变量来记录游戏中的状态信息：

二维数组：block：记录迷宫的布局。0为可通过，1代表不可通过。

dx、dy：记录移动的方向：左、右、上、下四种情况下x、y坐标需要做的更改。

table二维数组：记录某个坐标上的方格是否到达过。

函数解释：

test：判断是否已经达到目标位置

actOK：判断当前移动方向是否合理，排除不合理的情况：越界、是否有障碍等等。

back：当前路径无法继续下去，执行回退操作，更改相应变量。

DFS：核心函数，执行深度优先遍历操作。在每一个方格点A处，接下来都有4种走法，针对4种方向，依次判断，如果第一种方向合理，则移动到下一格，进行相同的操作。如果继续下去不能走到终点，则最终回退到方格点A，继续第二种方向，重复操作。如果4中方向都无法达到目标，则搜寻失败。

迷宫算法之深度优先搜索

//迷宫寻路：深度优先算法

#include <iostream>

using namespace std;

const int width = 10;//宽度
const int height = 10;//高度
//四种移动方向(左、右、上、下)对x、y坐标的影响
//x坐标：竖直方向，y坐标：水平方向
int dx[4] = {0,0,-1,1};
int dy[4] = {-1,1,0,0};

//障碍表
int block[height][width] = {
0,1,0,0,0,0,0,0,0,0,
0,1,1,0,1,1,1,0,0,0,
0,0,0,0,0,0,0,0,0,0,
1,1,1,0,1,0,0,0,0,0,
0,1,0,0,1,0,1,1,1,0,
0,1,0,0,1,1,1,1,1,0,
0,0,0,1,1,0,0,0,1,0,
0,1,0,0,0,0,1,0,1,0,
0,1,1,1,0,1,1,0,1,1,
0,0,0,0,0,0,1,0,0,0,
};

const int maxLevels = 1000;//最大移动步数
int maxAct = 4;//移动方向总数
int table[width][height] = {0};//标记是否已达到
int level = -1;//第几步
int levelComplete = 0;//这一步的搜索是否完成
int allComplete = 0;//全部搜索是否已完成
int Act[maxLevels] = {0};//每一步的移动方向（1、2、3、4）

int x = 0,y = 0;//现在的坐标
int targetX = height - 1,targetY = width - 1;//目标坐标

void test()//测试是否已达到目标
{
if (x == targetX && y == targetY)
{
levelComplete = allComplete = 1;
cout << "Get to destination Success" << endl;
}
}

int actOK()//判断移动方向是否合理
{
int nextX = x + dx[Act[level] - 1];
int nextY = y + dy[Act[level] - 1];

if (Act[level] > maxAct)//方向是否错误
return 0;
if(nextX >= height || nextX < 0)//x坐标是否越界
return 0;
if(nextY >= width || nextY < 0)//y坐标是否越界
return 0;
if(table[nextX][nextY] == 1)//是否已达到过
return 0;
if(block[nextX][nextY] == 1)//是否有障碍
return 0;

x = nextX;
y = nextY;//移动
table[nextX][nextY] = 1;//标记已达到
return 1;
}

void back()
{
table[x][y] = 0;
x -= dx[Act[level - 1] - 1];
y -= dy[Act[level - 1] - 1];//回退到原来的坐标
Act[level] = 0;//清除方向
--level;//回到上一层
}

//深度优先搜索
void DFS()
{
table[x][y] = 1;
while(!allComplete)
{
++level;//搜索下一步
levelComplete = 0;//这一步的搜索还未完成
while(!levelComplete)
{
++Act[level];//改变移动方向
if (actOK())//方向合理
{
test();
levelComplete = 1;//该步搜索完成
}
else
{
if (Act[level] > maxLevels)//已经搜索完所有方向
{
back();//回退,到上一个分支
}
if (level < 0)//全部搜索完，仍然没有搜索到目标
{
levelComplete = allComplete = 1;//退出
}
}
}
}
}

void print()
{
cout << "The path is " << endl;
for (int i = 0;i < height;++i)
{
for (int j = 0;j < width;++j)
{
/*cout << table[i][j] << " ";*/
if(table[i][j])
cout << "1 ";
else cout << "  ";
}
cout << endl;
}
}

int main(){
DFS();
print();
}

迷宫算法之广度优先搜索

广度优先搜索算法思想：

在这里采用一个辅助数据结构：队列。

（1）顶点v入队列。

（2）当队列非空时则继续执行，否则算法结束。

（3）出队列取得队头顶点v；访问顶点v并标记顶点v已被访问。

（4）查找顶点v的第一个邻接顶点col。

（5）若v的邻接顶点col未被访问过的，则col入队列。

（6）继续查找顶点v的另一个新的邻接顶点col，转到步骤（5）。直到顶点v的所有未被访问过的邻接点处理完。转到步骤（2）

//迷宫寻路：广度优先搜索
#include <iostream>
using namespace std;

const int rows = 10;//行数
const int cols = 10;//列数
const int numDirections = 4;//每一步，下一步可以走的方向：4个

//四种移动方向(左、右、上、下)对x、y坐标的影响
//x坐标：竖直方向，y坐标：水平方向
const char dx[numDirections] = {0,0,-1,1};
const char dy[numDirections] = {-1,1,0,0};

//障碍表
char block[rows][cols] = {
0,1,0,0,0,0,0,0,0,0,
0,1,1,0,1,1,1,0,0,0,
0,0,0,0,0,0,0,0,0,0,
1,1,1,0,1,0,0,0,0,0,
0,1,0,0,1,0,1,1,1,0,
0,1,0,0,1,1,1,1,1,0,
0,0,0,1,1,0,0,0,1,0,
0,1,0,0,0,0,1,0,1,0,
0,1,1,1,0,1,1,0,1,1,
0,0,0,0,0,0,1,0,0,0,
};

char path[rows][cols] = {0};//记录路径

int startX = 0,startY = 0;//起始点坐标
int endX = rows - 1,endY = cols - 1;//目标点坐标

//保存节点位置坐标的数据结构
typedef struct tagQNode{
char x,y;
int parentNode;//父节点索引
}QNode;

//打印路径
void printPath()
{
cout << "Success : the path is " << endl;
for (int i = 0;i < rows;++i)
{
for (int j = 0;j < cols;++j)
{
if (1 == path[i][j])
{
cout << "1 ";
}
else
cout << "  ";
}
cout << endl;
}
}

void BFS()
{
int num = rows * cols;
//利用数组来模拟队列
QNode *queue = (QNode *)malloc(num * sizeof(QNode));
//起始点入队列
queue[0].x = queue[0].y = 0;
queue[0].parentNode = -1;//起始点没有父节点

int front = 0,rear = 1;//队列的头和尾
while(front != rear)//队列不为空
{
for (int i = 0;i < numDirections;++i)
{
char nextX,nextY;//下一步的坐标
nextX = queue[front].x + dx[i];
nextY = queue[front].y + dy[i];
//下一个节点可行
if (nextX >= 0 && nextX < rows &&
nextY >= 0 && nextY < cols &&
0 == block[nextX][nextY])
{
//寻找到目标点
if (nextX == endX && nextY == endY)
{
//生成路径
path[nextX][nextY] = 1;
int tempParentIndex = front;
while(tempParentIndex != -1)
{
path[queue[tempParentIndex].x][queue[tempParentIndex].y] = 1;
tempParentIndex = queue[tempParentIndex].parentNode;
}
printPath();
}
//入栈
queue[rear].x = nextX;
queue[rear].y = nextY;
queue[rear].parentNode = front;
++rear;
//标记此点已被访问
block[nextX][nextY] = 1;
}
}
++front;
}
}

int main()
{
BFS();

//printPath();
}