導航:首頁 > 編程語言 > java迷宮最短路徑
java迷宮最短路徑
發布時間：2022-11-25 00:51:44importjava.io.File;
importjava.io.FileNotFoundException;
importjava.util.HashSet;
importjava.util.LinkedList;
importjava.util.List;
importjava.util.Scanner;
publicclassTest{
publicstaticvoidmain(String[]args)throwsFileNotFoundException{
Scannerinput=newScanner(newFile("Maze2tong.txt"));
introw=0;
char[][]Mazemap=newchar[12][58];
while(input.hasNext()){
Stringline=input.nextLine();
for(intcolumn=0;column<=line.length()-1;column++){
charc=line.charAt(column);
Mazemap[row][column]=c;
}
row++;
}
for(inti=0;i<12;i++){
for(intj=0;j<58;j++){
System.out.print(Mazemap[i][j]);
}
System.out.print(" ");
}
LinkedList<TwoTuple<Integer,Integer>>trace=newLinkedList<TwoTuple<Integer,Integer>>();
System.out.println(maze(Mazemap,trace));
System.out.println(trace);
}
publicstaticbooleanmaze(char[][]maze,
List<TwoTuple<Integer,Integer>>trace){
LinkedList<TwoTuple<Integer,Integer>>path=newLinkedList<TwoTuple<Integer,Integer>>();
HashSet<TwoTuple<Integer,Integer>>traverse=newHashSet<TwoTuple<Integer,Integer>>();
for(inti=0;i<maze.length;i++){
for(intj=0;j<maze[i].length;j++){
if(maze[i][j]=='S'){
path.add(newTwoTuple<Integer,Integer>(i,j));
}
}
}
while(!path.isEmpty()){
TwoTuple<Integer,Integer>temp=path.pop();
if(traverse.contains(temp)){
continue;
}elseif(maze[temp.first][temp.second]=='F'){
trace.add(temp);
returntrue;
}elseif(!traverse.contains(temp)){
if(temp.second+1<maze[temp.first].length
&&maze[temp.first][temp.second+1]!='W')
path.add(newTwoTuple<Integer,Integer>(temp.first,
temp.second+1));
if(temp.second-1>0
&&maze[temp.first][temp.second-1]!='W')
path.add(newTwoTuple<Integer,Integer>(temp.first,
temp.second-1));
if(temp.first+1<maze.length
&&maze[temp.first+1][temp.second]!='W')
path.add(newTwoTuple<Integer,Integer>(temp.first+1,
temp.second));
if(temp.first-1>0
&&maze[temp.first-1][temp.second]!='W')
path.add(newTwoTuple<Integer,Integer>(temp.first-1,
temp.second));
traverse.add(temp);
trace.add(temp);
}
}
trace.clear();
returnfalse;
}
}
classTwoTuple<A,B>{
publicfinalAfirst;
publicfinalBsecond;
publicTwoTuple(Aa,Bb){
first=a;
second=b;
}
@Override
publicinthashCode(){
returnfirst.hashCode()+second.hashCode();
}
@Override
publicbooleanequals(Objectobj){
if(!(objinstanceofTwoTuple)){
}
returnobjinstanceofTwoTuple&&first.equals(((TwoTuple)obj).first)
&&second.equals(((TwoTuple)obj).second);
}
publicStringtoString(){
return"("+first+","+second+")";
}
}///:-
importjava.io.File;
importjava.io.FileNotFoundException;
importjava.util.LinkedList;
importjava.util.Scanner;
classMyPoint
{
publicbooleanvisited=false;
publicintparentRow=-1;
publicintparentColumn=-1;
publicfinalcharcontent;
publicintx;
publicinty;
publicMyPoint(charc,intx,inty)
{
this.content=c;
this.x=x;
this.y=y;
}
}
publicclassMaze
{
publicstaticMyPoint[][]getMazeArray(){
Scannerinput=null;
MyPoint[][]mazemap=newMyPoint[12][58];
try{
input=newScanner(newFile("Maze2tong.txt"));
introw=0;
while(input.hasNext()){
Stringline=input.nextLine();
for(intcolumn=0;column<=line.length()-1;column++){
charc=line.charAt(column);
MyPointpoint=newMyPoint(c,row,column);
mazemap[row][column]=point;
}
row++;
}
input.close();
}catch(FileNotFoundExceptione){
e.printStackTrace();
}
returnmazemap;
}
publicstaticbooleantomRun(MyPoint[][]maze,MyPointend)
{
intx=maze.length;
inty=maze[0].length;
LinkedList<MyPoint>stack=newLinkedList<MyPoint>();
for(inti=0;i<maze.length;i++){
for(intj=0;j<maze[i].length;j++){
if(maze[i][j].content=='S'){
stack.push(maze[i][j]);
maze[i][j].visited=true;
}
}
}
booleanresult=false;
while(!stack.isEmpty())
{
MyPointt=stack.pop();
//System.out.println("poppoint:"+t.x+""+t.y+"value:"+maze[t.x][t.y]);
if(t.content=='F')
{
result=true;
end.x=t.x;
end.y=t.y;
break;
}
if(t.x-1>0&&maze[t.x-1][t.y].visited==false&&maze[t.x-1][t.y].content!='W')
{
stack.push(maze[t.x-1][t.y]);
maze[t.x-1][t.y].parentRow=t.x;
maze[t.x-1][t.y].parentColumn=t.y;
maze[t.x-1][t.y].visited=true;
}
if(t.x+1<x&&maze[t.x+1][t.y].visited==false&&maze[t.x+1][t.y].content!='W')
{
stack.push(maze[t.x+1][t.y]);
maze[t.x+1][t.y].parentRow=t.x;
maze[t.x+1][t.y].parentColumn=t.y;
maze[t.x+1][t.y].visited=true;
}
if(t.y-1>0&&maze[t.x][t.y-1].visited==false&&maze[t.x][t.y-1].content!='W')
{
stack.push(maze[t.x][t.y-1]);
maze[t.x][t.y-1].parentRow=t.x;
maze[t.x][t.y-1].parentColumn=t.y;
maze[t.x][t.y-1].visited=true;
}
if(t.y+1<y&&maze[t.x][t.y+1].visited==false&&maze[t.x][t.y+1].content!='W')
{
stack.push(maze[t.x][t.y+1]);
maze[t.x][t.y+1].parentRow=t.x;
maze[t.x][t.y+1].parentColumn=t.y;
maze[t.x][t.y+1].visited=true;
}
}
returnresult;
}
publicstaticvoidshow(intx,inty,MyPoint[][]visited)
{
if(visited[x][y].parentRow==-1)
{
System.out.println("["+x+","+y+"]");
return;
}
show(visited[x][y].parentRow,visited[x][y].parentColumn,visited);
System.out.println("->"+"["+x+","+y+"]");
}
publicstaticvoidmain(String[]args)
{
MyPoint[][]maze=getMazeArray();
MyPointpoint=newMyPoint('c',1,1);
if(tomRun(maze,point))
{
System.out.println("逃生路徑如下：");
show(point.x,point.y,maze);
}
else
System.out.println("無法走出迷宮！");
}
}
❷ 迷宮最短路徑
用堆棧不一定能得出最短路徑，改用隊列可以實現最短路徑，下面是《數據結構演算法與應用-C++語言描述》裡面的一段話。
[迷宮老鼠] 使用F I F O分枝定界，初始時取（1，1）作為E-節點且活動隊列為空。迷宮的位置（1 , 1）被置為1，以免再次返回到這個位置。（1，1）被擴充，它的相鄰節點（1，2）和（2，1）加入到隊列中（即活節點表）。為避免再次回到這兩個位置，將位置（ 1，2）和（2，1）置為1。
1 1 0
1 1 1
0 0 0
a）
1 1 1
1 1 1
0 0 0
b）
1 1 1
1 1 1
1 0 0
c）
節點（1，2）從隊列中移出並被擴充。檢查它的三個相鄰節點（見圖1 6 - 1的解空間），只有
（1，3）是可行的移動（剩餘的兩個節點是障礙節點），將其加入隊列，並把相應的迷宮位置置
為1，所得到的迷宮狀態如圖17-1b 所示。節點（1，2）被刪除，而下一個E-節點（2，1）將
會被取出，當此節點被展開時，節點（3，1）被加入隊列中，節點（3，1）被置為1，節點（2，
1）被刪除，所得到的迷宮如圖17-1c 所示。此時隊列中包含（1，3）和（3，1）兩個節點。隨
後節點（1，3）變成下一個E-節點，由於此節點不能到達任何新的節點，所以此節點即被刪除，
節點（3，1）成為新的E-節點，將隊列清空。節點（3，1）展開，（3，2）被加入隊列中，而
（3，1）被刪除。（3，2）變為新的E-節點，展開此節點後，到達節點（3，3），即迷宮的出口。
使用F I F O搜索，總能找出從迷宮入口到出口的最短路徑。
❸ java 最短路徑演算法 如何實現有向 任意兩點的最短路徑
Dijkstra(迪傑斯特拉)演算法是典型的最短路徑路由演算法，用於計算一個節點到其他所有節點的最短路徑。主要特點是以起始點為中心向外層層擴展，直到擴展到終點為止。
Dijkstra一般的表述通常有兩種方式，一種用永久和臨時標號方式，一種是用OPEN, CLOSE表方式
用OPEN,CLOSE表的方式，其採用的是貪心法的演算法策略，大概過程如下：
1.聲明兩個集合，open和close，open用於存儲未遍歷的節點，close用來存儲已遍歷的節點
2.初始階段，將初始節點放入close，其他所有節點放入open
3.以初始節點為中心向外一層層遍歷，獲取離指定節點最近的子節點放入close並從新計算路徑，直至close包含所有子節點
代碼實例如下：
Node對象用於封裝節點信息，包括名字和子節點
[java] view plain
public class Node {
private String name;
private Map<Node,Integer> child=new HashMap<Node,Integer>();
public Node(String name){
this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Map<Node, Integer> getChild() {
return child;
}
public void setChild(Map<Node, Integer> child) {
this.child = child;
}
}
MapBuilder用於初始化數據源，返回圖的起始節點
[java] view plain
public class MapBuilder {
public Node build(Set<Node> open, Set<Node> close){
Node nodeA=new Node("A");
Node nodeB=new Node("B");
Node nodeC=new Node("C");
Node nodeD=new Node("D");
Node nodeE=new Node("E");
Node nodeF=new Node("F");
Node nodeG=new Node("G");
Node nodeH=new Node("H");
nodeA.getChild().put(nodeB, 1);
nodeA.getChild().put(nodeC, 1);
nodeA.getChild().put(nodeD, 4);
nodeA.getChild().put(nodeG, 5);
nodeA.getChild().put(nodeF, 2);
nodeB.getChild().put(nodeA, 1);
nodeB.getChild().put(nodeF, 2);
nodeB.getChild().put(nodeH, 4);
nodeC.getChild().put(nodeA, 1);
nodeC.getChild().put(nodeG, 3);
nodeD.getChild().put(nodeA, 4);
nodeD.getChild().put(nodeE, 1);
nodeE.getChild().put(nodeD, 1);
nodeE.getChild().put(nodeF, 1);
nodeF.getChild().put(nodeE, 1);
nodeF.getChild().put(nodeB, 2);
nodeF.getChild().put(nodeA, 2);
nodeG.getChild().put(nodeC, 3);
nodeG.getChild().put(nodeA, 5);
nodeG.getChild().put(nodeH, 1);
nodeH.getChild().put(nodeB, 4);
nodeH.getChild().put(nodeG, 1);
open.add(nodeB);
open.add(nodeC);
open.add(nodeD);
open.add(nodeE);
open.add(nodeF);
open.add(nodeG);
open.add(nodeH);
close.add(nodeA);
return nodeA;
}
}
圖的結構如下圖所示：
Dijkstra對象用於計算起始節點到所有其他節點的最短路徑
[java] view plain
public class Dijkstra {
Set<Node> open=new HashSet<Node>();
Set<Node> close=new HashSet<Node>();
Map<String,Integer> path=new HashMap<String,Integer>();//封裝路徑距離
Map<String,String> pathInfo=new HashMap<String,String>();//封裝路徑信息
public Node init(){
//初始路徑,因沒有A->E這條路徑,所以path(E)設置為Integer.MAX_VALUE
path.put("B", 1);
pathInfo.put("B", "A->B");
path.put("C", 1);
pathInfo.put("C", "A->C");
path.put("D", 4);
pathInfo.put("D", "A->D");
path.put("E", Integer.MAX_VALUE);
pathInfo.put("E", "A");
path.put("F", 2);
pathInfo.put("F", "A->F");
path.put("G", 5);
pathInfo.put("G", "A->G");
path.put("H", Integer.MAX_VALUE);
pathInfo.put("H", "A");
//將初始節點放入close,其他節點放入open
Node start=new MapBuilder().build(open,close);
return start;
}
public void computePath(Node start){
Node nearest=getShortestPath(start);//取距離start節點最近的子節點,放入close
if(nearest==null){
return;
}
close.add(nearest);
open.remove(nearest);
Map<Node,Integer> childs=nearest.getChild();
for(Node child:childs.keySet()){
if(open.contains(child)){//如果子節點在open中
Integer newCompute=path.get(nearest.getName())+childs.get(child);
if(path.get(child.getName())>newCompute){//之前設置的距離大於新計算出來的距離
path.put(child.getName(), newCompute);
pathInfo.put(child.getName(), pathInfo.get(nearest.getName())+"->"+child.getName());
}
}
}
computePath(start);//重復執行自己,確保所有子節點被遍歷
computePath(nearest);//向外一層層遞歸,直至所有頂點被遍歷
}
public void printPathInfo(){
Set<Map.Entry<String, String>> pathInfos=pathInfo.entrySet();
for(Map.Entry<String, String> pathInfo:pathInfos){
System.out.println(pathInfo.getKey()+":"+pathInfo.getValue());
}
}
/**
* 獲取與node最近的子節點
*/
private Node getShortestPath(Node node){
Node res=null;
int minDis=Integer.MAX_VALUE;
Map<Node,Integer> childs=node.getChild();
for(Node child:childs.keySet()){
if(open.contains(child)){
int distance=childs.get(child);
if(distance<minDis){
minDis=distance;
res=child;
}
}
}
return res;
}
}
Main用於測試Dijkstra對象
[java] view plain
public class Main {
public static void main(String[] args) {
Dijkstra test=new Dijkstra();
Node start=test.init();
test.computePath(start);
test.printPathInfo();
}
}
❹ 迷宮數組 最短路徑演算法 我， 我， 我給分60！
//對角線也可以走：如從1,3到2,4最短路徑為根號2
//如果對角線不想，兩個for循環條件判斷稍微修改下：
//代碼如下：
//輸出-1 表示找不到路徑
/*
給個數組，0表示通路，1表示阻礙，然後給任意兩個0的坐標，可以找到它們之間的最短路徑並列印出來
比如說數組是 1 0 0 0 1
1 1 1 0 1
1 1 0 0 1
1 0 0 0 1
1 0 1 1 1
然後我就可以找到第一行第二個數和第五行第二個數之間的最短路徑了
*/
#include <stdlib.h>
#include <math.h>
#include <windows.h>
#include <stdio.h>
#define M 5
#define N 5
typedef struct coordinate{
short int x;
short int y;
} COORDINATE;
COORDINATE path[M*N];//全局變數，存儲已訪問結點
float getminpath(COORDINATE *,COORDINATE *,char [][N],COORDINATE *);
void main()
{
memset(path,0,sizeof(COORDINATE)*M*N);
char maze[M][N]={
'\1','\0','\0','\0','\1',
'\1','\1','\1','\0','\1',
'\1','\1','\0','\0','\1',
'\1','\0','\0','\0','\1',
'\1','\0','\1','\1','\1',
};
COORDINATE a,b;
float dis;
do{
system("cls");
printf("請輸入起點坐標：\n如1,2為第一行第二個數\n");
printf("取值范圍1～%d,1～%d\n",M,N);
scanf("%hd,%hd",&a.x,&a.y);
printf("請輸入終點坐標：\n如5,2為第五行第二個數\n");
printf("取值范圍1～%d,1～%d\n",M,N);
scanf("%hd,%hd",&b.x,&b.y);
a.x--;
a.y--;
b.x--;
b.y--;
dis=getminpath(&a,&b,maze,path);
printf("最短路徑為：%f\n",dis);
system("pause");
} while(getchar()!=EOF);
}
float getminpath(COORDINATE *from,COORDINATE *to,char maze[][5],COORDINATE *visited)
//從from結點到to結點可以分成兩步，1.從from到from的相鄰結點。2.再到to結點，這就是一個遞歸的過程
//將已訪問結點存放入visited中
{
COORDINATE *nearpt=(COORDINATE*)malloc(sizeof(COORDINATE)*1);
memset(nearpt,0,sizeof(COORDINATE));
int i,j;
float min=0;//存儲最短路徑的值
COORDINATE *pvisit;//遍歷已訪問結點的指針
char reflag;//相鄰結點是否 「已訪問」 的flag
float dis=-1;//距離
if(from==0||to==0||maze==0)
{
return -1;
}
else
{
if(from->x==to->x&&from->y==to->y)//坐標相同，表示已到達
{
dis=0;
}
else
{
for(i=-1;i<=1;i++)
{
for(j=-1;j<=1;j++)
{
if(i==0&&j==0)
{
continue;
}
nearpt->x=from->x+i;
nearpt->y=from->y+j;
if(nearpt->x<0||nearpt->x>M-1||nearpt->y<0||nearpt->y>N-1)//越界
{
continue;
}
if(maze[nearpt->x][nearpt->y]!='\0')//非零為障礙，繼續下一次循環
{
continue;
}
reflag='\0';//初值為'\0'，表示未訪問過
for(pvisit=path;pvisit<visited;pvisit++)//搜索已訪問結點
{
if(pvisit->x==nearpt->x&&pvisit->y==nearpt->y)
{
reflag='\1';//該結點已經訪問過了
break;
}
}
if(reflag=='\1')
{
continue;
}
else
{
visited->x=from->x;//將from結點加入已訪問結點數組中
visited->y=from->y;
dis=getminpath(nearpt,to,maze,visited+1);//遞歸
if(dis>=0)
{
dis+=sqrt((nearpt->x-from->x)*(nearpt->x-from->x)+(nearpt->y-from->y)*(nearpt->y-from->y));
// printf("%d,%d到%d,%d\t距離：%3f\n",from->x,from->y,to->x,to->y,dis);
if(min==0)//第一次，還沒將dis的值賦給m過
{
min=dis;
}
else
{
if(dis<min)
{
min=dis;
}
else
{
}
}
}
visited->x=0;//清除from結點
visited->y=0;
}
}
}
}
}
free(nearpt);
if(min>0)
{
return min;
}
else
{
return dis;
}
}
❺ 跪求迷宮最短路徑 題目：迷宮最短路徑 ⒈問題描述 從一個迷宮的入口到出口找出一條最短路經。用一個二維數
擦啊。。。我打了半天字，網路竟然給消了！！尼瑪呀！！！
算了，具體演算法我不想再寫了。樓主去參考下數據結構教材上關於圖的最短路徑的兩種經典演算法應該就比較明了了。
我日啊！！！寫了10多分鍾，網路啊網路！！！
❻ 求用java語言尋找走出迷宮路線的演算法
首先給定一個初始坐標，然後構建一個容器保存坐標值，之後進行迭代，橫坐標+1，或者縱坐標+1，這個順尋自己定義（四個方向），經過的「路徑」保存在那個容器中，如果遇到死角，以此往回迭代，在容器中將遇到死角的那個坐標刪除。最後找到自己定義的那個迷宮出口坐標。
❼ 用java語言求最短路徑
最短路徑就是敲代碼。 這個東西行業公認,沒有比敲代碼學語言更加快的路了。
如果是單純感興趣可以買兩本書自學 什麼thinkinjava之類的，開始肯定看不懂的,誰開始都看不懂,摸索著來,時間長了就理解了。如果有其它語言基礎學起來就快多了,因為語言這種東西,除了語法不一樣,邏輯都是一樣的。
如果是工作需要什麼的,可以找個培訓啥的。當然前提你有錢。
最後順帶吐個槽,捷徑好找的話，程序員這工作就不值錢了。
❽ 求java演算法源代碼 求出汽車從起點S出發到達終點T的一條行駛路程最短的路線。
呵呵，你如果最短路徑是m*n的這個前提就好算；如果最短不一定是m*n的話就成了一個迷宮問題同樣求指點啊
❾ 求java實現矩陣圖上任意兩點的最短路徑源碼
我用的是遞歸調用方法，有個小問題就是在列印步數的時候是返向的，原因是就是程序不斷的調用自己，到最後判斷基值位準退出調用。這才開始從棧里取出方法進行執行的原因。
代碼欣賞：
publicstaticintstep=1;
=newStringBuffer();
publicstaticint[][]maze={{1,1,1,1,1,1,1,1,1,1,1},
{1,0,1,0,1,0,0,0,0,0,1},
{1,0,1,0,0,0,1,0,1,1,1},
{1,0,0,0,1,0,1,0,0,0,1},
{1,0,1,1,0,0,1,0,0,1,1},//0代表可以通過，1代表不可通過
{1,0,1,0,1,1,0,1,0,0,1},
{1,0,0,0,0,0,0,0,1,0,1},
{1,0,1,0,1,0,1,0,1,0,1},
{1,0,0,1,0,0,1,0,1,0,1},
{1,1,1,1,1,1,1,1,1,1,1}};
publicstaticvoidmain(String[]args){
inti,j;//循環記數變數
Sample.way(1,1);//二維數組起始值從下標1，1開始
System.out.println("起點從坐標x=1,y=1開始");
System.out.println("終點坐標是x=8,y=9結束");
System.out.println("這是迷宮圖表");
System.out.println("012345678910");
System.out.println("+---+---+---+---+---+---+---+---+---+---+---+---+---+");
for(i=0;i<10;i++){
System.out.print(""+i+"‖");
for(j=0;j<11;j++)
System.out.print("-"+maze[i][j]+"-‖");
System.out.println("");
System.out.println("+---+---+---+---+---+---+---+---+---+---+---+---+---+");
}
//列印顯示步數
System.out.print(printStep.toString());
}
publicstaticbooleanway(intx,inty){
if(maze[8][9]==2)//代表遞歸終止條件（也就是當走出出口時標記為2）
returntrue;
else{
if(maze[y][x]==0){
maze[y][x]=2;
/*
*下面if判斷條件代表當前坐標為基點，
*根據判斷對當前位置進行遞歸調用：如：
*往上、往右上、往右、往右下、往下、
*往左下、往左、往左上的坐標是否可走，
*判斷是否可走的返回條件是：
*2代表可通過、1代表不能通過、3表示已經走過，但是未能走通。
*/
if(way(x,y-1)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}elseif(way(x+1,y-1)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}elseif(way(x+1,y)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}elseif(way(x+1,y+1)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}elseif(way(x,y+1)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}elseif(way(x-1,y+1)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}elseif(way(x-1,y)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}elseif(way(x-1,y-1)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}else{
maze[y][x]=3;
returnfalse;
}
}else
returnfalse;
}
}
復制代碼前需要樓主自己創建個類
Sample.way(1,1);這句代碼是我的類的靜態調用，改下XXXXX.way(1,1);
XXXXX代表你創建的類。
下面是這個程序運行後的截圖
與java迷宮最短路徑相關的資料
- php取域名中間
- php開發環境搭建eclipse
- php微信第三方登錄demo
- 洛陽python培訓
- dockerpythonweb
- pythonworkbook模塊
- 輕量級的編程語言
- python迭代是累計嗎
- php多參數函數
- 單片機編程技術什麼意思
- php字元串轉json數組
- 數控網路編程課程有哪些
- python30特效程序編碼
- redhatphp
- pt螺紋編程
- java創建xml文件
- 三菱模塊化編程
- 軟體編程西安交大
- java取月的最後一天
- 數控三通編程
- 編程靠經驗嗎
- php數組全數字
- 兄弟cnc編程說明書
- php閃電入門教程學習
- 編程貓怎樣做3d游戲
- 統計英文字元python
- phpffmpeg轉碼
- php工程部署
- php的基本語法
- java跳轉到jsp
- 山西php工資
- php保留兩位小數不四捨五入
- saas平台PHP
- php正則問號
- python和matlab難度
- python爬蟲很難學么
- php權威編程pdf
- php面向對象的程序設計
- java正則表達式驗證郵箱
- unsignedintjava
- 什麼是面對對象編程
- plc的編程指令邊沿繼電器