标签 图论 下的文章

url: https://www.luogu.com.cn/problem/P1453

tag:
动态规划,图论,基环树,树形DP

思路:
基环树是一种特殊的图结构,可以看作是在一棵树的基础上加入一条额外的边,从而使图中恰好出现一个环,也称作单环图唯一环图(unicyclic graph)。其主要特点包括:

  1. 连通性:基环树是连通图,任意两个顶点之间都有路径相连。
  2. 唯一的环:整个图中仅存在一个简单环,其他部分均保持树的结构(即无环)。
  3. 分解思想:可以将基环树看作由一个环和附着在环上各个顶点上的若干棵树构成。对于很多算法(例如树形 DP),通常先对环进行特殊处理(比如“断环”),再处理附着的树结构。

这种结构在算法竞赛中经常出现,处理时通常需要先找出环,然后考虑两种或多种情况(例如环上某些节点选或不选),从而在保证整体方案最优的前提下完成状态转移和求解。

这道题目其实和求树的最小覆盖问题类似,我们用 f[u][0/1] 表示节点u为根且选或者不选时的总共人流量。只是因为有基环树,所以需要先断边,然后分别用那一边的两个点为根且不选(方便另外一个点可选)时各跑一遍dfs,求答案,最后两个答案求一个最大值并乘上k,注意,对于不同的情况来说需要先将f数组清空(因为可选的点不同了)。

代码:

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 1e5 + 10;
int h[N], e[N * 2], ne[N * 2], idx;
int p[N];
bool st[N];
double k;
int n, s1, s2, flag;
int f[N][2];
void add(int a, int b)
{
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx ++;
}
void dfs1(int u, int fa)
{
    st[u] = 1;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int v = e[i];
        if (v == fa) continue;
        if (st[v])
        {
            s1 = u, s2 = v;
            flag = true;
            return;
        }
        dfs1(v, u);
        if (flag) return ;
    }
    st[u] = 0;
}
void dfs2(int u, int fa)
{
    f[u][1] = p[u];
    for (int i = h[u]; ~i; i = ne[i])
    {
        int v = e[i];
        if (v == fa) continue;
        if ((u == s1 && v == s2) || (u == s2 && v == s1)) continue;
        dfs2(v, u);
        f[u][1] += f[v][0];
        f[u][0] += max(f[v][0], f[v][1]);
    }
}
int main()
{
    memset(h, -1, sizeof h);
    cin >> n;
    for (int i = 0; i < n; i ++) cin >> p[i];
    int a, b;
    for (int i = 0; i < n; i ++)
    {
        cin >> a >> b;
        add(a, b), add(b, a);
    }
    cin >> k;
    dfs1(0, 0);
    dfs2(s1, s1);
    int res1 = f[s1][0];
    memset(f, 0, sizeof f);
    dfs2(s2, s2);
    int res2 = f[s2][0];
    printf("%.1f", max(res1, res2) * k);
    return 0;
}

url: https://www.luogu.com.cn/problem/P1119

tag:
图论,枚举,最短路

思路:
这道题可以用floyd算法来做,每次询问,都将当前这个时间可以重建完的村庄用floyd算法更新一下所有点的最短路。最后判断一下这个询问的两个村庄是否重建完以及是否可以联通,如果重建完并且联通就输出最短路,否则输出-1

代码:

#include <iostream>
#include <vector>
using namespace std;
const int N = 220;
int n, m, q;
int f[N][N];
int a[N];

inline void update(int k)
{
    for (int i = 0; i < n; i ++)
        for (int j = 0;  j< n; j ++)
            f[i][j] = f[j][i] = min(f[i][j], f[i][k] + f[k][j]);
}
int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i ++) cin >> a[i];
    for (int i = 0; i < n; i ++)
    {
        for (int j = 0; j < n; j ++) f[i][j] = 0x3f3f3f3f;
        f[i][i] = 0;
    }
    for (int i = 0; i < m; i ++)
    {
        int x, b, w;
        cin >> x >> b >> w;
        f[x][b] = f[b][x] = w;
    }
    cin >> q;
    int idx = 0;
    for (int i = 0; i < q; i ++)
    {
        int x, y, z;
        cin >> x >> y >> z;
        while (a[idx] <= z && idx < n)
        {
            update(idx);
            idx ++;
        }
        if (a[x] > z || a[y] > z) cout << -1 << endl;
        else if (f[x][y] == 0x3f3f3f3f) cout << -1 << endl;
        else cout << f[x][y] << endl;
    }
    return 0;
}

url: https://www.luogu.com.cn/problem/P2195

tag:
树的直径,树形DP,dfs,搜索,并查集,图论

思路:
先用树形DP求出每棵树的直径,并用并查集维护联通情况。用数组c来维护树的直径。对于询问1,直接输出直径,对于询问2,如果不在一个集合中,直径可能是原来两棵树的直径和 + 1,和原来两棵树的直径取一个最大值。参考: https://www.luogu.com.cn/article/o2yhg6cs

代码:

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
const int N = 3e5 + 20;
int n, m, q, len;
int d[N], g[N];
int f[N], c[N];
vector<int> e[N];
bool st[N];
int find(int x)
{
    if (f[x] != x) return f[x] = find(f[x]);
    return x;
}
void dfs(int x, int fa)
{
    int m1 = -1, m2 = -1;
    for (int i = 0; i < e[x].size(); i ++)
    {
        int y = e[x][i];
        if (y == fa) continue;
        dfs(y, x);
        int tmp = d[y] + 1;
        d[x] = max(d[x], tmp);
        if (tmp > m1) m2 = m1, m1 = tmp;
        else if (tmp > m2) m2 = tmp;
    }
    g[x] = max(max(0, m1 + m2), max(m1, m2));
    len = max(len, g[x]);
}
void calc(int x)
{
    len = 0;
    dfs(x, 0);
    c[x] = len;
}
int main()
{
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1; i <= n; i ++) f[i] = i;
    for (int i = 1; i <= m; i++)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        f[find(a)] = find(b);
        e[a].push_back(b);
        e[b].push_back(a);
    }
    for (int i = 1; i <= n; i ++)
    {
        if (f[i] != i || st[i]) continue;
        calc(i);
        st[i] = 1;
    }
    while (q --)
    {
        int opt, x;
        scanf("%d%d", &opt, &x);
        if (opt == 1)
        {
            printf("%d\n", c[find(x)]);
            continue;
        }
        int y;
        scanf("%d", &y);
        x = find(x), y = find(y);
        if (x == y) continue;
        int tmp = ((c[x] + 1) >> 1) + ((c[y] + 1) >> 1) + 1;
        tmp = max(tmp, max(c[x], c[y]));
        f[find(x)] = find(y);
        c[find(x)] = tmp;
    }
    return 0;
}

url: https://www.luogu.com.cn/problem/P2009

tag:
图论,最短路

思路:
这道题因为读入的时候,会有不同权值的相同的边,要求是如果有重复的就保留最长的那个,这种情况下用邻接链表不是很好做,所以可以用邻接矩阵来存比较方便。然后就是数据范围比较小,k是小于等于100,刚好floyd算法可以过,所以就用floyd来求最短路。

代码:

#include <iostream>
#include <cstring>
using namespace std;

int main()
{
    int d[110][110];
    memset(d, 0x3f, sizeof d);
    int n, k;

    cin >> n >> k ;
    int c = 0;
    for (int i = 0; i < n; i ++)
    {
        int w;
        cin >> w;
        if (i == n - 1)
        {
            d[i][0] = d[0][i] = w;
        }
        else
        {
            d[i][i + 1] = d[i + 1][i] = w;
        }
    }
    for (int i = 0; i < k; i ++)
    {
        char a, b;
        int w;
        cin >> a >> b >> w;
        if (d[a - 'A'][b - 'A'] == 0x3f3f3f3f) d[a - 'A'][b - 'A'] = d[b - 'A'][a - 'A'] = w;
        else d[a - 'A'][b - 'A'] = d[b - 'A'][a - 'A'] = max(w, d[a - 'A'][b - 'A']);
    }
    for (int q = 0; q < n; q ++)
        for (int i = 0; i < n; i ++)
            for (int j = 0; j < n; j ++)
                d[i][j] = min(d[i][j], d[i][q] + d[q][j]);

    char s, t;
    cin >> s >> t;
    cout << d[s - 'A'][t - 'A'];
    return 0;

}