过河卒算法java实现

❶ 过河卒，24点 pascal语言程序。（我是初学者写的易懂点 能省过程、函数尽量省）

program E1_1; {knight}
const
dx:array[1..8] of integer=(-2,-1,1,2,2,1,-1,-2);
dy:array[1..8] of integer=(1,2,2,1,-1,-2,-2,-1);
这个就是传说中的增量矩阵。其实也没那么神秘，就是一张表，有8种变化状态，每种状态对应了一个delta
x和y，比如第一种变化，x坐标减小2，y坐标加1。表示在棋盘上的8种行走方式。
var
n,m,x,y,i,j: byte;
g:array[0..20,0..20] of 0..1;
c:longint;
infile,outfile:text;
//这边是关键步骤
procere sol(x,y:integer);
var i:integer;
begin
if (x=n) and (y=m) then c:=c+1（当前x,y坐标都为目标坐标，那么总路径c +1，c为统计的路径条数） else
begin//深搜，只有2个法则，向上y+1,向左x+1。并且判断有没有出界。
if (y<m) and (g[x,y+1]=0) then sol(x,y+1);
if (x<n) and (g[x+1,y]=0) then sol(x+1,y);
end;
end;

begin
assign(infile,'knight.in');
assign(outfile,'knight.out');
reset(infile);
readln(infile,n,m,x,y);
close(infile);

g[x,y] := 1;
for i:=1 to 8 do
if (x+dx[i]>=0) and (x+dx[i]<=n) and (y+dy[i]>=0) and (y+dy[i]<=m) then
g[x+dx[i],y+dy[i]]:=1;//给地图赋值，0为可走，1为被马控制，如g[1,1]=1说明坐标（1，1）点被控制了。
sol(0,0);//从坐标（0，0）开始走。

rewrite(outfile);
writeln(outfile,c);
close(outfile);
end.
/----------------------------------------------------/
type arr=array [1..4] of integer;
var i,result,n,len:integer;
d:arr;
r:array [1..3,1..4] of integer;
procere print; //打答案用的，r[i,1],r[i,3]为运算数字,r[i,2]为运算符，r[i,4]为答案
var i,j:integer;
begin
assign(output,'point.out'); rewrite(output);
for i:=1 to 3 do
begin
for j:=1 to 3 do
if j<>2 then write(r[i,j])
else case r[i,j] of
1:write('+');
2:write('-');
3:write('*');
4:write('/')
end;
writeln('=',r[i,4])
end;
close(output);
end;
procere try(k:integer;var d:arr); //枚举，d数组暂存结果
var a,b,i,j,l,t:integer;
e:arr;
begin
if k=1 then
if d[1]=24 then begin print;halt end
else
else begin
for i:=1 to k-1 do
for j:=i+1 to k do
begin
a:=d[i]; b:=d[j]; //枚举要用的两个数
if a<b then begin t:=a;a:=b;b:=t end;
t:=0;
for l:=1 to k do if (l<>i) and (l<>j) then begin t:=t+1;e[t]:=d[l] end; //将剩下的数放好
r[5-k,1]:=a;
r[5-k,3]:=b;
r[5-k,4]:=-1;
for l:=1 to 4 do //枚举运算符
begin
case l of
1:r[5-k,4]:=a+b;
2:r[5-k,4]:=a-b;
3:r[5-k,4]:=a*b;
4:if b<>0 then if a mod b=0 then r[5-k,4]:=a div b
end;
r[5-k,2]:=l;
if r[5-k,4]<>-1 then
begin
e[t+1]:=r[5-k,4];
try(k-1,e)
end
end
end
end;
end;
begin
assign(input,'point.in');reset(input);
for i:=1 to 4 do read(d[i]);
close(input);
try(4,d);
assign(output,'point.out');rewrite(output);
writeln('No answer!');
close(output);
end.

❷ 两段简单pascal程序求算法分析【急！！】

两个都是经典题。

第一题：最大连续子段和，DP。f(i)表示1~i的以i结尾的最大连续子段和是多少（也就是你程序中的t）。那么当f(i)<0的话，显然下一个数就不要与f(i)连起来了，为什么呢？比如说，现在数列的1 -3 1。那么f(2)=-2。这时候算f(3)的话，显然f(3)=1比f(3)=-2+1=-1优。最后答案就是所有f(i)的最大值。

第二题：还是DP。先把兵不能走的地方标记出来（也就是马能到的地方）（也就是程序中的b数组）。然后f(i,j)表示兵走到(i,j)这个格子的方案数（也就是程序中的a数组）。那么f(i,j)=f(i-1,j)+f(i,j-1)。因为只有(i-1,j)和(i,j-1)可以走到(i,j)这个格子。最后就输出f(n,m)就可以了。

❸ 我用java写了一个商人过河的程序，但是有一个错误，大家帮我找一下

if((isavilable(a,stage[i],b))&&(mark[i]!=0))

❹ 用java实现野人传教士过河问题

//CrossRiverQuestion.java
importjava.util.ArrayList;
importjava.util.List;

publicclassCrossRiverQuestion{
publicstaticvoidmain(String[]args){
CrossRiverQuestionq=newCrossRiverQuestion(5,4);
q.solveQuestion();
}
privateintpeoNum;
privateintsavageNum;
privateList<Node>resultList=newArrayList<Node>();
publicList<Node>solveQuestion(){
Noden=newNode(peoNum,savageNum,0,0,0,newArrayList<Integer>(),0,0);
booleandfsResult=dfs(n);
if(dfsResult){
resultList.add(0,n);
for(Nodenode:resultList){
System.out.println("左岸传教士："+node.getLeftPeo()+"左岸野人："+node.getLeftSavage()+"右岸传教士："+node.getRightPeo()+"右岸野人："+node.getRightSavage()+"船上传教士："+node.getOnBoatPeoNum()+"船上野人："+node.getOnBoatSavageNum());
}
returnresultList;
}
returnnull;
}

publicCrossRiverQuestion(intpeoNum,intsavageNum){
super();
this.peoNum=peoNum;
this.savageNum=savageNum;
}

privatebooleandfs(Noden){
if(n.hasVisited())returnfalse;
n.addCheckSum();
if(n.getLeftPeo()==0&&n.getLeftSavage()==0)returntrue;
if(n.getLeftPeo()<0||n.getRightPeo()<0||n.getLeftSavage()<0||n.getRightSavage()<0){
returnfalse;
}
if(n.getLeftPeo()<n.getLeftSavage()&&n.getLeftPeo()>0)returnfalse;
if(n.getRightPeo()<n.getRightSavage()&&n.getRightPeo()>0)returnfalse;
if(n.getCURR_STATE()==n.getStateBoatLeft()){
Noden1=newNode(n.getLeftPeo()-1,n.getLeftSavage()-1,n.getRightPeo()+1,n.getRightSavage()+1,n.getStateBoatRight(),n.getNodesCheckSum(),1,1);
if(dfs(n1)){
resultList.add(0,n1);
returntrue;
}
Noden4=newNode(n.getLeftPeo()-2,n.getLeftSavage(),n.getRightPeo()+2,n.getRightSavage(),n.getStateBoatRight(),n.getNodesCheckSum(),2,0);
if(dfs(n4)){
resultList.add(0,n4);
returntrue;
}
Noden5=newNode(n.getLeftPeo(),n.getLeftSavage()-2,n.getRightPeo(),n.getRightSavage()+2,n.getStateBoatRight(),n.getNodesCheckSum(),0,2);
if(dfs(n5)){
resultList.add(0,n5);
returntrue;
}
}
else{
Noden6=newNode(n.getLeftPeo(),n.getLeftSavage()+1,n.getRightPeo(),n.getRightSavage()-1,n.getStateBoatLeft(),n.getNodesCheckSum(),0,1);
if(dfs(n6)){
resultList.add(0,n6);
returntrue;
}
Noden7=newNode(n.getLeftPeo()+1,n.getLeftSavage(),n.getRightPeo()-1,n.getRightSavage(),n.getStateBoatLeft(),n.getNodesCheckSum(),1,0);
if(dfs(n7)){
resultList.add(0,n7);
returntrue;
}
Noden1=newNode(n.getLeftPeo()+1,n.getLeftSavage()+1,n.getRightPeo()-1,n.getRightSavage()-1,n.getStateBoatLeft(),n.getNodesCheckSum(),1,1);
if(dfs(n1)){
resultList.add(0,n1);
returntrue;
}
Noden4=newNode(n.getLeftPeo()+2,n.getLeftSavage(),n.getRightPeo()-2,n.getRightSavage(),n.getStateBoatLeft(),n.getNodesCheckSum(),2,0);
if(dfs(n4)){
resultList.add(0,n4);
returntrue;
}
Noden5=newNode(n.getLeftPeo(),n.getLeftSavage()+2,n.getRightPeo(),n.getRightSavage()-2,n.getStateBoatLeft(),n.getNodesCheckSum(),0,2);
if(dfs(n5)){
resultList.add(0,n5);
returntrue;
}
}
returnfalse;
}
publicList<Node>getResultList(){
returnresultList;
}

}

Node.java

importjava.util.ArrayList;
importjava.util.List;

publicclassNode{
privateList<Integer>nodesCheckSum=newArrayList<Integer>();
privateintleftPeo;
privateintrightPeo;
privateintleftSavage;
privateintrightSavage;
privateintCURR_STATE=0;
privateintonBoatPeoNum=0;
privateintonBoatSavageNum=0;
privatefinalintSTATE_BOAT_LEFT=0;
privatefinalintSTATE_BOAT_RIGHT=1;
publicNode(intleftPeo,intleftSavage,intrightPeo,intrightSavage,intstate,ListcheckSumList,intonBoatPeoNum,intonBoatSavageNum){
this.CURR_STATE=state;
this.leftPeo=leftPeo;
this.leftSavage=leftSavage;
this.rightPeo=rightPeo;
this.rightSavage=rightSavage;
this.nodesCheckSum.addAll(checkSumList);
this.onBoatPeoNum=onBoatPeoNum;
this.onBoatSavageNum=onBoatSavageNum;
}
publicintgetLeftPeo(){
returnleftPeo;
}
publicvoidsetLeftPeo(intleftPeo){
this.leftPeo=leftPeo;
}
publicintgetRightPeo(){
returnrightPeo;
}
publicvoidsetRightPeo(intrightPeo){
this.rightPeo=rightPeo;
}
publicintgetLeftSavage(){
returnleftSavage;
}
publicvoidsetLeftSavage(intleftSavage){
this.leftSavage=leftSavage;
}
publicintgetRightSavage(){
returnrightSavage;
}
publicvoidsetRightSavage(intrightSavage){
this.rightSavage=rightSavage;
}
@Override
publicStringtoString(){
returnleftPeo+","+leftSavage+","+rightPeo+","+rightSavage+","+CURR_STATE;
}
publicintgetCURR_STATE(){
returnCURR_STATE;
}
publicvoidsetCURR_STATE(intcURR_STATE){
CURR_STATE=cURR_STATE;
}
publicintgetStateBoatLeft(){
returnSTATE_BOAT_LEFT;
}
publicintgetStateBoatRight(){
returnSTATE_BOAT_RIGHT;
}
publicintcalcCheckSum(){
return1*getCURR_STATE()+10*getLeftPeo()+100*getLeftSavage()+1000*getRightPeo()+10000*getRightSavage();
}
publicvoidaddCheckSum(){
intcheckSum=calcCheckSum();
nodesCheckSum.add(checkSum);
}
publicbooleanhasVisited(){
intsum=calcCheckSum();
for(IntegercheckSum:nodesCheckSum){
if(checkSum==sum)returntrue;
}
returnfalse;
}
publicList<Integer>getNodesCheckSum(){
returnnodesCheckSum;
}
publicintgetOnBoatPeoNum(){
returnonBoatPeoNum;
}
publicvoidsetOnBoatPeoNum(intonBoatPeoNum){
this.onBoatPeoNum=onBoatPeoNum;
}
publicintgetOnBoatSavageNum(){
returnonBoatSavageNum;
}
publicvoidsetOnBoatSavageNum(intonBoatSavageNum){
this.onBoatSavageNum=onBoatSavageNum;
}

}

❺ 简单过河卒问题

/*
A点有一个卒，需要走到目标B点。行走规则：可以向下（共4步）或者向右（共8步）。
要求计算从A能够到达B的路径的条数，并输出每一条路径.

解：
题目描述的是一种在二维空间中情形。设 X 轴为从左到右，Y轴为从上到下。
有 A 和 B 两点，第 1 维(X轴)距离d[1]=8，第 2 维（Y轴）距离 d[2]=8，
因此沿着点A到点B的向量为(8,4) 。每次沿着向量的一个方向（X轴或Y轴）运动一个单位，
也就是每次可以移到（1,0）或者(0,1)。计算从A到达B的路径条数。

一般的情形是：
在 D 维空间中，有A，B两点，
这两点在第 1 维距离d[1]，第 2 维距离d[2]，...，第D维的距离d[D],
因此沿着点A到点B的向量为(d[1],d[2],...,d[D])。每次沿着向量的一个方向运动一个单位，
也就是每次可以移动(±1,0,...,0)或者(0,±1,...,0),...,或者(0,0,...,±1)，
这里的第 i 个 ±1，实际只能取+1或者-1，具体正负性和相应的 d[i] 一样。
计算从A到达B的路径条数。

解决的方案：
我们针对题目描述的二维空间的情形进行分析。
点A到点B的向量为(8,4) 定下来后，因为每次只能沿着向量的一个方向（X轴或Y轴）运动一个单位，
而这两个方向是正交的，也就是互不影响的。
不管先走X方向，还是先走Y方向， 最后都一定是向X方向走 8 步，向 Y 方向走 4 步。

假设开始沿 X 方向运动一个单位，我们假设到达了点 A' 。
那么点 A' 到点 B 的向量为(7,4) ，下面问题就是计算 A' 到达 B 的路径条数。
可以发现，问题“计算 A 到达 B 的路径条数”和问题“计算 A 到达 B 的路径条数”是同一类问题。

假设开始沿 Y 方向运动一个单位，我们假设到达了点 A'' 。
那么点 A'' 到点 B 的向量为(8,3) ，下面问题就是计算 A'' 到达 B 的路径条数。
可以发现，问题“计算 A 到达 B 的路径条数”和问题“计算 A'' 到达 B 的路径条数”是同一类问题。

通过上面的两个假设可以发现，不管第一步怎么走，接下来都产生了一个相似的子问题。
这就是分治的策略，也就是把一个大问题，分解成若干个相似的子问题。

上面的两个假设，最后的一个子问题必定是某点到 B 的向量为(1,0)，
或者某点到 B 的向量为(0,1)，这是能立即解决的子问题。
*/

#include <stdio.h>
#include <stdlib.h>

// 当前需要的维度，可以修改这个值进行扩展（不用改动算法）
#define DIMENSION 2
// 每个维度的最大长度
#define MAX_LENGTH_PER_DIMENSION 100

// 空间最小的移动向量。一次只能在一个维度移动一个单位。
struct Step
{
// 维度索引
int index;
// 移动距离
int d;
};

/*
根据向量距离 distance ，计算每个维度上的最小移动单位。
通过 steps 和 stepsAmount 返回。

注意：如果向量距离某个维度上的的距离为 0 ，那么这个维度上不会返回最小移动单位。
*/
void getSteps(int distance[],struct Step steps[],int *stepsAmount)
{
int i;
*stepsAmount=0;
for(i=0;i<DIMENSION;i++)
{
// 在维度 i 上距离不为 0 ，需要计算最小移动单位
if(distance[i] != 0)
{
steps[*stepsAmount].index = i;
steps[*stepsAmount].d = distance[i]>0 ? 1 : -1;

(*stepsAmount) ++;
}
}
}

// 打印最小移动单位
void printStep(const struct Step* step)
{
int i;
// 对于小于等于二维的坐标系，可以为每一步指定上下左右四个方向
if(DIMENSION <= 2)
{
if(step->index == 0)
{
if(step->d > 0)
printf("右");
else
printf("左");
}
else if(step->index == 1)
{
if(step->d > 0)
printf("下");
else
printf("上");
}
}
// 对于大于二维的坐标系，直接输出移动向量。
else
{
printf("[");
for(i=0;i<DIMENSION;i++)
{
printf("%d",i==step->index ? step->d : 0);
if(i != DIMENSION-1)
printf(",");
}
printf("]");
}
}

void getPath(int distance[],
struct Step path[],int pathLength,int *totalSchemeAmount)
{
int i,j,k,d;

struct Step steps[DIMENSION];
int stepsAmount;

// 计算需要移动的总距离
for(i=0,d=0;i<DIMENSION;i++)
d += abs(distance[i]);

if(d == 0)
{// 已经走完全程，输出路径

for(i=0;i<pathLength;i++)
{
printStep(&path[i]);

if(i!=(pathLength-1))
printf(" ==> ");
else
printf("\n");
}

// 统计路径条数
(*totalSchemeAmount) ++;
}
else
{
// 获取最小移动单位
getSteps(distance,steps,&stepsAmount);
for(i=0;i<stepsAmount;i++)
{
// 任选一个维度，运动一个最小单位
path[pathLength++] = steps[i];
distance[steps[i].index] -= steps[i].d;

// 解决成子问题
getPath(distance,path,pathLength,totalSchemeAmount);

// 回溯
pathLength--;
distance[steps[i].index] += steps[i].d;
}
}
}

int main(int argc, char *argv[])
{
/* DIMENSION = 1 */
//int distance[DIMENSION]={-5};

/* DIMENSION = 2 */
int distance[DIMENSION]={8,4};

/* DIMENSION = 3 */
//int distance[DIMENSION]={1,1,1};

struct Step steps[DIMENSION],path[DIMENSION*MAX_LENGTH_PER_DIMENSION];
int stepsAmount,totalSchemeAmount=0;

// 计算路径
getPath(distance,path,0,&totalSchemeAmount);
printf("一共 %d 条路径。\n",totalSchemeAmount);

return 0;
}

❻ C语言——马拦过河卒。看看我的算法错哪了，并改正。

我发网络消息你咋老不回呢？除了你所说的那个问题以外，
if(abs(mx-dx)==1&&abs(my-dy)==2||abs(mx-dx)==2&&abs(my-dy)==1)这一句有问题
你判断掉了马所在的控制点
改成
if(abs(mx-dx)==1&&abs(my-dy)==2||abs(mx-dx)==2&&abs(my-dy)==1 || dx==mx && dy==my)
结果就是对的了
你的程度风格有点别扭，有些控制语句是多余的，还有就是在某些情况下，该算法还有bug，

❼ 急！Pascal编程：过河卒（无马拦）

递归算法，适合m、n较小的情况。仅供参考：

const
	m=13;n=15;
var
	num:longint;
	
procerenext(x,y:integer);
begin
	if(x=m)and(y=n)thenbegin
		inc(num);
		ifnum>10000000thenbegin
			writeln('路径太多，请采用更优算法');
			halt;
		end;
	end	
	elsebegin
		if(y+1<=n)thennext(x,y+1);
		if(x+1<=m)thennext(x+1,y);
	end;
end;

begin
	num:=0;
	next(1,1);
	writeln(num);
end.
	

❽ pascal编程：过河卒

【问题分析】

跳马是一道老得不能再老的题目，每位编程者都学过，一般是在学习回溯或搜索算法时，很多书上也有类似的题目，一些比赛中也经常出现这一问题的变形（如NOIP1997初中组第三题）。有些同学一看到这种类型的题目就去盲目搜索，但事实证明：当n，m=15就会超时。

其实，对本题稍加分析就能发现，到达棋盘上的一个点，只能从左边过来（我们称之为左点）或是从上面过来（我们称之为上点）。根据加法原理，到达某一点的路径条数，就等于到达其相邻的上点或左点的路径数目总和。因此我们可以使用逐列（逐行）递推的方法来求出从起点到终点的路径数目。障碍点（马的控制点）也完全适用，只要将到达该点的路径数目设置为0即可。

假设用F[I,J]到达点（I,J）的路径数目用G[I,J]表示点(I,J)是否为对方马的控制点，G[I,J]=0表示不是对放马的控制点，G[I,J]=1表示是对方马的控制点。则，我们可以得到如下的递推关系式：

F[I,J]=0{G[I,J]=1}

F[I,0]=F[I-1,0]{I>0,G[I,0]=0}

F[0,J]=F[0,J-1]{J>0,G[0,J]=0}

F[I,J]=F[I-1,J]+F[I,J-1]{I>0,J>0,G[I,J]=0}

上述递推式边界是：F[0,0]:=1。考虑到最大情况下：n=20，m=20，路径条数可能会出现超出长整型范围，所以要用int64或comp类型计数或者高精度运算。

（来源：http://hi..com/zhouqh_1997/item/c1b886861d0b6a1dc3162786）

【参考程序】

const dx:array[1..8] of integer=(-2, -1, 1, 2, 2, 1, -1, -2);

dy:array[1..8] of integer=(1, 2, 2, 1, -1, -2, -2, -1);

var n,m,x,y,i,j:integer;

g:array[0..20, 0..20] of boolean;

f:array[0..20, 0..20] of int64;

begin

readln(n,m,x,y);

g[x,y]:=true;

for i:=1 to 8 do

if(x+dx[i]>=0)and(x+dx[i]<=n)and(y+dy[i]>=0)and(y+dy[i]<=m)then

g[x+dx[i],y+dy[i]]:=true;

f[0,0]:=1;

for i:=1 to n do

if not(g[i,0]) then

f[i,0]:=f[i-1,0];

for i:=1 to m do

if not(g[0,i]) then

f[0,i]:=f[0,i-1];

for i:=1 to n do

for j:=1 to m do

if not(g[i,j]) then

f[i,j]:=f[i-1,j]+f[i,j-1];

writeln(f[n,m]);

end.

❾ 软件开发工作人员必读的书籍有哪些，特别是刚刚工作的

《人月神化》
《人件》
《软件发布方法》
《数据仓库项目管理》
《自适应软件开发》
《功能点分析》
《创建软件工程文化》
《OO项目开发》（这本书的名字记得不是很清楚）
这些书是一个系列丛书。清华大学出版社出的
《微软项目：求生法则》
《微软研发：致胜策略》
《微软团队：成功秘诀》
原来关于微软开发的系列丛书。很难买到了，但网上的下载很多

《微软的秘密》
很不错的一本书。质量保证人员应该看得一本书。也是在网上下载吧

《软件工程：实践者的研究方法》
最经典的软件工程书籍。十分难读，但的确是经典,英文已经到今天为止版了,中文版,很多大学拿它做教材,可以本科很难理解它的重要性,建议5年以上工作经验的同志们好好读一下,
《重构》
《重构手册》
这两本书是中国电力出版社的书，一套，使开发人员改进自己代码的教科书

《过河卒》
开发人员如何确定自己的技术人生，一本不错的书，

《borland传奇》
想了解PC软件的发展，读这个书最好，使你对软件的发展和计算机系统有一个更深刻的了解。

《Java夜未眠》
不仅仅是讲java语言的数，其中许多深刻的道理对质量保证人员也有很大的帮助

《计算机程序设计艺术》1，2，3卷
不知道怎么评价这三本书，开发人员的床头必备的书籍，就是一个字---牛

《软件工艺》
告诉你什么是软件开发，什么是程序员，让我们知道我们是怎么回事

《IT项目管理》（机械出版社）
PMP的管理书籍。项目组长必读的东西，如何从开发人员变为项目管理人员，这个书写的不错

《高质量软件项目管理》（清华大学出版社）
这本书将项目管理,软件工程都写到一起了,对于希望做项目管理和质量保证的人员很有用,对于一般的开发人员,你可以了解你以后的技术生涯需要那些技能和技巧,为以后的发展打下一个基础
最后一个系列
软件与系统思想家温伯格精粹译丛（清华大学出版社）
《质量、软件、管理---协调管理》
《质量、软件、管理---系统思维》
《程序员开发心理学》
《走查、审查、技术复审手册》
还有其他的书，但我只有这几本
《代码大全I,II》
软件编码最经典的书籍,是两本经典中的经典.

❿ java一个过河搭桥游戏，若木桩之间有木板则小人能到木板上，怎么记住木板位置以及判断木桩之间有无木板

判断木桩的两点左边是否在木板上。你用swing。有发放判断