有向无环图最长路径java_有向无环图的最长简单路径
给定一个有向无环图$G=(V,E)$，边权重为实数，给定图中的两个顶点$k,t$，设计动态规划算法，求从k到t的最长简单路径，子问题图是怎样的？算法的效率如何？
算法分析：
该问题不能够用贪心求解，假设从k出发，每一步取得weight最大的边，按这样的路径，并不能够保证能走到终点t。所以考虑动态规划算法。
该问题满足动态规划算法的两个特征：
一、最优子结构：
从k出发到t的最优路径，一定是$max(best , path , A_1 , to ,, t+weightA_0)$，其中$A0-->A1-->cdots t$和$B0-->B1-->cdots t$等等的诸多方案中的最优方案，构成了最优解。符合“剪贴”性质。
二、重叠子结构
有上面的公式可知，子问题：$A0-->A1-->cdots t$会被反复求解。
状态转移函数：
int q=weight[k][t];
for(int i=k+1;i<=t && weight[k][i];i++)
{
q=max(q,weight[k][i]+Find_longest_path(weight,numVertexes,i,t,r));
}
r[k]=q;
return q;
算法实现
Graphic_longest_path.h
#include
#include
using namespace std;
#define INITWEIGHT 0
//用矩阵实现图
class graph
{
private:
bool isWeighted; //是否带权？
bool isDirected; //是否有向？
int numV; //顶点数
int numE; //边数
int **matrix; //邻接矩阵
public:
graph(int numV,bool isWeighted=false,bool isDirected=false);
void createGraph();
~graph();
int getVerNums()
{
return numV;
}
int getEdgeNums()
{
return numE;
}
int **getWeight()
{
return matrix;
}
void setEdgeWeight(int beg,int end,int weight);
void printAdjacentMatrix();
//检查输入
bool check(int i,int j,int w=1);
};
//类的实现
graph::graph(int numV,bool isWeighted,bool isDirected)
{
while(numV<=0)
{
cout<
cin>>numV;
}
this->numV=numV;
this->isWeighted=isWeighted;
this->isDirected=isDirected;
//private之后的成员可以被类的成员函数访问，但是不能够被使用该类的代码访问
matrix=new int *[numV];
for(int i=0;i
matrix[i]=new int [numV];
//对图进行初始化
if(!isWeighted) //无权图
{
//对所有的权值初始化为0
for(int i=0;i
for(int j=0;j
matrix[i][j]=0;
}
else //有权图
{
for(int i=0;i
for(int j=0;j
matrix[i][j]=INITWEIGHT;
}
}
//建图
void graph::createGraph()
{
cout<
while(cin>>numE && numE<0)
cout<
int i,j,w;
if(!isWeighted) //无权图
{
if(!isDirected) //无向图
{
cout<
for(int k=0;k
{
cin>>i>>j;
while(!check(i,j))
{
cout<
cin>>i>>j;
}
matrix[i][j]=matrix[j][i]=1;
}
}
else
{
cout<
for(int k=0;k
{
cin>>i>>j;
while(!check(i,j))
{
cout<
cin>>i>>j;
}
matrix[i][j]=1;
}
}
}
else //有权图
{
if(!isDirected) //无向图
{
cout<
for(int k=0;k
{
cin>>i>>j>>w;
while(!check(i,j,w))
{
cout<
cin>>i>>j>>w;
}
matrix[i][j]=matrix[j][i]=w;
}
}
else
{
cout<
for(int k=0;k
{
cin>>i>>j>>w;
while(!check(i,j,w))
{
cout<
cin>>i>>j>>w;
}
matrix[i][j]=w;
}
}
}
}
graph::~graph() //析构函数
{
for(int i=0;i
delete[] matrix[i];
delete[] matrix;
}
//设置指定边权值：
void graph::setEdgeWeight(int beg,int end,int weight)
{
if(isWeighted)
{
while(!check(beg,end,weight))
{
cout<
cin>>beg>>end>>weight;
}
if(isDirected)
matrix[beg][end]=weight;
else
matrix[beg][end]=matrix[end][beg]=weight;
}
else
{
while(!check(beg,end,1))
{
cout<
cin>>beg>>end;
}
if(isDirected) //对邻接矩阵的值进行反转，重置，1变成0，0变成1
matrix[beg][end]=1-matrix[beg][end];
else
matrix[beg][end]=matrix[end][beg]=1-matrix[beg][end];
}
}
//输入检查
bool graph::check(int i,int j,int w)
{
if(i>=0 && i=0 && j0)
return true;
else
return false;
}
void graph::printAdjacentMatrix()
{
cout.setf(ios::left);
cout<
for(int i=0;i
cout<
cout<
for(int i=0;i
{
cout<
for(int j=0;j
cout<
cout<
}
}
dynamic_longest_path.h
#include "Graphic_longest_path.h"
#include
#include
#define INFINITY 0x7fffffff
int max(int a,int b)
{
return a>b?a:b;
}
int Find_longest_path(int **weight,int numVertexes,int k,int t,vector &r) //寻找k到t的最短路径
{
if(r[k]>=0)
return r[k];
if(k==t)
{
int q=0;
r[k]=q;
return q;
}
else
{
int q=weight[k][t];
for(int i=k+1;i<=t && weight[k][i];i++)
{
q=max(q,weight[k][i]+Find_longest_path(weight,numVertexes,i,t,r));
}
r[k]=q;
return q;
}
}
int dynamic_longest_path(int **weight,int numVertexes,int k,int t)
{
vector r;
r.resize(numVertexes);
for(int i=0;i
r[i]=-INFINITY;
return Find_longest_path(weight,numVertexes,k,t,r);
}
Graphic_longest_path.cpp
#include "dynamic_longest_path.h"
#include
int main()
{
cout<
bool isDirected, isWeighted;
int numV;
cout<
cout<
cin>>numV;
cout<
cin>>isWeighted;
cout<
cin>>isDirected;
graph graph(numV,isWeighted,isDirected);
cout<
isDirected ? cout<
isWeighted ? cout<
graph.createGraph();
cout<
graph.printAdjacentMatrix();
cout<
int k,t;
cout<
cin>>k>>t;
int numVertex=graph.getVerNums();
int **weight_dynamic=graph.getWeight();
cout<
cout<
int result=dynamic_longest_path(weight_dynamic,numVertex,k,t);
cout<
cout<
int beg, end, weight;
bool flag;
cout<
cin>>flag;
if(flag)
{
if(isWeighted)
{
cout<
cin>>beg>>end>>weight;
graph.setEdgeWeight(beg,end,weight);
}
else
{
cout<
cin>>beg>>end;
graph.setEdgeWeight(beg,end,1);
}
cout<
cout<
graph.printAdjacentMatrix();
}
return 0;
}
重构解
为了能够输出最短路径的方案，可以对解进行重构：
Graphic_longest_path.h
#include
#include
using namespace std;
#define INITWEIGHT 0
//用矩阵实现图
class graph
{
private:
bool isWeighted; //是否带权？
bool isDirected; //是否有向？
int numV; //顶点数
int numE; //边数
int **matrix; //邻接矩阵
public:
graph(int numV,bool isWeighted=false,bool isDirected=false);
void createGraph();
~graph();
int getVerNums()
{
return numV;
}
int getEdgeNums()
{
return numE;
}
int **getWeight()
{
return matrix;
}
void setEdgeWeight(int beg,int end,int weight);
void printAdjacentMatrix();
//检查输入
bool check(int i,int j,int w=1);
};
//类的实现
graph::graph(int numV,bool isWeighted,bool isDirected)
{
while(numV<=0)
{
cout<
cin>>numV;
}
this->numV=numV;
this->isWeighted=isWeighted;
this->isDirected=isDirected;
//private之后的成员可以被类的成员函数访问，但是不能够被使用该类的代码访问
matrix=new int *[numV];
for(int i=0;i
matrix[i]=new int [numV];
//对图进行初始化
if(!isWeighted) //无权图
{
//对所有的权值初始化为0
for(int i=0;i
for(int j=0;j
matrix[i][j]=0;
}
else //有权图
{
for(int i=0;i
for(int j=0;j
matrix[i][j]=INITWEIGHT;
}
}
//建图
void graph::createGraph()
{
cout<
while(cin>>numE && numE<0)
cout<
int i,j,w;
if(!isWeighted) //无权图
{
if(!isDirected) //无向图
{
cout<
for(int k=0;k
{
cin>>i>>j;
while(!check(i,j))
{
cout<
cin>>i>>j;
}
matrix[i][j]=matrix[j][i]=1;
}
}
else
{
cout<
for(int k=0;k
{
cin>>i>>j;
while(!check(i,j))
{
cout<
cin>>i>>j;
}
matrix[i][j]=1;
}
}
}
else //有权图
{
if(!isDirected) //无向图
{
cout<
for(int k=0;k
{
cin>>i>>j>>w;
while(!check(i,j,w))
{
cout<
cin>>i>>j>>w;
}
matrix[i][j]=matrix[j][i]=w;
}
}
else
{
cout<
for(int k=0;k
{
cin>>i>>j>>w;
while(!check(i,j,w))
{
cout<
cin>>i>>j>>w;
}
matrix[i][j]=w;
}
}
}
}
graph::~graph() //析构函数
{
for(int i=0;i
delete[] matrix[i];
delete[] matrix;
}
//设置指定边权值：
void graph::setEdgeWeight(int beg,int end,int weight)
{
if(isWeighted)
{
while(!check(beg,end,weight))
{
cout<
cin>>beg>>end>>weight;
}
if(isDirected)
matrix[beg][end]=weight;
else
matrix[beg][end]=matrix[end][beg]=weight;
}
else
{
while(!check(beg,end,1))
{
cout<
cin>>beg>>end;
}
if(isDirected) //对邻接矩阵的值进行反转，重置，1变成0，0变成1
matrix[beg][end]=1-matrix[beg][end];
else
matrix[beg][end]=matrix[end][beg]=1-matrix[beg][end];
}
}
//输入检查
bool graph::check(int i,int j,int w)
{
if(i>=0 && i=0 && j0)
return true;
else
return false;
}
void graph::printAdjacentMatrix()
{
cout.setf(ios::left);
cout<
for(int i=0;i
cout<
cout<
for(int i=0;i
{
cout<
for(int j=0;j
cout<
cout<
}
}
longest_path_constitute.h
#include "Graphic_longest_path.h"
#include
#include
#define INFINITY 0x7fffffff
int max(int a,int b)
{
return a>b?a:b;
}
int Find_longest_path(int **weight,int numVertexes,int k,int t,vector &r,int *solution) //寻找k到t的最短路径
{
if(r[k]>=0)
return r[k];
if(k==t)
{
int q=0;
r[k]=q;
solution[k]=t;
return q;
}
else
{
int q=weight[k][t];
if(weight[k][t])
solution[k]=t;
for(int i=k+1;i<=t && weight[k][i];i++)
{
int tmp=max(q,weight[k][i]+Find_longest_path(weight,numVertexes,i,t,r,solution));
if(tmp>q)
{
q=tmp;
solution[k]=i;
}
}
r[k]=q;
return q;
}
}
int dynamic_longest_path(int **weight,int numVertexes,int k,int t,int *solution)
{
vector r;
r.resize(numVertexes);
for(int i=0;i
{
r[i]=-INFINITY;
}
//完成初始化
return Find_longest_path(weight,numVertexes,k,t,r,solution);
}
void print_solution(int *solution,int k,int t)
{
if(solution[k]==-1)
cout<
else
{
cout<
cout< ";
while(k!=t)
{
cout<
if(solution[k]!=t)
{
cout< ";
}
k=solution[k];
}
cout<
}
}
Graphic_longest_path.cpp
#include "longest_path_constitute.h"
#include
int main()
{
cout<
bool isDirected, isWeighted;
int numV;
cout<
cout<
cin>>numV;
cout<
cin>>isWeighted;
cout<
cin>>isDirected;
graph graph(numV,isWeighted,isDirected);
cout<
isDirected ? cout<
isWeighted ? cout<
graph.createGraph();
cout<
graph.printAdjacentMatrix();
cout<
int k,t;
cout<
cin>>k>>t;
int numVertex=graph.getVerNums();
int **weight_dynamic=graph.getWeight();
cout<
cout<
//初始化solution：
int *solution=new int[numVertex+1];
for(int i=0;i
solution[i]=-1;
//返回最优解：
int result=dynamic_longest_path(weight_dynamic,numVertex,k,t,solution);
cout<
cout<
//返回solution的解，注意delete[]
cout<
print_solution(solution,k,t);
int beg, end, weight;
bool flag;
cout<
cin>>flag;
if(flag)
{
if(isWeighted)
{
cout<
cin>>beg>>end>>weight;
graph.setEdgeWeight(beg,end,weight);
}
else
{
cout<
cin>>beg>>end;
graph.setEdgeWeight(beg,end,1);
}
cout<
cout<
graph.printAdjacentMatrix();
}
return 0;
}
输出结果
