洛谷试炼日记（图论）（解题报告）

二叉树

P1087 [NOIP2004 普及组] FBI 树

题目链接
直接暴搜咯
AC代码：

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

using namespace std;

char dfs(string s){
    if(s.size() == 1){
        if(s[0] == '0'){
            cout << 'B';
            return 'B';
        }
        else {
            cout << 'I';
            return 'I';
        }
    }
    char a = dfs(s.substr(0,s.size() / 2));
    char b = dfs(s.substr(s.size() / 2));
    if(a == b) {
        cout << a ;
        return a;
    }
    else {
        cout << 'F';
        return 'F';
    }
}
int main(){
    int n;cin >> n;
    string s;cin >> s;
    dfs(s);
    return 0;
}

P1030 [NOIP2001 普及组] 求先序排列

题目链接
挺简单的看看代码就行
AC代码：

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

using namespace std;
void solve(string a,string b){
    if(a.size() > 0){
        char rt = b[b.size() - 1];
        cout << rt;
        int k = a.find(rt);
        solve(a.substr(0,k),b.substr(0,k));
        solve(a.substr(k + 1),b.substr(k,a.size() - k - 1));
    }
}
int main(){
    string a,b;
    cin >> a >> b;
    solve(a,b);
    return 0;
}

P1305 新二叉树

题目链接
今天的题目都比较水…所以只好上精简代码压压惊
AC代码：

#include<iostream>
#include<cstring>

using namespace std;
int n;string s;

int main(){
    cin >> n >> s;
    for(int i = 2;i <= n;i ++){
        string ss;
        cin >> ss;
        int x = s.find(ss[0]);
        s.erase(x,1);
        s.insert(x,ss);
    }
    for(int i = 0;i < s.size();i ++)
        if(s[i] != '*') cout << s[i];
    return 0;
}

P1229 遍历问题

题目链接
这道题还算比较有意思的
我们发现 如果一个节点只有一个子节点 那么他子节点那一层就可以有两种中序遍历方式 一种在左一种在右
那么我们只需要统计一下只拥有一个子节点的节点个数
然后答案就是 1 <<（节点个数）
那么怎么统计节点个数呢
我们发现只要在前序和后序遍历中出现两个相同的相邻字母并且字母顺序是颠倒的 那么节点个数就++
AC代码：

#include<iostream>

using namespace std;
string a,b;
int main(){
    cin >> a >> b;
    int ans = 0;
    for(int i = 0;i < a.size();i ++){
        for(int j = 0;j < b.size();j ++){
            if((i + 1) < a.size() && (j - 1) >= 0 && a[i] == b[j] && a[i + 1] == b[j - 1]) ans ++;
        }
    }
    cout << (1 << ans) << endl;
    return 0;
}

P5018 [NOIP2018 普及组] 对称二叉树

题目链接
我们先遍历一遍整颗树 预处理出每个节点的大小
然后再枚举每一个节点 判断一下它是否符合对称二叉树的条件
就是具有两个相同大小的子节点 lson rson
并且两个子节点的子节点 lson[lson] rson[lson] lson[rson] rson[lson]要满足 lson[lson] == rson[rson] ,rson[lson] == lson[rson]
递归下去判断
AC代码：

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

using namespace std;
const int N = 1e6 + 10;
int n,son[N][2];
int val[N],siz[N];

void dfs(int u){
    siz[u] = 1;
    if(son[u][0] != -1){
        dfs(son[u][0]);
        siz[u] += siz[son[u][0]];
    }
    if(son[u][1] != -1){
        dfs(son[u][1]);
        siz[u] += siz[son[u][1]];
    }
}

bool check(int u,int v){
    if(u == -1 && v == -1) return true;
    if(u != -1 && v != -1 && val[u] == val[v] && check(son[u][0],son[v][1]) && check(son[u][1],son[v][0]))
        return true;
    return false;
}

int main(){
    scanf("%d",&n);
    for(int i = 1;i <= n;i ++){
        scanf("%d",&val[i]);
    }
    for(int i = 1;i <= n;i ++){
        scanf("%d%d",&son[i][0],&son[i][1]);
    }
    dfs(1);
    int ans = 0;
    for(int i = 1;i <= n;i ++){
        if(check(son[i][0],son[i][1]))
            ans = max(ans,siz[i]);
    }
    printf("%d",ans);
    return 0;
}

树的直径

P2195 HXY造公园

题目链接
并查集+树的直径
首先我们用并查集维护集合，然后预处理出所有集合里的树的直径
那么对于x和y 如果x和y属于不同集合 那么要使合并完的直径最小，显然要选两个集合直径的中点，把他们连起来 那么合并后的集合的直径为 max((dis[fx] + 1) / 2 + (dis[fy] + 1) / 2 + 1 , dis[fx],dis[fy])
AC代码：

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

using namespace std;
const int N = 3e5 + 10;
int fa[N];
int getf(int x){return fa[x] == x ? x : fa[x] = getf(fa[x]);}
int n,m,q;
struct edge{
    int next,to,w;
}e[N];
int head[N],cnt;
void add(int u,int v,int w){
    e[++ cnt].next = head[u];
    e[cnt].to = v;
    e[cnt].w = w;
    head[u] = cnt;
}

int d[N];
int c;
bool vis[N];
int maxx;
void dfs(int u,int val){
    if(maxx < val) maxx = val,c = u;
    for(int i = head[u];i;i = e[i].next){
        int v = e[i].to;
        if(vis[v]) continue;
        vis[v] = true;
        dfs(v,val + 1);
    }
    vis[u] = false;
}
void dfs2(int u,int val){
    if(maxx < val) maxx = val;
    for(int i = head[u];i;i = e[i].next){
        int v = e[i].to;
        if(vis[v]) continue;
        vis[v] = true;
        dfs(v,val + 1);
    }
    vis[u] = false;
}



int main(){
    scanf("%d%d%d",&n,&m,&q);
    for(int i = 1;i <= n;i ++) fa[i] = i;
    for(int i = 0;i < m;i ++){
        int u,v;
        scanf("%d%d",&u,&v);
        add(u,v,1);
        add(v,u,1);
        int fu = getf(u);
        int fv = getf(v);
        if(fu != fv) fa[fu] = fv;
    }
    for(int i = 1;i <= n;i ++){
        int x = getf(i);
        if(d[x]) continue;
        maxx = -1;
        vis[x] = true;
        dfs(x,0);
        maxx = -1;
        vis[c] = true;
        dfs2(c,0);
        d[x] = maxx;
    }
    for(int i = 0;i < q;i ++){
        int op;int x,y;
        scanf("%d",&op);
        if(op == 1){
            scanf("%d",&x);
            printf("%d\n",d[getf(x)]);
        }
        else {
            scanf("%d%d",&x,&y);
            int fx = getf(x);
            int fy = getf(y);
            if(fx == fy) continue;
            fa[fx] = fy;
            int ans = max(d[fx],d[fy]);
            d[fy] = max(ans,(d[fx] + 1) / 2 + (d[fy] + 1) / 2 + 1);
        }
    }
    return 0;
}

P3629 [APIO2010]巡逻

题目链接
直呼好题啊！！！
首先我们要知道，如果不新建道路警车要走过的距离就是2 * (n - 1)（也就是每条边走两遍）那么我们建边是为了节省路程，那我们可以去算出节省出来的这些路程，再用原来的减掉它得到答案
然后我们要知道，新建一条道路也就是新建一条边的时候，一定会出现一个环，这个环里面的边就只需要走一次啦（想想为啥）
所以当k == 1的时候 找到原图的直径把直径首尾相接就是最优解啦（想想为啥）
最后我们要知道，当已经存在一条新建边时（也就是k == 2时），再新建一条边的时候，会有以下两种情况，
第一种就是新建边形成的环 和原来的环没有重叠的边
另一种就是有重叠啦 那么这些重叠的边呢 由于这条新建边必须走过一次所以这些重叠的边必须被走过两次（想想为啥）
所以我们要怎么将两种情况合为一体呢 我们第一条边肯定还是把直径的首尾相接 在加第二条边的时候，考虑重叠的情况，相当于原来只需走一次的边也要走两次 也就是原来省下来的距离现在要添回去
（这里有点难想）所以我们把那些重叠的边的权值处理为-1，再跑一次求直径就行（有负权边求直径记得用树形dp求）
AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>

using namespace std;
const int N = 1e5 + 10;
int n,k;
struct edge{
    int next,to,w;
}e[N << 1];
int head[N],cnt;
map<int,bool> ma;
int st,id,maxx;
int d,ed;

void dfs(int u,int fa,int val){
    if(val >= maxx){
        maxx = val;
        id = u;
    }
    for(int i = head[u];i;i = e[i].next){
        int v = e[i].to;
        if(v != fa){
            dfs(v,u,val + e[i].w);
        }
    }
}

void add(int u,int v){
    e[++ cnt].next = head[u];
    e[cnt].to = v;
    e[cnt].w = 1;
    head[u] = cnt;
}
bool fl;int fr[N];
void dfs2(int u,int fa,int det){
    if(fl) return;
    for(int i = head[u];i;i = e[i].next){
        if(fl) return;
        int v = e[i].to;
        if(v == fa) continue;
        if(v == det){
            fr[u] = v;
            fl = true;
            return;
        }
        fr[u] = v;
        dfs2(v,u,det);
        if(fl) return;
    }
}

int d1,dis[N];
void dp(int u,int fa){
    for(int i = head[u];i;i = e[i].next){
        int v = e[i].to;
        if(v == fa) continue;
        dp(v,u);
        d1 = max(d1,dis[u] + dis[v] + e[i].w);
        dis[u] = max(dis[u],dis[v] + e[i].w);
    }
}


int main(){
    scanf("%d%d",&n,&k);
    for(int i = 2;i <= n;i ++){
        int u,v;
        scanf("%d%d",&u,&v);
        add(u,v);
        add(v,u);
    }
    dfs(1,0,0);
    maxx = 0;st = id;
    dfs(st,0,0);
    d = maxx,ed = id;

    if(k == 1){
        printf("%d",(2 * (n - 1) - d + 1));
    }
    else{
        dfs2(st,0,ed);
        ma[ed] = 1;ma[st] = 1;
        for(int i = st;i != ed;i = fr[i]) ma[i] = 1;
        for(int i = 1;i <= n;i ++){
            if(ma[i] == 1){
                for(int j = head[i];j;j = e[j].next){
                    if(ma[e[j].to] == 1) e[j].w = -1;
                }
            }
        }

        dp(1,0);
        printf("%d",2 * n - d - d1);
    }
    return 0;
}