图¶

graph = (int **)malloc(N * sizeof(int *));
for(int i = 0; i < N ; i++){
    graph[i] = (int *)malloc(N * sizeof(int));
}//二维数组动态分配内存，可以用来表示图

void Topsort( Graph G ){   
    Queue  Q = CreateQueue( NumVertex );
    MakeEmpty( Q );
    int  Counter = 0;
    Vertex  V, W;

    for ( each vertex V )
        if ( Indegree[ V ] == 0 )   
            Enqueue( V, Q );

    while ( !IsEmpty( Q ) ) {
      V = Dequeue( Q );
      TopNum[ V ] = ++ Counter; /* assign next */
      for ( each W adjacent from V )
          if ( ––Indegree[ W ] == 0 )  
              Enqueue( W, Q );
    }  /* end-while */

    if ( Counter != NumVertex )
      Error( “Graph has a cycle” );

    DisposeQueue( Q ); /* free memory */
}

bool IsTopSeq(LGraph Graph,Vertex Seq[]){
    PtrToAdjVNode temp,pre;
    for(int i=0;i<Graph->Nv;i++){
        temp=(Graph->G)[Seq[i]-1].FirstEdge;
        while(temp!=NULL){
            for(int j=0;j<i;j++){
                if((temp->AdjV+1)==Seq[j]){
                    return false;
                }
            }
            pre=temp;
            temp=temp->Next;
        }
    }return true;
}

//BYD命名太混乱了，记个思路就行

/*
*每次循环将从Seq[i]out的edge归零
*修正：不用归零，因为之后就不会调用Seq[i]对应的Vertex了
*并且归零前检测一遍它指向的元素是否在Seq[i]前面，
*若在说明false，最后都没false就true
*/

//HW中的实现
typedef struct AdjVNode *PtrToAdjVNode; 
struct AdjVNode{
    Vertex AdjV;
    PtrToAdjVNode Next;
};

typedef struct Vnode{
    PtrToAdjVNode FirstEdge;
} AdjList[MaxVertexNum]; //AdjList[i]中存第i个vertex的out edge链表

typedef struct GNode *PtrToGNode;
struct GNode{  
    int Nv;
    int Ne;
    AdjList G;
};
typedef PtrToGNode LGraph;

LGraph G=ReadG();

int n, m, s, t; // s是源点，t是汇点
bool vis[MAXN];
int dfs(int p = s, int flow = INF){
    if (p == t)
        return flow; // 到达终点，返回这条增广路的流量
    vis[p] = true;
    for (int eg = head[p]; eg; eg = edges[eg].next){
        int to = edges[eg].to, vol = edges[eg].w, c;
        // 返回的条件是残余容量大于0、未访问过该点且接下来可以达到终点（递归地实现）
        // 传递下去的流量是边的容量与当前流量中的较小值
        if (vol > 0 && !vis[to] && (c = dfs(to, min(vol, flow))) != -1){
            edges[eg].w -= c;
            edges[eg ^ 1].w += c;
            // 这是链式前向星取反向边的一种简易的方法
            // 建图时要把cnt置为1，且要保证反向边紧接着正向边建立
            return c;
        }
    }
    return -1; // 无法到达终点
}
inline int FF()
{
    int ans = 0, c;
    while ((c = dfs()) != -1)
    {
        memset(vis, 0, sizeof(vis));
        ans += c;
    }
    return ans;
}

int n, m, s, t, last[MAXN], flow[MAXN];
inline int bfs()
{
    memset(last, -1, sizeof(last));
    queue<int> q;
    q.push(s);
    flow[s] = INF;
    while (!q.empty())
    {
        int p = q.front();
        q.pop();
        if (p == t) // 到达汇点，结束搜索
            break;
        for (int eg = head[p]; eg; eg = edges[eg].next)
        {
            int to = edges[eg].to, vol = edges[eg].w;
            if (vol > 0 && last[to] == -1) // 如果残余容量大于0且未访问过（所以last保持在-1）
            {
                last[to] = eg;
                flow[to] = min(flow[p], vol);
                q.push(to);
            }
        }
    }
    return last[t] != -1;
}
inline int EK()
{
    int maxflow = 0;
    while (bfs())
    {
        maxflow += flow[t];
        for (int i = t; i != s; i = edges[last[i] ^ 1].to) 
        // 从汇点原路返回更新残余容量
        {
            edges[last[i]].w -= flow[t];
            edges[last[i] ^ 1].w += flow[t];
        }
    }
    return maxflow;
}

void dfs(int x) {
    for (int y = 1; y <= maxn; ++y) {
        if (G[x][y]) {
            G[x][y] = 0;
            G[y][x] = 0;
            dfs(y);
        }
    }
    ans[++ansi] = x;
    return;
}
for (int i = 1; i <= maxn; ++i) {
    if (deg[i] % 2) {
        cnt++;
        if (!root) root = i;
    }
}
if (!root) {
    for (int i = 1; i <= maxn; ++i) {
        if (deg[i]) {
            root = i; 
            break;
        }
    }
}
if(cnt==2 || cnt == 0){
    dfs(root);
}else{
    printf("No Solution\n");
    return 0;
}

TARJAN_SEARCH(int u)
    vis[u]=true 
    low[u]=dfn[u]=++dfncnt 
    push u to the stack 
    for each (u,v) then do 
        if v has not been searched then 
            TARJAN_SEARCH(v) // 搜索 
            low[u]=min(low[u],low[v]) // 回溯 
        else if v has been in the stack then 
            low[u]=min(low[u],dfn[v])

int dfn[N], low[N], dfncnt, s[N], in_stack[N], tp; 
int scc[N], sc; // 结点 i 所在 SCC 的编号 
int sz[N]; // 强连通 i 的大小 
void tarjan(int u) { 
    low[u] = dfn[u] = ++dfncnt, s[++tp] = u, in_stack[u] = 1; 
    for (int i = h[u]; i; i = e[i].nex) { 
        const int &v = e[i].t; 
        if (!dfn[v]) { 
            tarjan(v); 
            low[u] = min(low[u], low[v]); 
        } else if (in_stack[v]) { 
            low[u] = min(low[u], dfn[v]); 
        } 
    } if (dfn[u] == low[u]) { 
        ++sc; 
        while (s[tp] != u) { 
            scc[s[tp]] = sc; 
            sz[sc]++; 
            in_stack[s[tp]] = 0; 
            --tp; 
        } scc[s[tp]] = sc; 
        sz[sc]++; 
        in_stack[s[tp]] = 0; --tp; 
    } 
}