最小点基，最小权点基(Summer Holiday HDU - 1827)(强连通分量的应用)

最小点基：

在有向图G中，如果存在一条从顶点vi到顶点vj的边，就称vi是vj的前代，vj是vi的后代。

设si是有向图G中的一个强连通分量，如果该强连通分量与图G其他部分相连的所有弧都是向外伸展的，即vj属于si而vk不属于si，vj不可能是vk的后代，这样的强连通分量称为最高强连通分量。

在有向图G=(V,E)中，B是V的子集。如果对于任意的vj属于V，不属于B，都存在一个vi属于B，使得vi是vj的前代，则称B是一个点基。在有向图G中，顶点数最少的点基称为最小点基。设图G的每个顶点vi都有一个非负的权值ai，使得顶点对应的权值ai之和最小的点基称为最小权点基。

注意：如果每个顶点vi的权ai都等于1，那么最小权点基就是最小点基。因此最小权点基是最小点基的一个特例。

最小点基算法：

是强连通的一个应用，找出图G的所有强连通分量，将每个强连通分量各自缩成一个点v，即删除各个强连通分量内的边，连接v与原强连通分量相连接的点。缩点后再找出入度为0的点，就是缩点前的最高的强连通分量。最小点基就从最高的强连通分量中任选一个顶点，组成的顶点集B就是图G的一个最小点基。

最小权点基：

最小权点基的算法基本上根最小点基一样，最小点基最后是从最高的强连通分量中任选一个顶点，组成最小点基；而最小权点基则是从最高的强连通分量中取权值最小的顶点，组成最小权点基。

传送门

题意：

    老师想通知他的所有学生一个消息，虽然他手上有他们的联系方式，但是一个一个联系太耗时间和电话费了。他知道其它人也有一些别人的联系方式，这样可以通知他人，再让他们去通知一下别人。现在要求出至少需要联系多少人，最少需要多少花费，使得所有的人都被通知到。

    上述问题可以抽象为：图G中，每个点都有一个权值，若a能联系到b，则连边(a,b)。选出最少的点数(或者权值最小)，使从这些点能到达所有点。

题解：求图G的强连通分量，入度为0的强连通分量个数即为最小点基，从每个入度为0的强连通分量中取出权值最小的点，构成的集合即最小权点基。

附上代码：

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int INF = 0x7fffffff;
const int MAX = 1005;

int n,m;
int node[MAX];

struct Edge
{
    int from;
    int to;
    int next;
};
Edge edges[2005];
int head[MAX],edgeNum;

int dfn[MAX],low[MAX],seq;
int stack[MAX],top;
bool inStack[MAX];
int belong[MAX],cnt;
int ind[MAX];
int cost[MAX];

void addEdge(int from, int to)
{
    edges[edgeNum].from = from;
    edges[edgeNum].to = to;
    edges[edgeNum].next = head[from];
    head[from] = edgeNum++;
}

int min(int a, int b)
{
    return a<b?a:b;
}

void Tarjan(int u)
{
    dfn[u] = low[u] = seq++;
    stack[top++] = u;
    inStack[u] = true;
    for(int i = head[u]; i != -1; i = edges[i].next){
        int w = edges[i].to;
        if(dfn[w] < 0){
            Tarjan(w);
            low[u] = min(low[u],low[w]);
        }
        else if(inStack[w]){
            low[u] = min(low[u],dfn[w]);
        }
    }
    if(dfn[u] == low[u]){
        int v;
        cnt++;
        do{
            top--;
            v =stack[top];
            inStack[v] = false;
            belong[v] = cnt;
        }while(u != v);
    }
}

void solve()
{
    int i;
    for(i = 1; i <= n; i++){
        if(dfn[i] < 0){
            Tarjan(i);
        }
    }
    for(i = 0; i < edgeNum; i++){
        if(belong[edges[i].from] != belong[edges[i].to]){
            ind[belong[edges[i].to]]++;
        }
    }
    for(i = 1; i <= n; i++){
        if(cost[belong[i]] > node[i]){
            cost[belong[i]] = node[i];
        }
    }
    int result1=0,result2=0;
    for(i = 1; i <= cnt; i++){
        if(ind[i]==0){
            result1++;
            result2 += cost[i];
        }
    }
    printf("%d %d\n",result1,result2);
}

int main()
{
    int i;
    int from,to;
    while(scanf("%d %d",&n,&m)!=EOF){
        edgeNum = seq = cnt = top = 0;
        memset(head,-1,sizeof(head));
        memset(dfn,-1,sizeof(dfn));
        memset(inStack,0,sizeof(inStack));
        memset(ind,0,sizeof(ind));
        for(i = 1; i <= n; i++){
            cost[i] = INF;
        }
        for(i = 1; i <= n; i++){
            scanf("%d",&node[i]);
        }
        for(i = 0; i < m; i++){
            scanf("%d %d",&from,&to);
            addEdge(from,to);
        }
        solve();
    }
    return 0;
}