Codeforces 1104 E（DFS生成树）

传送门

题意：

给你一个有$n$个结点，$m$条边的无向连通图，以及一个数字$k$。现在问你，能否构成如下的两种情况：

1. 找到$1$条长度大于nk\frac{n}{k}kn​路径，并把这条路径输出
2. 找到$k$个环，要求每个环的长度至少要为$3$，且环的长度不能被$3$整除。并把这$k$个环的路径都输出出来

题目分析

在这道题中，我们需要运用到DFS生成树的一些性质。

首先，对于DFS生成树，简单来讲就是在DFS遍历图过程中将当前遍历的结点与其相邻的结点连边而形成的一个树形的结构。值得注意的是，为了保证它是一个树形的结构，我们规定，倘若该结点是第一次被访问，这条边为树边，否则则称为回退边。这样所有的树边就能够形成一个树形的结构。

对于这个问题，首先，我们在遍历DFS生成树的过程中，倘若发现当前的深度大于nk\frac{n}{k}kn​，则证明存在一条满足条件$1$的路径，因此我们只需要把它输出即可。

其次，对于条件$2$，我们需要知道，如果一棵DFS生成树的最大深度小于nk\frac{n}{k}kn​，则证明一定至少有$k$个叶子结点。

证明： 因为这是一棵生成树，因此对于每个叶子结点，必定都存在一条从根到该结点的路径。我们设对于第$i$个结点而言，路径的长度为xix_ixi​。因为每个叶子结点到根的距离至少为$1$，因此必定有：∑i=1cxi≥n\sum_{i=1}^{c}x_i \ge ni=1∑c​xi​≥n 故我们不难分析出有：max⁡i=1cxi≥nc\max_{i=1}^{c} x_i \ge \frac{n}{c}i=1maxc​xi​≥cn​
因此，树的深度至少要为nc\frac{n}{c}cn​，故如果某棵树的深度小于nc\frac{n}{c}cn​，则证明这棵树至少要有$c$个叶子结点。

因为题目规定，每个结点的度至少为$3$，因此必然存在，对于每一个叶子结点$v$，它至少存在$2$条回退边，$1$条树边，且它的这两条回退边必定是该节点的祖先。

证明：倘若结点$v$的其中一条回退边不是它的祖先，如果我们要满足度至少为3的条件，则必定会有一个新的结点$u$，使得$v$和$u$之间有一条连边。而此时该结点$v$就不满足它是叶子结点的定义，故可以证明，必定存在至少两个回退边。

因此，我们假设该结点$v$的祖先分别为$x$和$y$，则$x$到$v$的路径再加上回退边则会构成一个环，此时的环的长度为$dis(x,v)+1$。
同理，$y$到$x$的路径加上回退边、$x$到$y$的路径加上两条回退边也将构成一个环。程度分别为$dis(y,v)+1$，$dis(x,y)+2$。

而上述三个数，必定有一个数不能够被$3$整除。

粗略证明：假设$dis(x,v)+1$和$dis(y,v)+1$同时被$3$整除，则有$$dis(x,y)=dis(v,y)-dis(v,x)=(dis(v,y)+1)-(dis(v,x)+1)$$也能够被$3$整除，则$dis(x,y)+2$必定不能被$3$整除，证毕。

因此，通过上述的分析，我们可以知道，对于一张题目所给的图，要么我们可以找到一个长度为nk\frac{n}{k}kn​的路径，要么我们可以通过$k$个叶子节点形成$k$个环。

因此我们只需要用分别模拟上述的几个过程即可。

#include <bits/stdc++.h>
#define maxn 300005
using namespace std;
struct Node{
    int to,next;
}q[maxn<<1];
int head[maxn];
int cnt=0;
void add_edge(int from,int to){
    q[cnt].to=to;
    q[cnt].next=head[from];
    head[from]=cnt++;
}
vector<int>E[maxn];
int dep[maxn];
int Par[maxn];
bool vis[maxn];
void init(){
    memset(head,-1,sizeof(head));
    memset(Par,-1,sizeof(Par));
    cnt=0;
}

int n,m,k;
vector<int> Circle;
void PATH(int x){
    puts("PATH");
    int cnt=0;
    vector<int>vec;
    int j=x;
    for(;Par[j]!=-1;j=Par[j]){
        vec.push_back(j);
    }
    vec.push_back(j);
    printf("%d\n",vec.size());
    for(auto it:vec){
        printf("%d ",it);
    }
    puts("");
    exit(0);
}
void dfs(int x,int fa,int dpt){//dfs的过程
    int cntt=0;
    vis[x]=1;
    Par[x]=fa;//用Par数组存祖先
    dep[x]=dpt;
    if(1ll*dpt*k>=n)  PATH(x);//如果当前发现有过一个深度大于n/k的边，则直接输出PATH
    for(int i=0;i<E[x].size();i++){
        int to=E[x][i];
        if(vis[to]) continue;
        dfs(to,x,dpt+1);
        cntt++;
    }
    if(cntt==0) Circle.push_back(x);//存叶子
}
void Find_Circle(){//寻找环的情况
    puts("CYCLES");
    for(int i=0;i<k;i++){
        int v=Circle[i];
        int To1=E[v][0];
        int To2=E[v][1];
        int To3=E[v][2];
        int x,y;
        if(To1==Par[v]) x=To2,y=To3;
        else if(To2==Par[v]) x=To1,y=To3;
        else if(To3==Par[v]) x=To1,y=To2;
        if((dep[v]-dep[x]+1)%3!=0){
            printf("%d\n",dep[v]-dep[x]+1);
            int j=v;
            for(;j!=x;j=Par[j]){
                printf("%d ",j);
            }
            printf("%d\n",x);
        }
        else if((dep[v]-dep[y]+1)%3!=0){
            printf("%d\n",dep[v]-dep[y]+1);
            int j=v;
            for(;j!=y;j=Par[j]){
                printf("%d ",j);
            }
            printf("%d\n",y);
        }
        else{
            if(dep[y]>dep[x]) swap(x,y);
            if((dep[x]-dep[y]+2)%3!=0){
                printf("%d\n",dep[x]-dep[y]+2);
                int j=x;
                for(;j!=y;j=Par[j]){
                    printf("%d ",j);
                }
                printf("%d %d\n",y,v);
            }
        }
    }
}
int main()
{
    scanf("%d%d%d",&n,&m,&k);
    for(int i=0;i<m;i++){
        int to,from;
        scanf("%d%d",&from,&to);
        E[from].push_back(to);
        E[to].push_back(from);
    }
    dfs(1,-1,1);
    Find_Circle();
    return 0;
}

转载于:https://www.cnblogs.com/Chen-Jr/p/11007165.html