dfs演算法java

『壹』 java中計算兩個時間相差多少分鍾

java中計算兩個時間相差多少分鍾

具體代碼如下：

public static String getDatePoor(Date endDate, Date nowDate) {

long nd = 1000 * 24 * 60 * 60;

long nh = 1000 * 60 * 60;

long nm = 1000 * 60;

// long ns = 1000;

// 獲得兩個時間的毫秒時間差異

long diff = endDate.getTime() - nowDate.getTime();

// 計算差多少天

long day = diff / nd;

// 計算差多少小時

long hour = diff % nd / nh;

// 計算差多少分鍾

long min = diff % nd % nh / nm;

// 計算差多少秒//輸出結果

// long sec = diff % nd % nh % nm / ns;

return day + "天" + hour + "小時" + min + "分鍾";

}

data默認有toString()

輸出格林威治時間，比如說Date date = new Date();

String toStr = date.toString();

(1)dfs演算法java擴展閱讀：

1. Java是由Sun Microsystems公司於1995年5月推出的Java程序設計語言（以下簡稱Java語言）和Java平台的總稱。

2. 用Java實現的HotJava瀏覽器（支持Java applet）顯示了Java的魅力：跨平台、動感的Web、Internet計算。

3. 從此，Java被廣泛接受並推動了Web的迅速發展，常用的瀏覽器現在均支持Java applet。另一方面，Java技術也不斷更新。

4. Java語言是一個面向對象的。Java語言提供類、介面和繼承等原語，為了簡單起見，只支持類之間的單繼承，但支持介面之間的多繼承，並支持類與介面之間的實現機制（關鍵字為implements）。

『貳』 判斷有向圖是否連通+dfs+java

方法1：

如果存在迴路，則必存在一個子圖，是一個環路。環路中所有頂點的度>=2。
n演算法：
第一步：刪除所有度<=1的頂點及相關的邊，並將另外與這些邊相關的其它頂點的度減一。

第二步：將度數變為1的頂點排入隊列，並從該隊列中取出一個頂點重復步驟一。

如果最後還有未刪除頂點，則存在環，否則沒有環。

n演算法分析：
由於有m條邊，n個頂點。

i)如果m>=n，則根據圖論知識可直接判斷存在環路。（證明：如果沒有環路，則該圖必然是k棵樹 k>=1。根據樹的性質，邊的數目m = n-k。k>=1，所以：m<n）

ii)如果m<n 則按照上面的演算法每刪除一個度為0的頂點操作一次（最多n次），或每刪除一個度為1的頂點（同時刪一條邊）操作一次（最多m次）。這兩種操作的總數不會超過m+n。由於m<n，所以演算法復雜度為O(n)。

『叄』 java實現二進制窮舉

閑著沒事，給你寫了一個一個DFS演算法，可以枚舉（a1, a2… ak），剩下的太簡單，你自己寫著玩吧。。。

importjava.util.ArrayList;


publicclassDFS{

	publicstaticvoidmain(String[]args){
		DFSdfs=newDFS();
		dfs.dfs(1);
	}
	intsum=0;
	intindex=5;
	ArrayList<Integer>list=newArrayList<Integer>();
	publicvoiddfs(inti)
	{
		if(i>index)
		{
			sum++;
			System.out.println("thisisthe"+sum);
			for(Integerinteger:this.list)
			{
				System.out.print(integer+"");
			}
			System.out.println();
			return;
		}
		for(intj=0;j<=1;j++)
		{
			list.add(j);
			this.dfs(i+1);
			list.remove(list.size()-1);
		}
	}
}

『肆』 Java數組的全排列，裡面布爾類型的數組vis[ ]，在遞歸演算法里起了什麼作用，遞歸那塊理解不了，求詳細解答

不要急於看代碼，你心理要知道全排列的思路，不注重思路是很多程序員易犯的錯誤。
全排列演算法：
如果我求得固定第一位後的排列，那麼全部排列就可以求出，固定第一位有10種可能，可以循環求得。
如果我求得固定第二位後的排列，固定第一位後的排列就可以求出，固定第二位有9種可能，可以循環求得。
。。。
如果我求得固定第10位後的排列，固定第9位後的排列就可以求出，固定第10位有1種可能，可以循環求得。
這很明顯是遞歸的演算法。
static void dfs(int start,int end,int num){//為全部排列的集合，start為數字的位置,end為最後一位，num多餘的
if(start==end){//當前的數字位置為最後一位時，說明，一個序列已經生成
for(int i=1;i<end;i++)
System.out.print(a[i]+" ");//輸出序列
System.out.println();
}
else{//序列沒有生成時
for(int i=1;i<end;i++){
if(vis[i])//i是否在前面使用過
continue;//如果是直接跳過
a[start]=i;//確定start位置的數字，當start為1時就是確定第一位，有10種可能
vis[i]=true;//設置i為已使用狀態，避免下一位使用i
dfs(start+1,end,num);//求得確定start位後的全部序列
vis[i]=false;//設置i為未使用狀態
}
}

『伍』 用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;
}

}

『陸』 java計算時間差

現在是2004-03-26 13：31：40
過去是：2004-01-02 11：30：24
要獲得兩個日期差，差的形式為：XX天XX小時XX分XX秒

方法一：
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

try
{
Date d1 = df.parse("2004-03-26 13:31:40");
Date d2 = df.parse("2004-01-02 11:30:24");
long diff = d1.getTime() - d2.getTime();
long days = diff / (1000 * 60 * 60 * 24);
}
catch (Exception e)
{
}

方法二：
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
java.util.Date now = df.parse("2004-03-26 13:31:40");
java.util.Date date=df.parse("2004-01-02 11:30:24");
long l=now.getTime()-date.getTime();
long day=l/(24*60*60*1000);
long hour=(l/(60*60*1000)-day*24);
long min=((l/(60*1000))-day*24*60-hour*60);
long s=(l/1000-day*24*60*60-hour*60*60-min*60);
System.out.println(""+day+"天"+hour+"小時"+min+"分"+s+"秒");

方法三：
SimpleDateFormat dfs = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
java.util.Date begin=dfs.parse("2004-01-02 11:30:24");
java.util.Date end = dfs.parse("2004-03-26 13:31:40");
long between=(end.getTime()-begin.getTime())/1000;//除以1000是為了轉換成秒

long day1=between/(24*3600);
long hour1=between%(24*3600)/3600;
long minute1=between%3600/60;
long second1=between%60/60;
System.out.println(""+day1+"天"+hour1+"小時"+minute1+"分"+second1+"秒");

『柒』 java中怎麼獲取時間差

java中對日期時間的處理比較多，獲取時間計算差值的代碼如下：

/*
*Java代碼計算時間差
*現在是：2004-03-2613：31：40
*過去是：2004-01-0211：30：24
*/
SimpleDateFormatdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss");
java.util.Datenow=df.parse("2004-03-2613:31:40");
java.util.Datedate=df.parse("2004-01-0211:30:24");
longl=now.getTime()-date.getTime();
longday=l/(24*60*60*1000);
longhour=(l/(60*60*1000)-day*24);
longmin=((l/(60*1000))-day*24*60-hour*60);
longs=(l/1000-day*24*60*60-hour*60*60-min*60);
System.out.println(""+day+"天"+hour+"小時"+min+"分"+s+"秒");
//現在要獲得兩個日期差，差的形式為：XX天XX小時XX分XX秒