zoukankan      html  css  js  c++  java
  • [BZOJ1023][SHOI2008]cactus仙人掌图

    1023: [SHOI2008]cactus仙人掌图

    Time Limit: 1 Sec  Memory Limit: 162 MB Submit: 2806  Solved: 1170 [Submit][Status][Discuss]

    Description

      如果某个无向连通图的任意一条边至多只出现在一条简单回路(simple cycle)里,我们就称这张图为仙人掌 图(cactus)。所谓简单回路就是指在图上不重复经过任何一个顶点的回路。

     

      举例来说,上面的第一个例子是一张仙人图,而第二个不是——注意到它有三条简单回路:(4,3,2,1,6 ,5,4)、(7,8,9,10,2,3,7)以及(4,3,7,8,9,10,2,1,6,5,4),而(2,3)同时出现在前两 个的简单回路里。另外,第三张图也不是仙人图,因为它并不是连通图。显然,仙人图上的每条边,或者是这张仙 人图的桥(bridge),或者在且仅在一个简单回路里,两者必居其一。定义在图上两点之间的距离为这两点之间最 短路径的距离。定义一个图的直径为这张图相距最远的两个点的距离。现在我们假定仙人图的每条边的权值都是1 ,你的任务是求出给定的仙人图的直径。

    Input

      输入的第一行包括两个整数n和m(1≤n≤50000以及0≤m≤10000)。其中n代表顶点个数,我们约定图中的顶 点将从1到n编号。接下来一共有m行。代表m条路径。每行的开始有一个整数k(2≤k≤1000),代表在这条路径上 的顶点个数。接下来是k个1到n之间的整数,分别对应了一个顶点,相邻的顶点表示存在一条连接这两个顶点的边 。一条路径上可能通过一个顶点好几次,比如对于第一个样例,第一条路径从3经过8,又从8返回到了3,但是我们 保证所有的边都会出现在某条路径上,而且不会重复出现在两条路径上,或者在一条路径上出现两次。

    Output

      只需输出一个数,这个数表示仙人图的直径长度。

    Sample Input

    15 3
    9 1 2 3 4 5 6 7 8 3
    7 2 9 10 11 12 13 10
    5 2 14 9 15 10 8
    10 1
    10 1 2 3 4 5 6 7 8 9 10

    Sample Output

    8
    9

    HINT

    对第一个样例的说明:如图,6号点和12号点的最短路径长度为8,所以这张图的直径为8。

     

    【注意】使用Pascal语言的选手请注意:你的程序在处理大数据的时候可能会出现栈溢出。
    如果需要调整栈空间的大小,可以在程序的开头填加一句:{$M 5000000},其中5000000即
    指代栈空间的大小,请根据自己的程序选择适当的数值。
     
    不具体讲了,为了搞出仙人掌的正确食用姿势今晚饭都没吃好
     
    类似于树的直径dp,但在处理环的时候要破环为链,然后发现要求的可以用单调队列优化,不过里面有个min值,可以通过倍长来消去,然后一边Tarjan一边做就行了
    #include <cstdio>
    #include <algorithm>
    using namespace std;
    char buf[10000000], *ptr = buf - 1;
    inline int readint(){
        int n = 0;
        char ch = *++ptr;
        while(ch < '0' || ch > '9') ch = *++ptr;
        while(ch <= '9' && ch >= '0'){
            n = (n << 1) + (n << 3) + ch - '0';
            ch = *++ptr;
        }
        return n;
    }
    const int maxn = 100000 + 10, maxm = 400000 + 10;
    struct Edge{
        int to, next;
        Edge(){}
        Edge(int _t, int _n): to(_t), next(_n){}
    }e[maxm];
    int fir[maxn] = {0}, Fir[maxn] = {0}, cnt = 1;
    inline void ins(int u, int v){
        e[++cnt] = Edge(v, fir[u]); fir[u] = cnt;
        e[++cnt] = Edge(u, fir[v]); fir[v] = cnt;
    }
    inline void link(int u, int v){
        e[++cnt] = Edge(v, Fir[u]); Fir[u] = cnt;
    }
    int n, N;
    int dfn[maxn], low[maxn], Index = 0;
    int sta[maxn], top = 0;
    void tarjan(int u, int f){
        dfn[u] = low[u] = ++Index;
        sta[++top] = u;
        for(int v, i = fir[u]; i; i = e[i].next){
            v = e[i].to;
            if(!dfn[v]){
                tarjan(v, i ^ 1);
                low[u] = min(low[u], low[v]);
                if(low[v] > dfn[u]){
                    link(u, v);
                    top--;
                }
                else if(low[v] == dfn[u]){
                    link(u, ++N);
                    do link(N, sta[top]);
                    while(sta[top--] != v); 
                }
            }
            else if(i ^ f) low[u] = min(low[u], dfn[v]);
        }
    }
    int ans, dp[maxn], tmp[maxn];
    int q[maxn], head, tail;
    void dfs(int u){
        for(int i = fir[u]; i; i = e[i].next) dfs(e[i].to);
        if(u > n){
            int c = 1;
            for(int i = fir[u]; i; i = e[i].next) tmp[c++] = e[i].to;
            for(int i = 0; i < c; i++) tmp[i + c] = tmp[i];
            head = 1; tail = 0;
            for(int i = 1; i <= c >> 1; i++){
                while(head <= tail && dp[tmp[q[tail]]] - q[tail] < dp[tmp[i]] - i) tail--;
                q[++tail] = i;
            }
            for(int i = (c >> 1) + 1; i <= (c >> 1) + c; i++){
                if(i - q[head] << 1 > c) head++;
                ans = max(ans, dp[tmp[i]] + dp[tmp[q[head]]] + i - q[head]);
                while(head <= tail && dp[tmp[q[tail]]] - q[tail] < dp[tmp[i]] - i) tail--;
                q[++tail] = i;
            }
            for(int i = 1; i <= c >> 1; i++) dp[u] = max(dp[u], dp[tmp[i]] + i - 1);
            for(int i = (c >> 1) + 1; i < c; i++) dp[u] = max(dp[u], dp[tmp[i]] + c - 1 - i);
        }
        else{
            int t = 0;
            for(int i = fir[u]; i; i = e[i].next){
                t = max(t, dp[e[i].to] + 1);
                if(t > dp[u]) swap(t, dp[u]);
            }
            ans = max(ans, dp[u] + t);
        }
    }
    int main(){
        fread(buf, sizeof(char), sizeof(buf), stdin);
        N = n = readint();
        int m = readint();
        for(int k, u, v, i = 1; i <= m; i++){
            k = readint();
            u = readint();
            for(int i = 1; i < k; i++){
                v = readint(); 
                ins(u, v);
                u = v;
            }
        }
        tarjan(1, 0);
        for(int i = 1; i <= N; i++)
            fir[i] = Fir[i];
        dfs(1);
        printf("%d
    ", ans);
        return 0;
    }
  • 相关阅读:
    互联网广告综述之点击率特征工程
    强大的矩阵奇异值分解(SVD)
    xgboost原理
    《转》八大算法详细讲解
    sklearn中的回归器性能评估方法
    sklearn中的损失函数
    sklearn参数优化方法
    sklearn中的数据集的划分
    sklearn数据预处理
    九宫格布局
  • 原文地址:https://www.cnblogs.com/ruoruoruo/p/7445329.html
Copyright © 2011-2022 走看看