BNU 20860——Forwarding Emails——————【强连通图缩点+记忆化搜索】

Forwarding Emails

Time Limit: 1000ms

Memory Limit: 131072KB

This problem will be judged on UVA. Original ID: 12442
64-bit integer IO format: %lld      Java class name: Main

Prev

Submit Status Statistics Discuss

Next

Type:

None

 

None

Graph Theory

2-SAT

Articulation/Bridge/Biconnected Component

Cycles/Topological Sorting/Strongly Connected Component

Shortest Path

Bellman Ford

Dijkstra/Floyd Warshall

Euler Trail/Circuit

Heavy-Light Decomposition

Minimum Spanning Tree

Stable Marriage Problem

Trees

Directed Minimum Spanning Tree

Flow/Matching

Graph Matching

Bipartite Matching

Hopcroft–Karp Bipartite Matching

Weighted Bipartite Matching/Hungarian Algorithm

Flow

Max Flow/Min Cut

Min Cost Max Flow

DFS-like

Backtracking with Pruning/Branch and Bound

Basic Recursion

IDA* Search

Parsing/Grammar

Breadth First Search/Depth First Search

Advanced Search Techniques

Binary Search/Bisection

Ternary Search

Geometry

Basic Geometry

Computational Geometry

Convex Hull

Pick's Theorem

Game Theory

Green Hackenbush/Colon Principle/Fusion Principle

Nim

Sprague-Grundy Number

Matrix

Gaussian Elimination

Matrix Exponentiation

Data Structures

Basic Data Structures

Binary Indexed Tree

Binary Search Tree

Hashing

Orthogonal Range Search

Range Minimum Query/Lowest Common Ancestor

Segment Tree/Interval Tree

Trie Tree

Sorting

Disjoint Set

String

Aho Corasick

Knuth-Morris-Pratt

Suffix Array/Suffix Tree

Math

Basic Math

Big Integer Arithmetic

Number Theory

Chinese Remainder Theorem

Extended Euclid

Inclusion/Exclusion

Modular Arithmetic

Combinatorics

Group Theory/Burnside's lemma

Counting

Probability/Expected Value

Others

Tricky

Hardest

Unusual

Brute Force

Implementation

Constructive Algorithms

Two Pointer

Bitmask

Beginner

Discrete Logarithm/Shank's Baby-step Giant-step Algorithm

Greedy

Divide and Conquer

Dynamic Programming

Tag it!

[PDF Link]

J	Forwarding Emails

"... so forward this to ten other people, to prove that you believe the emperor has new clothes."

Aren't those sorts of emails annoying?

Martians get those sorts of emails too, but they have an innovative way of dealing with them. Instead of just forwarding them willy-nilly, or not at all, they each pick one other person they know to email those things to every time - exactly one, no less, no more (and never themselves). Now, the Martian clan chieftain wants to get an email to start going around, but he stubbornly only wants to send one email. Being the chieftain, he managed to find out who forwards emails to whom, and he wants to know: which Martian should he send it to maximize the number of Martians that see it?

Input

The first line of input will contain T (≤ 20) denoting the number of cases.

Each case starts with a line containing an integer N (2 ≤ N ≤ 50000) denoting the number of Martians in the community. Each of the next N lines contains two integers: u v (1 ≤ u, v ≤ N, u ≠ v) meaning that Martian u forwards email to Martian v.

Output

For each case, print the case number and an integer m, where m is the Martian that the chieftain should send the initial email to. If there is more than one correct answer, output the smallest number.

Sample Input	Output for Sample Input
3 3 1 2 2 3 3 1 4 1 2 2 1 4 3 3 2 5 1 2 2 1 5 3 3 4 4 5	Case 1: 1 Case 2: 4 Case 3: 3

题目大意：现在要转发邮件，有n个人，有n条边，表示u--->v可以转发邮件。有一个人想要在这n个人中选一个人作为起点进行邮件转发。想要让转发给的人尽量多，问从哪里开始转发可以满足条件。

解题思路：想转发给的人尽量多，即要求让经过的点尽量多。我们可以在有向图上进行强连通缩点。然后在缩点形成的DAG上进行DFS。然后遍历判断从哪个连通块出发能经过最多的点，在求出该连通块的最小顶点编号即为结果。

#include<bits/stdc++.h>
using namespace std;
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
const int maxn=50050;
vector<int>G[maxn];
int pre[maxn],lowlink[maxn],sccno[maxn],dfs_clock,scc_cnt;
int dp[maxn],d[maxn];
stack<int>S;
set<int>ST[maxn];//新的DAG需要去重边
//tarjan 模板
void dfs(int u){
    pre[u]=lowlink[u]=++dfs_clock;
    S.push(u);
    for(int i=0;i<G[u].size();i++){
        int v=G[u][i];
        if(!pre[v]){
            dfs(v);
            lowlink[u]=min(lowlink[u],lowlink[v]);
        }else if(!sccno[v]){
            lowlink[u]=min(lowlink[u],pre[v]);
        }
    }
    if(lowlink[u]==pre[u]){
        scc_cnt++;
        for(;;){
            int x=S.top();S.pop();
            sccno[x]=scc_cnt;
            if(x==u)
                break;
        }
    }
}
void find_scc(int n){
    dfs_clock=scc_cnt=0;
    while(!S.empty())
        S.pop();
    memset(sccno,0,sizeof(sccno));
    memset(pre,0,sizeof(pre));
    for(int i=0;i<n;i++){
        if(!pre[i])
            dfs(i);
    }
}
int DFS(int u){
    if(dp[u])
        return dp[u];
    dp[u]=d[u];
    for(set<int>::iterator it=ST[u].begin();it!=ST[u].end();it++){
        int v=*it;
        if(!dp[v]){
            dp[u]+=DFS(v);
        }else {
            dp[u]+=dp[v];
        }
    }
    return dp[u];
}
int main(){
    int t,n,a,b,cnt=0;
    scanf("%d",&t);
    while(t--){
        memset(dp,0,sizeof(dp));
        memset(d,0,sizeof(d));
        scanf("%d",&n);
        for(int i=0;i<n;i++){
            scanf("%d%d",&a,&b);
            a--,b--;
            G[a].push_back(b);
        }
        find_scc(n);
        for(int i=0;i<n;i++){
            d[sccno[i]]++;
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<G[i].size();j++){
                int v=G[i][j];
                if(sccno[i]!=sccno[v])//SB了，开始忘了加这个条件，要是不同的连通块
                    ST[sccno[i]].insert(sccno[v]);
            }
        }
        for(int i=1;i<=scc_cnt;i++){//在连通块形成的DAG上记忆化搜索
            if(!dp[i]){
                DFS(i);
            }
        }
        int sum=0,ck=0;
        for(int i=1;i<=scc_cnt;i++){
            if(dp[i]>sum){
                ck=i;
                sum=dp[i];
            }
        }
        int ok=0;
        for(int i=0;i<n;i++){
            if(sccno[i]==ck){
                ok=i;
                break;
            }
        }
        printf("Case %d: %d\n",++cnt,ok+1);
        for(int i=0;i<=n;i++)
            G[i].clear();
        for(int i=1;i<=scc_cnt;i++){
            ST[i].clear();
        }
    }
    return 0;
}

/*
55
4
1 2
2 1
4 3
3 2

5
1 2
2 1
5 3
3 4
4 5
*/