图论模板1

// 并查集；

for (int i = 1; i <= n; i++)
{
    fathar[i] = i;
}
int find(int x)
{
    if (x == fathar[x])
        return x; // 如果找到根结点，则返回根节点编号x；
    else
        return find(fathar[x]); // 否则，递归判断x的父亲结点是否是根节点；
}

void union(int a, int b)
{
    int faA = find(a);
    int faB = find(b);
    if (faA != faB)
    {
        fathar[faA] = faB; // 如果两个不属于同一个集合，就合并他们；
    }
}

// dijkstra算法；
const int maxv = 1000;
const int INF = 0x3f3f3f3f;
int n, g[maxv][maxv];
int d[maxv];
bool vis[maxv] = {false};

void dijkstra(ints)
{
    fill(a, a + maxv, INF);
    d[s] = 0;
    for (int i = 0; i < n; i++)
    {
        int u = -1, min = INF;
        for (int j = 0; j < n; j++)
        {
            if (vis[j] == false && d[j] < min)
            {
                u = j;
                min = d[j];
            }
        }
    }
    if (u == -1)
        return;
    vis[u] = true;
    for (int v = 0; v < n; v++)
    {
        if (vis[v] == false && g[u][v] != INF && d[u] + g[u][v] < d[v])
        {
            d[v] = d[u] + g[u][v];
        }
    }
}

// Floyd算法

const int INF = 0x3f3f3f3f;
const int maxv = 200;
int n, m;
int dis[maxv][maxv];
void floyd()
{
    for (int k = 0; k < n; k++)
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (dis[i][k] != INF && dis[k][j] != INF && dis[i][k] + dis[k][j] < dis[i][j])
                {
                    dis[i][j] = dis[i][k] + dis[k][j];
                }
            }
        }
    }
}

// 最小生成树  prim算法
int n, g[maxv][maxv];
int d[maxv];
bool vis[maxv] = {false};
int prim()
{
    fill(d, d + maxv, INF);
    d[0] = 0;
    int ans = 0;
    for (int i = 0; i < n; i++)
    {
        int u = -1, min = INF;
        for (int j = 0; j < n; j++)
        {
            if (vis[j] == false && d[j] < min)
            {
                min = d[j];
                u = j;
            }
        }
    }
    if (u == -1)
        return -1;
    vis[u] = true;
    ams += d[u];
    for (int v = 0; v < n; v++)
    {
        if (vis[v] == false && g[u][v] != INF && g[u][v] < d[v])
        {
            d[v] = g[u][v];
        }
    }
    return ans;
}