2014多校5---1002 HDU4912 ( Paths on the tree ) LCA+贪心+bfs/dfs

最新推荐文章于 2020-09-14 21:36:15 发布
最新推荐文章于 2020-09-14 21:36:15 发布
阅读量615 收藏
点赞数
分类专栏： Contest 文章标签： ACM LCA algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NothingButNo/article/details/38534859
版权

题意：

一棵树，给出m条路径，然后问最多选择多少条路径，使得每两条路径之间没有 任何公共点，公共边。

解法：

把m条路径求出lca，然后按照lca深度从大到小排序。

从深度大的开始选，贪心，可以这么想：假设选深的可以的话但是选浅的会有路径覆盖，则只能选一个。而后则时候先选择深的和结果一样，而如果选了浅的则可能影响结果。

接下来分两步：

1.检验路径上是不是已经有被标记的点了。这里可以用BFS或者DFS。

2.把路径上经过的点标记。

注意这里是检验路径而不是整个子树，标记也是路径不是子树，我当时把每个LCA都往下把整个子树都标记和检测了，但是后来发现可以存在这种情况：某个子树被标记了，但是他的父亲连同他的兄弟可以被标记没有冲突，如果是标记整个子树就会有问题。

郁闷的地方：

我之前用的是vector来存的，无论用bfs还是dfs结果居然不一样且都不是正确答案，而且在防止返回访问父节点的时候用mark或者fa[i][0]是不一样的，用mark会出结果，但是用v！=fa[i][0]就会死循环在里面或者爆栈。。。

这里还要注意的一点是：

在求LCA时候处理fa[i][j]的时候要放在dfs或者bfs里面，因为要保证在你所形成的树里面深度深的的fa数组的处理要用到他上面的数组，此时需要保证他们已经是对的，应为生成的树不是唯一的，但必须保证deep数组和fa数组对应。在dfs和bfs过程中就可以明确记录下fa[i][0]了。

注意常数M的取值，注意fa[root][0]的取值，注意每个需要扫M的地方不要超出范围了，因为那里的fa还没处理，都是0.


AC代码：dfs

#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
#include<iostream>
#include<queue>
using namespace std;
const int maxn=100005;
const int M=20;
int n,m;
int fa[maxn][M];
int head[maxn],tol;
struct A
{
    int astor,a,b;
}ans[maxn];
vector<int> G[maxn];
bool mark[maxn];
int deep[maxn];

struct Edge{
    int next,to;
    Edge(int _next=0,int _to=0){
        next=_next;to=_to;
    }
}edge[10*maxn];
void addedge(int u,int v){
    edge[tol]=Edge(head[u],v);
    head[u]=tol++;
}

bool cmp(A x, A y)
{
    return deep[x.astor]>deep[y.astor];
}
void init()
{
    int i;
    memset(mark,false,sizeof(mark));
    memset(head,-1,sizeof(head));
    for(i=0;i<n;i++)
        G[i].clear();
    memset(deep,0,sizeof(deep));
    memset(fa,0,sizeof(fa));
}
void dfs(int u)
{
    mark[u]=true;
    int i,j;
    int v;
    for(i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(mark[v])
            continue;
        else
        {
            fa[v][0]=u;
            for(j=1;j<M;j++) fa[v][j]=fa[fa[v][j-1]][j-1];
            deep[v]=deep[u]+1;
            dfs(v);
        }
    }
}

/*void bfs(int u)
{
    queue<int> q;

    deep[u]=0;
    fa[u][0]=u;
    q.push(u);
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        int i,v,j;
        for(j=1;j<M;j++)
        {
            fa[t][j]=fa[fa[t][j-1]][j-1];
            //printf("fa [ %d ][ %d ]= %d\n",t,j,fa[t][j]);

        }//
         //cout<<"SSS"<<endl;
        for(i=0;i<G[t].size();i++)
        {
            v=G[t][i];

            if(v==fa[t][0])
            {
                cout<<t<<"  "<<v<<endl;
                continue;
            }

            mark[v]=true;
            deep[v]=deep[t]+1;
            fa[v][0]=t;
            q.push(v);
        }
    }
}*/

int LCA(int x,int y)
{
    if(deep[x]<deep[y]) swap(x,y);
    int d=deep[x]-deep[y];
    //cout<<"d="<<d<<"  "<<endl;
    int i;
    for(i=M-1;i>=0;i--)
    {
        if( (1<<i)&d )
        {
            x=fa[x][i];//cout<<"SS"<<endl;
            //cout<<"i="<<i<<"  "<<endl;
        }
    }
    //cout<<"x="<<x<<" y= "<<y<<endl;
    if(x==y)
    return x;
    for(i=M-1;i>=0;i--)
    {
        //cout<<"fa[x][i]="<<fa[x][i]<<" fa[y][i]= "<<fa[y][i]<<endl;
        if(fa[x][i]!=fa[y][i])
        {
            //cout<<"2x="<<x<<" y= "<<y<<endl;
            x=fa[x][i];
            y=fa[y][i];
        }
    }
    x=fa[x][0];//cout<<"fax="<<fa[x][0]<<endl;
    return x;
}
void makemark(int u,int lca)
{
    int i;
    mark[lca]=true;
    for(i=u;i!=lca;i=fa[i][0])
    {
        mark[i]=true;
    }
}

bool judge(int u,int lca)
{
    bool f=true;
    if(mark[ans[u].a] || mark[ans[u].b] || mark[ans[u].astor])
        return false;
    else
    {
        int i;
        for(i=ans[u].a;i!=lca;i=fa[i][0])
        {
            if(mark[i])
            {
                f=false;
                return false;
            }
        }
        for(i=ans[u].b;i!=lca;i=fa[i][0])
        {
            if(mark[i])
            {
                f=false;
                return false;
            }
        }
    }
    if(f)
        return true;
    else
        return false;
}


int main()
{
    
    //freopen("in","r",stdin);
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        int i;
        int a,b;
        init();
        for(i=0;i<n-1;i++)
        {
            scanf("%d %d",&a,&b);
            //G[a].push_back(b);
            //G[b].push_back(a);
            addedge(a,b);
            addedge(b,a);
            //fa[b][0]=a;
        }
        //printf("root = %d\n",root);
        //bfs(1);
        deep[1]=0;
        fa[1][0]=1;
        dfs(1);


        //for(i=1;i<=n;i++)
        //printf("deep[%d] = %d\n",i,deep[i]);
        for(i=0;i<m;i++)
        {
            scanf("%d %d",&a,&b);
            ans[i].astor=LCA(a,b);
            ans[i].a=a;
            ans[i].b=b;
        }
        sort(ans,ans+m,cmp);
       // for(i=0;i<m;i++)
        //printf("%d ",ans[i]);
        //printf("\n");
        memset(mark,false,sizeof(mark));
        int res=0;
        for(i=0;i<m;i++)
        {
            int l=ans[i].astor;
            if(judge(i,l))
            {
                makemark(ans[i].a,l);
                makemark(ans[i].b,l);
                res++;
            }
        }
        printf("%d\n",res);
    }
return 0;
}

bfs： 

#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
#include<iostream>
#include<queue>
using namespace std;
const int maxn=100005;
const int M=20;
int n,m;
int fa[maxn][M];
int head[maxn],tol;
struct A
{
    int astor,a,b;
}ans[maxn];
vector<int> G[maxn];
bool mark[maxn];
int deep[maxn];

struct Edge{
    int next,to;
    Edge(int _next=0,int _to=0){
        next=_next;to=_to;
    }
}edge[10*maxn];
void addedge(int u,int v){
    edge[tol]=Edge(head[u],v);
    head[u]=tol++;
}

bool cmp(A x, A y)
{
    return deep[x.astor]>deep[y.astor];
}
void init()
{
    int i;
    memset(mark,false,sizeof(mark));
    memset(head,-1,sizeof(head));
    for(i=0;i<n;i++)
        G[i].clear();
    memset(deep,0,sizeof(deep));
    memset(fa,0,sizeof(fa));
}
/*void dfs(int u)
{
    mark[u]=true;
    int i,j;
    int v;
    for(i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(mark[v])
            continue;
        else
        {
            fa[v][0]=u;
            for(j=1;j<M;j++) fa[v][j]=fa[fa[v][j-1]][j-1];
            deep[v]=deep[u]+1;
            dfs(v);
        }
    }
}*/

void bfs(int u)
{
    queue<int> q;

    deep[u]=0;
    fa[u][0]=u;
    q.push(u);
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        int i,v,j;
        for(j=1;j<M;j++)
        {
            fa[t][j]=fa[fa[t][j-1]][j-1];
            //printf("fa [ %d ][ %d ]= %d\n",t,j,fa[t][j]);

        }//
         //cout<<"SSS"<<endl;
        for(i=head[t];i!=-1;i=edge[i].next)
        {
            v=edge[i].to;
            if(v==fa[t][0])
            {

                continue;
            }

            mark[v]=true;
            deep[v]=deep[t]+1;
            fa[v][0]=t;
            q.push(v);
        }
    }
}

int LCA(int x,int y)
{
    if(deep[x]<deep[y]) swap(x,y);
    int d=deep[x]-deep[y];
    //cout<<"d="<<d<<"  "<<endl;
    int i;
    for(i=M-1;i>=0;i--)
    {
        if( (1<<i)&d )
        {
            x=fa[x][i];//cout<<"SS"<<endl;
            //cout<<"i="<<i<<"  "<<endl;
        }
    }
    //cout<<"x="<<x<<" y= "<<y<<endl;
    if(x==y)
    return x;
    for(i=M-1;i>=0;i--)
    {
        //cout<<"fa[x][i]="<<fa[x][i]<<" fa[y][i]= "<<fa[y][i]<<endl;
        if(fa[x][i]!=fa[y][i])
        {
            //cout<<"2x="<<x<<" y= "<<y<<endl;
            x=fa[x][i];
            y=fa[y][i];
        }
    }
    x=fa[x][0];//cout<<"fax="<<fa[x][0]<<endl;
    return x;
}
void makemark(int u,int lca)
{
    int i;
    mark[lca]=true;
    for(i=u;i!=lca;i=fa[i][0])
    {
        mark[i]=true;
    }
}

bool judge(int u,int lca)
{
    bool f=true;
    if(mark[ans[u].a] || mark[ans[u].b] || mark[ans[u].astor])
        return false;
    else
    {
        int i;
        for(i=ans[u].a;i!=lca;i=fa[i][0])
        {
            if(mark[i])
            {
                f=false;
                return false;
            }
        }
        for(i=ans[u].b;i!=lca;i=fa[i][0])
        {
            if(mark[i])
            {
                f=false;
                return false;
            }
        }
    }
    if(f)
        return true;
    else
        return false;
}


int main()
{
    
    //freopen("in","r",stdin);
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        int i;
        int a,b;
        init();
        for(i=0;i<n-1;i++)
        {
            scanf("%d %d",&a,&b);
            //G[a].push_back(b);
            //G[b].push_back(a);
            addedge(a,b);
            addedge(b,a);
            //fa[b][0]=a;
        }
        //printf("root = %d\n",root);
        //bfs(1);
        bfs(1);


        //for(i=1;i<=n;i++)
        //printf("deep[%d] = %d\n",i,deep[i]);
        for(i=0;i<m;i++)
        {
            scanf("%d %d",&a,&b);
            ans[i].astor=LCA(a,b);
            ans[i].a=a;
            ans[i].b=b;
        }
        sort(ans,ans+m,cmp);
       // for(i=0;i<m;i++)
        //printf("%d ",ans[i]);
        //printf("\n");
        memset(mark,false,sizeof(mark));
        int res=0;
        for(i=0;i<m;i++)
        {
            int l=ans[i].astor;
            if(judge(i,l))
            {
                makemark(ans[i].a,l);
                makemark(ans[i].b,l);
                res++;
            }
        }
        printf("%d\n",res);
    }
return 0;
}


NothingButNo
关注
专栏目录
HDU 4912
Skywalker
09-28 621
给一棵n个结点的树，m条路径的起点和终点， 问至多可以选择多少条路径使其两两间没有公共点。
HDU题目分类大全【大集合】
欢迎来到扣子不会飞的博客！
03-18 3620
基础题： 1000、1001、1004、1005、1008、1012、1013、1014、1017、1019、1021、1028、1029、 1032、1037、1040、1048、1056、1058、1061、1070、1076、1089、1090、1091、1092、1093、 1094、1095、1096、1097、1098、1106、1108、1157、1163、1164、1170、...
Paths(升级版)---3011
Caristra的博客
10-11 616
题意有一棵树，树的节点编号为1,2,…,n。 树上有m条路径，现在要从这些路径中选一些，选出的路径不能有公共点。 每条路径有一个权值，求选出哪些路径，是的权值最大。思路： 如上图，此题实际上就是在可选择的边上多了权值的信息，然而，这就完全不是一道题目了…dp[i]表示以i为根的子树的最大值； sum[i]表示i的子节点的子树的dp之和； 也就是：val + ∑sum[i] - ∑dp[i]
hdu 4912 Paths on the tree LCA + 贪心
vickey
08-06 642
题意：给一棵树，有m 条paths,
hdu 4912 Paths on the tree (LCA+贪心)
虽然冲动永远比坚持容易~
08-11 609
题意： 有一颗无根树，
HDU 4912 Paths on the tree LCA 排序贪心
九野的博客
08-05 1757
lca。。。 排个序然后暴力保平安 _(:зゝ∠)_  #pragma comment(linker, "/STACK:102400000,102400000") #include"cstdio" #include"iostream" #include"set" #include"queue" #include"string.h" using namespace std; #define
HDU_4912_Paths on the tree LCA(最近公共祖先)+贪心
可视化和机器学习
08-08 1477
http://acm.hdu.edu.cn/showproblem.php?pid=4912
hdu4912 LCA(ST)+???+贪心
animalcoder
03-04 215
2014 Multi-University Training Contest 5 B - Paths on the tree题意：一个n个点的无向树给你m个路径u,v：路径就是从u走到v的最短路经过的所有点现在要选尽量多的路径，使得路径不会有交点思路：贪心：lca深度大的先选每次选要判是否能走（路径上的点是否被标记过）选了之后将整条路径向上暴力vis标记，这样T了因为可能有极限数据：前1条路径是u...
HDU 5293 Tree chain problem 树形DP+LCA+树链剖分+线段树
JYZ's Blog
03-18 472
Tree chain problem Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Problem Description Coco has a tree, whose vertices are conveniently labeled by 1,2,…,
HDU 4912 lca贪心
weixin_33937913的博客
05-26 62
Paths on the tree Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) Total Submission(s): 297    Accepted Submission(s): 93 Problem Description bobo has ...
【刷题计划1】【poj分类转载】
loving coding
08-19 1257
----------------2018.4.10更新-----------------------原本这只是暑假刷题计划，后来因为某些原因，自己就不是很努力的刷题，现在情况有变，so，重新继续咯~下个月26号省赛，扣去中间实训的一周时间和几次校赛，大概只有一个月时间。目前计划是，每天基础算法题+cf上3题，专业课也先停了，自己这段时间只想认真写题。昨天晚上又失眠了，虽然我知道保证训练效率的关键是...
OI每周刷题记录——lrllrl
翻过这座山，他们就会听到你的故事
09-16 1769
看这标题就知道我是模仿的hzwer大佬，远程%%% 大佬的OI经历让蒟蒻我深受感触，为了晚一些AFO本蒟蒻也得加油了 从高二上期第一周开始计数，每个星期天更一次，一直更到我AFO 2018.9.2~2018.9.8 线段树： CH4301 线段树 poj2482（同洛谷P1502） 线段树+离散化+扫描线 CH4302 线段树+最大公约数+树状数组+构造 poj2481 线...
解题报告：【kuangbin带你飞】专题九 连通图
繁凡さん的博客
09-14 2970
目录A、POJ 1236 Network of Schools（有向图缩点）B、UVA 315 Network（找割点）C、UVA 796 Critical Links（桥）D、POJ 3694 NetworkE、POJ 3177 Redundant PathsF、HDU 4612 Warm upG、HDU 4635 Strongly connected（最多可加边数使得仍然非强连通）H、HDU 4685 Prince and PrincessI、HDU 4738 Caocao's Bridges A、PO
北大ACM题目分类1（适合树图专题）
briup_acmer的专栏
09-28 982
原帖： 一些图论、网络流入门题总结、汇总 http://hi.baidu.com/zfy0701/blog/item/b8332b5c7b2dd545fbf2c052.html 搜索题目推荐及解题报告 http://hi.baidu.com/zfy0701/blog/item/c6e216ed18a9d24a78f05589.html 字符串题目推荐及解题报告 http://h
基于H5的宿舍管理系统.zip
11-09
基于SSM的毕业设计源码
CSP-J历年复赛真题资源.txt
最新发布
11-09
CSP-J历年复赛真题资源.txt
【激光雷达】激光雷达数据处理（点云数据滤波、误差分析、模型验证、三维表面拟合）【含Matlab源码 9065期】.mp4
11-09
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
macOS_Sequoia_15.1.password(imacos.top).rdr.split.012
11-09
macOS_Sequoia_15.1.password(imacos.top).rdr.split.012
高分springboot毕设+vue的校园社交平台_jdl-Java源码.zip
11-09
本项目是一个基于Spring Boot和Vue的校园社交平台，旨在为高校学生提供一个便捷、高效的社交互动环境。项目源码涵盖了前后端完整开发流程，适合计算机相关专业学生进行毕业设计，同时也为Java学习者提供了实战练习的机会。 在功能方面，该平台支持用户注册与登录、个人信息管理、好友添加与聊天、动态发布与评论、兴趣小组创建与加入等功能。通过这些功能，用户可以在平台上轻松找到志同道合的朋友，分享学习和生活中的点滴，参与各类兴趣小组的活动，丰富校园生活。 技术框架方面，后端采用Spring Boot框架，实现了快速开发和部署，提供了稳定的服务支持。前端则使用Vue框架，实现了友好的用户界面和流畅的用户体验。前后端通过RESTful API进行数据交互，保证了系统的安全性和可扩展性。 开发此项目的目的在于帮助学生更好地掌握Java Web开发技能，理解前后端分离的开发模式，同时为校园社交提供一个便捷的平台。
杭电ACM 1000-2000题解：C/C++源码与解题报告
5. **模运算与随机数生成**：提到的HDU ACM 1014题涉及到在模意义下生成均匀分布的随机数。在计算机模拟和加密等领域，模运算常用于生成伪随机序列，确保结果在特定范围内均匀分布。 6. **问题分析与解题策略**：每...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值