拓扑排序

以下是关于拓扑排序应用的例题

#include <iostream>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;
const int maxn = 1e5 + 10;
int T, n, m, u, v, num;
int InDeg[maxn];//入度 
vector<int> vec[maxn];//邻接表 
//判断是否有环 
queue<int> q; 
//复杂度0(v + e) 
/*
2
2 2
1 2
2 1
3 2
1 2
1 3
输出 Wrong
Correct 
*/
bool topsort(){
    while(!q.empty()){//清空队列 
        q.pop();
    }
    int num=0;//记录被删去的节点数 
    for(int i = 1; i <= n; i++){
        if(!InDeg[i]){//将入度为0的顶点入队 
            q.push(i);
        }
    }
    while(!q.empty()){
        int now = q.front();
        q.pop();
        num++;
        //遍历当前元素下一个元素的所有元素 
        for(int i= 0;i < vec[now].size();i++){
            //与当前点连的，入度为1的入队（且减为0）度数大于1的度数减1但不入队，小于1的不影响 
            if(--InDeg[vec[now][i]] == 0){
                q.push(vec[now][i]);
            }
        }
    }
    //若删去的点等于原来图中点的个数则该有向图无环 
    if(num == n) return true;
    return false;
}
int main(){
    scanf("%d", &T);
    while(T--){
        scanf("%d%d", &n, &m);//读入n个顶点m条边 
        for(int i = 1; i <= n; i++){//清空该顶点到其他顶点的边 
            vec[i].clear();
        }
        memset(InDeg, 0, sizeof(InDeg)); //将记录入度的数组清空 
        while(m--){//读入m条边 
            scanf("%d%d", &u,&v);
            vec[u].push_back(v);//从u到v建立连接（有向图） 
            InDeg[v]++;//将v的入度加1 
        }
        if(topsort()){
            puts("Correct");
        }else{
            puts("Wrong");
        } 
    }
    return 0;
} 

拓扑排序二

#1175 : 拓扑排序·二

时间限制:10000ms

单点时限:1000ms

内存限制:256MB

描述

小Hi和小Ho所在学校的校园网被黑客入侵并投放了病毒。这事在校内BBS上立刻引起了大家的讨论，当然小Hi和小Ho也参与到了其中。从大家各自了解的情况中，小Hi和小Ho整理得到了以下的信息：

• 校园网主干是由N个节点(编号1..N)组成，这些节点之间有一些单向的网路连接。若存在一条网路连接(u,v)链接了节点u和节点v，则节点u可以向节点v发送信息，但是节点v不能通过该链接向节点u发送信息。
• 在刚感染病毒时，校园网立刻切断了一些网络链接，恰好使得剩下网络连接不存在环，避免了节点被反复感染。也就是说从节点i扩散出的病毒，一定不会再回到节点i。
• 当1个病毒感染了节点后，它并不会检查这个节点是否被感染，而是直接将自身的拷贝向所有邻居节点发送，它自身则会留在当前节点。所以一个节点有可能存在多个病毒。
• 现在已经知道黑客在一开始在K个节点上分别投放了一个病毒。

举个例子，假设切断部分网络连接后学校网络如下图所示，由4个节点和4条链接构成。最开始只有节点1上有病毒。

最开始节点1向节点2和节点3传送了病毒，自身留有1个病毒：

其中一个病毒到达节点2后，向节点3传送了一个病毒。另一个到达节点3的病毒向节点4发送自己的拷贝：

当从节点2传送到节点3的病毒到达之后，该病毒又发送了一份自己的拷贝向节点4。此时节点3上留有2个病毒：

最后每个节点上的病毒为：

小Hi和小Ho根据目前的情况发现一段时间之后，所有的节点病毒数量一定不会再发生变化。那么对于整个网络来说，最后会有多少个病毒呢？

提示：拓扑排序的应用

输入

第1行：3个整数N,M,K，1≤K≤N≤100,000，1≤M≤500,000

第2行：K个整数A[i]，A[i]表示黑客在节点A[i]上放了1个病毒。1≤A[i]≤N

第3..M+2行：每行2个整数 u,v，表示存在一条从节点u到节点v的网络链接。数据保证为无环图。1≤u,v≤N

输出

第1行：1个整数，表示最后整个网络的病毒数量 MOD 142857

样例输入

4 4 1
1
1 2
1 3
2 3
3 4

样例输出

6

#include <iostream>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;
const int maxn = 1e5 + 10;
const int mod = 142857;
int T, n, m, u, v;
int InDeg[maxn];//入度 
int virus[maxn];//病毒的数量 
vector<int> vec[maxn];//邻接表 
queue<int> q; 
//拓扑排序二 
void topsort(){
    while(!q.empty()){//清空队列 
        q.pop();
    }
    for(int i = 1; i <= n; i++){
        if(!InDeg[i]){//将入度为0的顶点入队 
            q.push(i);
        }
    }
    while(!q.empty()){
        int now = q.front();
        q.pop();
        //遍历当前元素下一个元素的所有元素 
        for(int i= 0;i < vec[now].size();i++){
            //与当前点连的，入度为1的入队（且减为0）度数大于1的度数减1但不入队，小于1的不影响 
            if(--InDeg[vec[now][i]] == 0){
                q.push(vec[now][i]);
            }
            //与当前元素相连的元素的病毒数=（当前元素的病毒数+ 当前元素相连的元素的病毒数） % mod 
            virus[vec[now][i]] = (virus[vec[now][i]] + virus[now]) % mod;
        }
    }
    
}
int main(){
    int k, x;
    while(~scanf("%d%d%d",&n,&m,&k)){
        for(int i = 1; i <= n; i++){//清空该顶点到其他顶点的边 
            vec[i].clear();
        }
        memset(InDeg, 0, sizeof(InDeg)); //将记录入度的数组清空 
        memset(virus, 0, sizeof(virus)); 
        while(k--){
            scanf("%d",&x);
            virus[x]++;
        }
        while(m--){//读入m条边 
            scanf("%d%d", &u,&v);
            vec[u].push_back(v);//从u到v建立连接（有向图） 
            InDeg[v]++;//将v的入度加1 
        }
        topsort();
        int ans = 0; 
        for(int i = 1; i <= n; i++){
            ans = (ans + virus[i]) % mod;
        }
        printf("%d
",ans);
    }
    return 0;
} 

In this winter holiday, Bob has a plan for skiing at the mountain resort.

This ski resort has MM different ski paths and NNdifferent flags situated at those turning points.

The ii-th path from the S_iSi​-th flag to the T_iTi​-th flag has length L_iLi​.

Each path must follow the principal of reduction of heights and the start point must be higher than the end point strictly.

An available ski trail would start from a flag, passing through several flags along the paths, and end at another flag.

Now, you should help Bob find the longest available ski trail in the ski resort.

Input Format

The first line contains an integer TT, indicating that there are TT cases.

In each test case, the first line contains two integers NN and MM where 0 < N leq 100000<N≤10000and 0 < M leq 1000000<M≤100000 as described above.

Each of the following MM lines contains three integers S_iSi​, T_iTi​, and L_i~(0 < L_i < 1000)Li​ (0<Li​<1000)describing a path in the ski resort.

Output Format

For each test case, ouput one integer representing the length of the longest ski trail.

样例输入复制

1
5 4
1 3 3
2 3 4
3 4 1
3 5 2

样例输出复制

6

#include <iostream>
#include <vector>
#include <queue> 
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 1e5 + 10;
//pair中的first为终点second为边的权值,vec的下标为起点 
vector<pair<int, int> > vec[maxn];//邻接表 
int InDeg[maxn], dp[maxn];//InDeg用来记录每个点的入度，dp用来记录从起点到当前点的最长路 
queue<int> q;
int T,n,m,k,u,v,w,x,ans;
void topsort(){
    while(!q.empty()){
        q.pop();
    }
    for(int i = 1; i <= n; i++){
        if(!InDeg[i]) q.push(i);
    }
    while(!q.empty()){
        int now = q.front();
        q.pop();
        for(int i = 0; i < vec[now].size(); i++){
            if(--InDeg[vec[now][i].first] == 0){
                q.push(vec[now][i].first);
            }
            dp[vec[now][i].first] = max(dp[vec[now][i].first],dp[now] + vec[now][i].second);
        }
    }
}
int main(){
    scanf("%d", &T);
    while(T--){
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; i++){
            vec[i].clear();
        }
        memset(InDeg, 0, sizeof(InDeg));
        memset(dp, 0, sizeof(dp));
        while(m--){
            scanf("%d%d%d", &u,&v,&w);
            vec[u].push_back(make_pair(v, w));
            InDeg[v]++;
        }
        topsort();
        int maxx = -1;
        for(int i = 1; i <= n; i++){
            maxx = max(maxx, dp[i]);
        }
        printf("%d
", maxx);
    }
    return 0;
}

D. Almost Acyclic Graph

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

You are given a directed graph consisting of n vertices and m edges (each edge is directed, so it can be traversed in only one direction). You are allowed to remove at most one edge from it.

Can you make this graph acyclic by removing at most one edge from it? A directed graph is called acyclic iff it doesn't contain any cycle (a non-empty path that starts and ends in the same vertex).

Input

The first line contains two integers n and m (2 ≤ n ≤ 500, 1 ≤ m ≤ min(n(n - 1), 100000)) — the number of vertices and the number of edges, respectively.

Then m lines follow. Each line contains two integers u and v denoting a directed edge going from vertex u to vertex v (1 ≤ u, v ≤ n, u ≠ v). Each ordered pair (u, v) is listed at most once (there is at most one directed edge from u to v).

Output

If it is possible to make this graph acyclic by removing at most one edge, print YES. Otherwise, print NO.

Examples

input

Copy

3 4
1 2
2 3
3 2
3 1

output

Copy

YES

input

Copy

5 6
1 2
2 3
3 2
3 1
2 1
4 5

output

Copy

NO

Note

In the first example you can remove edge , and the graph becomes acyclic.

In the second example you have to remove at least two edges (for example,  and ) in order to make the graph acyclic.

这道题代码先放在这里，抽时间分析

#include <iostream>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;
const int maxn = 1e5 + 10;
vector<int> vec[maxn];
int inDeg[maxn], ruDeg[maxn], flag;
int ans, T, n, m, u, v, sorted;
queue<int> q;
bool topsort(){
    while(!q.empty()){
        q.pop();
    }
    sorted = 0;
    for(int i = 1; i <= n; i++){
        if(inDeg[i] == 0){
            q.push(i);
        }
    }
    while(!q.empty()){
        int now = q.front();
        q.pop();
        ++sorted;
        for(int i = 0; i < vec[now].size(); i++){
            if(--inDeg[vec[now][i]] == 0){
                q.push(vec[now][i]);
            }
        }
    }
    if(sorted == n){
        return true;
    }
    return false;
}
int main(){
    while(~scanf("%d%d",&n,&m)){
        for(int i = 1; i <= n; i++){
            vec[i].clear();
        }
        memset(inDeg, 0, sizeof(inDeg));
        memset(ruDeg, 0, sizeof(ruDeg));
        sorted = 0;
        while(m--){
            scanf("%d%d",&u,&v);
            vec[u].push_back(v);
            ruDeg[v]++;
            inDeg[v]++;
        }
        if(topsort()){
            puts("YES");
            continue;
        }else{
            flag = 0;
            for(int i = 1; i <= n; i++){
                memcpy(inDeg, ruDeg, sizeof(ruDeg));
                if(inDeg[i] >= 1){
                    inDeg[i]--;
                    if(topsort()){
                        flag = 1;
                        puts("YES");
                        break;
                    }
                }
            }
        }
        if(flag == 0){
            puts("NO");
        }
    }
    return 0;
}