std::vector<size_t> topological_sort(const Graph& g) {
enum class colors { white, gray, black };
const size_t num_v = g.num_vertices();
std::vector<size_t> list(num_v);
std::vector<colors> color(num_v, colors::white);
size_t cur_pos = num_v;
std::function<void(size_t)> dfs_visit;
dfs_visit = [&](const size_t src) {
color[src] = colors::gray;
for (const auto e : g.out_edges(src)) {
const size_t tgt = g.target(e);
if (color[tgt] == colors::white)
dfs_visit(tgt);
else if (color[tgt] == colors::gray)
throw std::logic_error("Not a DAG");
}
color[src] = colors::black;
list[--cur_pos] = src;
};
for (size_t v = 0; v != num_v; ++v)
if (color[v] == colors::white)
dfs_visit(v);
return list;
}
void dfs(Graph* g, int mode){
int u;
for (u=0; u < g->nVertices; u++){
g->color[u]= 'W';
g->p[u]=-1;
}
time = 1;
if(mode==1){
for (u=g->nVertices*2-1; u >=0; u--){
if(temp_fin_aux[u]!=-1){
if(g->color[temp_fin_aux[u]] == 'W'){
tamanhoSCC=0;
scc++;
dfs_visit(g,temp_fin_aux[u],mode);
tamanhoSCC++;
}
}
if(tamanhoSCC>SCCBigger) SCCBigger=tamanhoSCC;
}
return;
}
for (u=0; u < g->nVertices; u++){
if(g->color[u] == 'W'){
dfs_visit(g,u, mode);
}
}
}
void Graph::dfs_visit(int dfsId, int nodeU, std::vector<int> * finishTime, bool transpose, bool undirect){
colors[nodeU] = 1;
if( transpose or undirect){
for(unsigned j=0; j<AdjT[nodeU].size(); j++){
int nodeV = AdjT[nodeU][j];
if( colors[nodeV] == 0 ){
dfsParent[nodeV] = nodeU;
dfsDiscoveredId[nodeV] = dfsId;
dfs_visit(dfsId,nodeV,finishTime,transpose,undirect);
}
}
}
if( (!transpose) or undirect ){
for(unsigned j=0; j<Adj[nodeU].size(); j++){
int nodeV = Adj[nodeU][j];
if( colors[nodeV] == 0 ){
dfsParent[nodeV] = nodeU;
dfsDiscoveredId[nodeV] = dfsId;
dfs_visit(dfsId,nodeV,finishTime,transpose,undirect);
}
}
}
colors[nodeU] = 2;
finishTime->push_back(nodeU);
}
bool is_bipartite(const Graph &g, std::vector<bool> &color) {
const size_t num_v = g.num_vertices();
std::vector<bool> visited(num_v);
color.resize(num_v);
std::function<void(size_t)> dfs_visit;
dfs_visit = [&](const size_t src) {
visited[src] = true;
for (const auto e : g.out_edges(src)) {
const size_t tgt = (src == g.source(e)) ? g.target(e) : g.source(e);
if (!visited[tgt]) {
color[tgt] = !color[src];
dfs_visit(tgt);
} else if (color[src] == color[tgt])
throw std::logic_error("Not bipartite");
}
};
for (size_t v = 0; v != num_v; ++v)
if (!visited[v])
try {
dfs_visit(v); // The color of 'v' is left as is.
} catch (std::logic_error &) {
return false;
}
return true;
}
void find_bridges(const Graph &g, UnaryFunction output_bridge) {
const size_t num_v = g.num_vertices();
size_t time = 0;
std::vector<size_t> pred(num_v, SIZE_MAX);
std::vector<size_t> dtm(num_v);
std::vector<size_t> low(num_v);
std::function<void(size_t)> dfs_visit;
dfs_visit = [&](const size_t src) {
low[src] = dtm[src] = ++time;
for (const auto e : g.out_edges(src)) {
const size_t tgt = (src == g.source(e)) ? g.target(e) : g.source(e);
if (!dtm[tgt]) {
pred[tgt] = src;
dfs_visit(tgt);
low[src] = std::min(low[src], low[tgt]);
if (low[tgt] > dtm[src])
output_bridge(e);
} else if (tgt != pred[src])
low[src] = std::min(low[src], dtm[tgt]);
}
};
for (size_t v = 0; v != num_v; ++v)
if (!dtm[v])
dfs_visit(v);
}
void Graph::build_dfs(int index_node){
dfs_visit(index_node);
for(auto n:list_graph){
if(n.second.color==white){
dfs_visit(n.first);
}
}
print_dfs();
}
static int
dfs_visit (L_Cb * cb, Set blocks, L_Cb * header)
{
L_Flow *dest;
L_Cb *dest_cb;
int cycle = 0;
cb->flags = L_SET_BIT_FLAG (cb->flags, L_CB_VISITED);
for (dest = cb->dest_flow; dest; dest = dest->next_flow)
{
dest_cb = dest->dst_cb;
/* Ignore backedges to region header and side exit arcs */
if ((dest_cb == header) ||
!Set_in (blocks, dest_cb->id))
continue;
if (!L_EXTRACT_BIT_VAL (dest_cb->flags, L_CB_VISITED))
cycle |= dfs_visit (dest_cb, blocks, header);
else if (!L_EXTRACT_BIT_VAL (dest_cb->flags, L_CB_VISITED2))
cycle = 1;
}
cb->flags = L_SET_BIT_FLAG (cb->flags, L_CB_VISITED2);
return cycle;
}
std::vector<int> * Graph::dfs( bool transpose=false, bool undirect=false, std::vector<int> * rOrder=NULL){
int size = numberOfVertices;
for(int i=0; i<size; i++){
colors[i] = 0;
dfsParent[i] = -1;
dfsDiscoveredId[i] = -1;
}
std::vector<int> * finishTime = new std::vector<int> ();
int dfsId = -1;
for(int i=0; i<size; i++){
int node = i;
if( rOrder != NULL ) { node = rOrder->at( size - i -1); }
if( colors[node] == 0 ){
// std::cout << "Dfs a partir de: " << node+1 << "\n";
dfsId++;
dfsDiscoveredId[node] = dfsId;
dfs_visit(dfsId,node, finishTime, transpose, undirect);
}
}
numberOfSCCs = dfsId+1;
return finishTime;
}
void dfs(int G[6][6], char E[6][6]){
int visited[6]={0,0,0,0,0,0},i,j,time=0;
int start[6] = {0,0,0,0,0,0};
int finish[6] = {0,0,0,0,0,0};
for(i=0;i<6;i++){
if(!visited[i])
dfs_visit(i,G,E,visited,start,finish);
}
printf("start :");
for(i=0;i<6;i++)
printf("%d ",start[i]);
printf("\nfinish:");
for(i=0;i<6;i++)
printf("%d ",finish[i]);
printf("\n");
for(i=0;i<6;i++)
{
for(j=0;j<6;j++){
if(G[i][j]){
if(start[j]<start[i] && start[i]<finish[i] && finish[i]<finish[j])
E[i][j] = 'B';
if(start[i]<start[j] && start[j]<finish[j] && finish[j]<finish[i] && E[i][j]!='T')
E[i][j] = 'F';
if(start[j]<finish[j] && finish[j]<start[i] && start[i]<finish[i])
E[i][j] = 'C';
printf("%c ",E[i][j]);
}
else
printf("* ");
}
printf("\n");
}
toposort(finish);
}
void dfs_visit(graph* g,node* s)
{
s->d = ++timer ;
s->low = s->d ;
s->color = gray ;
edge* curedge = g->adjlist[s->idx]->firstedge ;
for( ; curedge != NULL ; curedge = curedge->next)
{
node* cur = curedge->v ;
if(cur->color == white)
{
cur->parent = s ;
dfs_visit(g,cur) ;
s->low = min(s->low , cur->low) ;
if( (cur->low) > (s->d) )
{
printf("%d %d\n" , s->idx , cur->idx) ;
}
}
else if(cur != s->parent)
{
s->low = min(s->low , cur->d) ;
}
}
s->f = ++timer ;
s->color = black ;
}
void DFS(Graph *p)
{
for(int i = 0; i<p->nodes.size(); i++)
{
p->nodes[i]->color = 0;
// p->nodes[i]->prev = DIS_INF;
}
time1 = 0;
for(int i = 0; i<p->nodes.size();i++)
{
if(p->nodes[i]->color == 0)
{
temp = new CC("temp");
cout<<endl;
// cout<<"nodes id draw: "<<p->nodes[i]->id+1<<endl;
cout<<p->nodes[i]->left<<" ";
cout<<p->nodes[i]->down<<" ";
cout<<p->nodes[i]->right<<" ";
cout<<p->nodes[i]->top<<endl;
dfs_visit(p,p->nodes[i]);
p->connected.push_back(temp);
}
}
}
void dfs_visit(int u,int V,int G[V][V],char E[V][V],int color[],int parent[]){
color[u]=G;
int v,t;
for(v=0;v<V;i++){
if(G[u][v]){
switch(color[v]){
case W: E[u][v]='T';
parent[v]=u;
dfs_visit(v,V,G,E,color,parent);
break;
case G: E[u][v]='B';
break;
case B: t=v;
while(parent[t]!=v){
if(parent[t]==u){
E[u][v]='F';
break;
}
t=parent[t];
}
if(E[u][v]!='F')
E[u][v]='C';
break;
}
}
}
}
void dfs_visit(Graph* g, int u, int mode){
List* auxlist;
g->color[u] = 'G';
g->d[u] = time;
time++;
auxlist = g->listaAdjac[u];
if(mode==1) verticeSCC[u]=scc;
while(auxlist != NULL){
if(auxlist->value != -1){
if (g->color[auxlist->value-1] == 'W'){
g->p[auxlist->value-1] = u;
dfs_visit(g,auxlist->value-1,mode);
tamanhoSCC++;
}
else if(g->color[auxlist->value-1]=='B' && mode==1){
if(sccBit[verticeSCC[auxlist->value-1]]==0 && verticeSCC[auxlist->value-1]!=verticeSCC[u]){
GtconnectSCC++;
sccBit[verticeSCC[auxlist->value-1]]=1;
}
}
}
auxlist=auxlist->next;
}
g->color[u] = 'B';
g->f[u] = time;
if(mode==0){
temp_fin_aux[g->f[u]-1] = u;
}
time++;
}
void dfs_visit(Graph* p, Node* in)
{
time1 = time1 + 1;
in->d = time1;
in->color = -1;
if(in->edge.size() == 0)
{
temp->nodes.push_back(in);
}
// cout<<"aa"<<in->edge.size()<<endl;
for(int i = 0; i<in->edge.size();i++)
{
if(in->edge[i]->getNeighbor(in)->color == 0)
{
// CC* c1 = new CC("1");
// c1->addEdge(in,in->edge[i]->getNeighbor(in));
// p->connected.push_back(c1);
temp->addEdge(in, in->edge[i]->getNeighbor(in));
in->edge[i]->getNeighbor(in)->prev = in;
// cout<<"nodes id draw: "<<in->edge[i]->getNeighbor(in)->id+1<<endl;
cout<<p->nodes[in->edge[i]->getNeighbor(in)->id]->left<<" ";
cout<<p->nodes[in->edge[i]->getNeighbor(in)->id]->down<<" ";
cout<<p->nodes[in->edge[i]->getNeighbor(in)->id]->right<<" ";
cout<<p->nodes[in->edge[i]->getNeighbor(in)->id]->top<<endl;
dfs_visit(p,in->edge[i]->getNeighbor(in));
}
in->color = 1;
time1 = time1 + 1;
in->f = time1;
}
}
int main(void){
int t;
int n,a,b,i;
int hq1,hq2;
scanf("%d",&t);
while(t--){
scanf("%d%d%d",&n,&hq1,&hq2);
arr= createlist(n);
for(i=1;i<hq1;i++){
scanf("%d",&a);
arr[i].add(a);
arr[a].add(i);
}
for(i=hq1+1;i<=n;i++){
scanf("%d",&a);
arr[i].add(a);
arr[a].add(i);
}
dfs_visit(hq2);
for(i=1;i<hq2;i++)
printf("%d ",arr[i].parent);
for(i=hq2+1;i<=n;i++)
printf("%d ",arr[i].parent);
printf("\n");
}
return 0;
}
static void dfs (void) {
i_bb_t b;
for (b = i_fg_root; b; b = b->lnext)
b->color = WHITE;
dfn = num_bb+1;
NEW(nodes, dfn);
dfs_visit(i_fg_root); /* nodes[dfn..num_bb] stores visited nodes */
assert(dfn);
}
static void dfs(){
int i;
for(i=0;i<N;i++){color[i]=white;parent[i]=-1;time_stamp[i][0]=time_stamp[i][1]=0;}
time=0;
for(i=0;i<N;i++){
if(color[i]==white)
dfs_visit(i);
}
}
/*
* LB_hb_region_contains_cycle
* ----------------------------------------------------------------------
* Given a set of CB ids and a header CB, return 1 iff the region
* contains a cycle which does not include the header; 0 otherwise.
*/
int
LB_hb_region_contains_cycle (Set blocks, L_Cb * header)
{
int i, num_cb, *buf, cycle = 0;
L_Cb *cb;
num_cb = Set_size (blocks);
buf = (int *) alloca (sizeof (int) * num_cb);
Set_2array (blocks, buf);
for (i = 0; i < num_cb; i++)
{
cb = L_cb_hash_tbl_find (L_fn->cb_hash_tbl, buf[i]);
cb->flags = L_CLR_BIT_FLAG (cb->flags, L_CB_VISITED);
cb->flags = L_CLR_BIT_FLAG (cb->flags, L_CB_VISITED2);
}
if (dfs_visit (header, blocks, header))
{
cycle = 1;
}
else
{
for (i = 0; i < num_cb; i++)
{
cb = L_cb_hash_tbl_find (L_fn->cb_hash_tbl, buf[i]);
if (L_EXTRACT_BIT_VAL (cb->flags, L_CB_VISITED))
continue;
if (dfs_visit (cb, blocks, header))
{
cycle = 1;
break;
}
}
}
#ifdef DEBUG_CYCLE
if (cycle)
fprintf (stderr, "cycle in region (header %d)\n", header->id);
#endif
return cycle;
}
static void dfs_visit(int u){
time_stamp[u][0]=++time;
color[u]=gray;
int i;
for(i=0;i<N;i++){if(graph[u][i]==1 && color[i]==white){parent[i]=u;dfs_visit(i);}}
printf("%d ",u);
time_stamp[u][1]=++time;
color[u]=black;
}
void dfs(adj_table& adj) {
Sequence visitSequence(1, 0);
Table edgeColor;
if(dfs_visit(0, visitSequence, adj, edgeColor)) {
visitSequence.pop_back();
std::copy(visitSequence.begin(), visitSequence.end(),
std::ostream_iterator<unsigned>(std::cout, " -> "));
std::cout << "0\n";
}
}
void dfs(DFSVertex* vertices, int nelem) {
for (int u = 0; u < nelem; u++) {
vertices[u].super.color = WHITE;
vertices[u].super.parent = -1;
}
dfs_time = 0;
for (int u = 0; u < nelem; u++) {
if (vertices[u].super.color == WHITE) {
dfs_visit(vertices, nelem, u);
}
}
}
void dfs_visit(int a){
arr[a].set_visited();
node *temp;
int val;
for(temp=arr[a].head.next;temp;temp=temp->next){
val=temp->value;
if(arr[val].not_visited()){
arr[val].parent=a;
dfs_visit(val);
}
}
}
void dfs(graph* g)
{
int i ;
timer = 0 ;
for(i=1; i<= (g->vertices) ; ++i)
{
if(g->v[i]->color == white)
{
dfs_visit(g,g->v[i]) ;
}
}
}
void dfs_visit(int u,int G[6][6],char E[6][6],int visited[],int start[], int finish[]){
int v;
visited[u]=1;
printf("%d\n",u);
start[u]=++time;
for(v=0;v<6;v++){
if(G[u][v] && !visited[v]){
E[u][v] = 'T';
//E[u][v] = E[v][u] = 'T';
dfs_visit(v,G,E,visited,start,finish);
}
}
finish[u]=++time;
}
void detect_cycles(void)
{
struct wait_graph_node *ptr_wait;
//printf("\ndetect_cycle");
//fflush(stdout);
ptr_wait = head_wait_graph;
while(ptr_wait!= NULL)
{
if(ptr_wait->visited == 0)/*not visited*/
dfs_visit(ptr_wait);
ptr_wait = ptr_wait->next;
}
}
static void dfs_visit (i_bb_t b) {
i_bb_t *n = b->n; /* List of successors */
unsigned int nn = b->nn; /* Number of successors */
unsigned int i;
b->color = BLACK;
for (i = 0; i < nn; i++) /* Recurse on successors */
if (n[i]->color == WHITE)
dfs_visit(n[i]);
nodes[--dfn] = b;
#ifndef NDEBUG
b->dfn = dfn;
#endif
}
void dfs_visit(DFSVertex* vertices, int nelem, int u) {
dfs_time++;
vertices[u].d = dfs_time;
vertices[u].super.color = GRAY;
for (Adj* v = vertices[u].super.first; v; v = v->next) {
if (vertices[v->n].super.color == WHITE) {
vertices[v->n].super.parent = u;
dfs_visit(vertices, nelem, v->n);
}
}
vertices[u].super.color = BLACK;
dfs_time++;
vertices[u].f = dfs_time;
}
void dfs_visit(graph_list& g, int p, int *visited, int& time)
{//返回dfs搜索节点p的递归次数
//即从节点p开始dfs遍历到的节点数量，也是递归遍历花费的时间
print_node(&g.g_l[p][0]);
visited[p] = 1;
for(int i = 1; i < (int)g.g_l[p].size(); ++ i)
//寻找节点p的邻节点中，尚未被访问的所有邻节点
if(!visited[g.g_l[p][i].g_idx])
//对未被访问的所有节点进行下一轮dfs递归
//在有向图中，将当前节点看作子树中的根节点，所有其邻节点看作该节点的孩子
//则dfs过程也可以看作对当前节点的子树进行一次遍历
dfs_visit(g, g.g_l[p][i].g_idx, visited, time);
g.g_l[p][0].g_value = time ++;
}
void Graph::dfs_visit(int index_node){
time++;
list_graph[index_node].distance=time;
list_graph[index_node].color=grey;
for(auto i : list_graph[index_node].connect_node){
Node &n=list_graph[i];
if(n.color==white){
n.front=&list_graph[index_node];
dfs_visit(i);
}
}
list_graph[index_node].color=black;
time++;
list_graph[index_node].finish=time;
}
void dfs(int V,int G[V][V]){
int color[V],parent[V],i;
char E[V][V];
for(i=0;i<V;i++){
color[i]=W;
parent[i]=i;
}
for(i=0;i<V;i++)
for(j=0;j<V;j++)
E[i][j]='*';
for(i=0;i<V;i++)
if(color[i]==W)
dfs_visit(i,V,G,E,color,parent);
display(V,E);
}
