int dfs_path(int cur, int dep)
{
int idx;
edge_st *pe;
if (dep >= n_idx)
return 1;
idx = vetexs[cur].next;
pe = &edges[idx];
while(1) {
if (used[pe->idx]) {
if(pe->next == -1)
return 0;
pe = &edges[pe->next];
continue;
}
stack[dep] = pe->edge_num;
used[pe->idx] = 1;
if (dfs_path(pe->v, dep+1)) {
return 1;
}
used[pe->idx] = 0;
stack[dep] = 0;
if (pe->next == -1) {
break;
}
pe = &edges[pe->next];
}
return 0;
}
int main(int argc, char * argv[])
{
while(init()) {
if(check_path() &&
dfs_path(begin, 0)) {
dump_card();
} else {
printf("no solution\n");
}
}
return 0;
}
void Graph::path(int start,int end)
{
/*
Finds the path between two vertices in the graph.
This uses DFS algorithm. This might not be the
shortest path between the two vertices.
Idea is to store the path using a stack in the DFS
algorithm and print the stack when the end vertex
is reached by the DFS algorithm.
*/
Stack<int> s(SIZE);
bool visited[SIZE] = {false};
std::cout<<std::endl;
std::cout<<"Path "<<start<<"-->"<<end<<" : ";
dfs_path(start,end,visited,&s);
}
int dfs_path(bipartite b, int *visit_x, int *visit_y, int p,
int *ymatch, int *a_label, int *b_label)
{
visit_x[p] = 1;
for(int i = 0; i < b.b_yn; ++ i)
if(!visit_y[i] && b.b_g[p][i] &&
a_label[p] + b_label[i] == b.b_g[p][i]){
//“带权二分图的最优匹配 Kuhn-Munkres算法(转)”中缺少的判断条件是
//b.b_g[p][i]这一句，即判断节点p与节点i之间存在边
//本文之前的若干二分图算法的代码中都有这个判断，此处应该是原作者的失误
visit_y[i] = 1;
if(ymatch[i] == -1 ||
dfs_path(b, visit_x, visit_y, ymatch[i],
ymatch, a_label, b_label)){
ymatch[i] = p;
return(1);
}
}
return(0);
}
void Graph::dfs_path(int start,int end, bool visited[],Stack<int> *s)
{
visited[start] = true;
s->push(start);
if(s->topofstack() == end)
{
s->print();
}
Node<int> *curr = array[start].gethead();
while(curr!=NULL)
{
if(!visited[curr->getData()])
{
dfs_path(curr->getData(),end,visited,s);
}
curr = curr->getNext();
}
s->pop();
}
int kuhn_munkres(bipartite b, int *ymatch)
{//二分图B存在完备匹配，故它的X和Y集合节点数量相同
//X集合有b_xn个节点，下标从0到b_xn-1，Y集合有b_yn个节点，下标从0到b_yn-1
//b_g[i][j]指代节点i和节点j之间的边的权值，其中节点i属于X集合，节点j属于Y集合
memset(ymatch, -1, MAX * sizeof(int));
//数组a_label和b_label为节点标号
//数组visit_x(visit_y)标记X(Y)集合中节点是否被访问过
int a_label[MAX], b_label[MAX], visit_x[MAX], visit_y[MAX];
//初始化节点标号数组a_label和b_label
//X集合中每个节点i的标号初始化为其所有邻边中最大的权值，Y集合中所有节点i标号为0
//从而保证对于每条边e都有A[i]+B[i]>=value(e)
construct_s(b, a_label, b_label);
for(int i = 0; i < b.b_xn; ++ i)
while(1){
memset(visit_x, 0, MAX * sizeof(int));
memset(visit_y, 0, MAX * sizeof(int));
if(dfs_path(b, visit_x, visit_y, i, ymatch, a_label, b_label))
break;
int tmp_label(INF);
for(int j = 0; j < b.b_xn; ++ j)
if(visit_x[j])
for(int k = 0; k < b.b_yn; ++ k)
if(!visit_y[k])
tmp_label = min(tmp_label,
a_label[j] + b_label[k] - b.b_g[j][k]);
for(int j = 0; j < b.b_xn; ++ j){
if(visit_x[j])
a_label[j] -= tmp_label;
if(visit_y[j])
b_label[j] += tmp_label;
}
}
int max_match(0);
for(int i = 0; i < b.b_yn; ++ i)
max_match += b.b_g[ymatch[i]][i];
return(max_match);
}
