[CEOI1997]参观洞穴 解题报告

最新推荐文章于 2022-08-11 18:38:53 发布
最新推荐文章于 2022-08-11 18:38:53 发布
阅读量1.2k 收藏
点赞数 1
分类专栏： DFS DP 文章标签： DP dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TA201314/article/details/46754249
版权
DP 同时被 2 个专栏收录
43 篇文章 1 订阅
订阅专栏
DFS
22 篇文章 0 订阅
订阅专栏

这道题挺有意思的，难点主要在建模。

“对于每个房间来说，我们都能找到一条通往任意一个其他房间的只经过内通道的路线，但是如果我们规定每个内通道只能走一次的话，这样的路线是惟一的。”
也就是说，在删掉外通道以后，所有节点形成了一棵树。
但是我比较傻逼。。我只想到了内节点形成了一棵树（而且是二叉树，但是我不知道这有什么用），所以我以为就是用k条带权树上路径去不重不漏地覆盖整棵树，于是就写了一个O（n^2）的DP。。（结果不知道为什么在POJ上跑的比我O（N）的标算还快）

“从每个房间出发，恰好有三条通道通往另外三个不同的房间。显然，从每个外房间出发的三条通道分别通往它在圆圈上两个相邻的外房间和某个内房间。”
首先，可以发现，如果忽略1号节点，并以与1号节点相邻的内节点（它是一定存在且唯一的）为根的话，所形成的树的所有叶节点都是外节点，所有外节点也都是叶节点。
而且这还是一棵二叉树。

“所有的房间和通道在同一层且任意两条通道不交叉。”这句话的意思是外房间在环上是依据某种DFS序排列的，而且哈密顿序中环上节点的出现序列必然是沿环的。

由于一号节点比较特殊，所以我们考虑枚举一号节点的进出方式之后，将会剩下一坨二叉树。那么我们考虑每个树的根，实际上如果它要被选择的话，它只能被从左子树最右边的孙子和右子树最左边的孙子之间的路径取到——因为这是一棵二叉树。所以路径的选择竟然是唯一的！

所以我们可以先构出二叉树，然后把所有点按dfs序排序，然后处理的时候按dfs序对没被标记的点依次处理。然后还有各种蛋疼的细节，写了我一上午。
Code（O（N！）DFS）：

#include<cstdio>
#include<cstring>
int tmp[505];
int ptr[505],next[1505],w[1505],succ[1505],etot=1;
void addedge(int u,int v,int wt){
    next[etot]=ptr[u],ptr[u]=etot,succ[etot]=v,w[etot++]=wt;
}
bool p[505];
int ans=0x7fffffff,n,ansp[505];
void dfs(int node,int nown,int noww,int top){
    if(noww>=ans)return;
    p[node]=1,tmp[top]=node;
    for(int i=ptr[node];i;i=next[i])
        if(!p[succ[i]])dfs(succ[i],nown+1,noww+w[i],top+1);
        else if(succ[i]==1&&nown==n-1){
            ans=noww+w[i];
            memcpy(ansp,tmp,sizeof(int)*n);
        }
    p[node]=0;
}
int main(){
    freopen("cave.in","r",stdin);
    freopen("cave.out","w",stdout);
    int m,k;
    scanf("%d%d",&n,&k);
    m=n+(n>>1);
    int i,u,v,wt;
    for(i=m;i--;){
        scanf("%d%d%d",&u,&v,&wt);
        addedge(u,v,wt),addedge(v,u,wt);
    }
    dfs(1,0,0,0);
    putchar('1');
    for(i=1;i<n;++i)printf(" %d",ansp[i]);
}

Code（O（N^2）DP）：

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
using namespace std;
#include<algorithm>
int next[1505],succ[1505],ptr[505],w[1505],etot=1;
inline void addedge(int u,int v,int wt){
    next[etot]=ptr[u],ptr[u]=etot,w[etot]=wt,succ[etot++]=v;
}
inline void in(int &x){
    char c=getchar();
    while(c<'0'||c>'9')c=getchar();
    x=0;
    for(;c>='0'&&c<='9';c=getchar())x=x*10+(c^'0');
}
int depth[505],k;
inline void depdfs(int node,int ftr){
    depth[node]=depth[ftr]+1;
    for(int i=ptr[node];i;i=next[i])
        if(succ[i]!=ftr&&succ[i]>k)
            depdfs(succ[i],node);
}
int road[505][505],cost[505],nnode;
inline bool finddfs(int node,int x,int ftr){
    road[node][++road[node][0]]=x;
    for(int i=ptr[x];i;i=next[i])
        if(succ[i]!=ftr){
            cost[node]+=w[i];
            //cout<<"Get:"<<succ[i]<<"("<<w[i]<<")\n";
            if(succ[i]==nnode)return 1;
            else if(succ[i]>k&&finddfs(node,succ[i],x))return 1;
            cost[node]-=w[i];
            //cout<<"Del:"<<succ[i]<<"(-"<<w[i]<<")\n";
        }
    --road[node][0];
    return 0;
}
bool p[505];//这个点在不在当前所选的路径上。 
bool flag[505];//外边界的点进不进去。 
int f[505],chosen[505];
#include<vector>
vector<int> belong[505];
#define inf 1000000000
inline int dfs(int node,int ftr){
    if(!p[node])return f[node];
    int ans=0;
    for(int i=ptr[node];i;i=next[i])
        if(succ[i]!=ftr&&succ[i]>k)
            ans+=dfs(succ[i],node);
    return ans;
}
inline void dpdfs(int node,int ftr){
    for(int i=ptr[node];i;i=next[i])
        if(succ[i]!=ftr&&succ[i]>k)
            dpdfs(succ[i],node);
    for(int i,j=belong[node].size();j--;){
        for(i=road[belong[node][j]][0];i;--i)p[road[belong[node][j]][i]]=1;
        int tmp=cost[belong[node][j]];
        for(i=ptr[node];i;i=next[i])
            if(succ[i]!=ftr&&succ[i]>k)
                tmp=min(tmp+dfs(succ[i],node),inf);
        if(tmp<f[node]){
            f[node]=tmp;
            chosen[node]=belong[node][j];
            //cout<<node<<":"<<chosen[node]<<"->"<<f[node]<<endl;
        }
        for(i=road[belong[node][j]][0];i;--i)p[road[belong[node][j]][i]]=0;
    }
}
inline void outdfs(int node,int ftr){
    if(!p[node]){
        flag[chosen[node]]=1;
        for(int i=road[chosen[node]][0];i;--i)p[road[chosen[node]][i]]=1;
    }
    for(int i=ptr[node];i;i=next[i])
        if(succ[i]!=ftr&&succ[i]>k)
            outdfs(succ[i],node);
}
int main(){
    freopen("cave.in","r",stdin);
    //freopen("cave_TA.out","w",stdout);
    int n,m;
    in(n),in(k);
    m=3*n>>1;
    int i,j,u,v,wt;
    for(i=m;i--;){
        in(u),in(v),in(wt);
        addedge(u,v,wt),addedge(v,u,wt);
    }
    depdfs(k+1,0);
    int node=1,highest;
    int sum=0,tmp;
    for(i=ptr[1];i;i=next[i])
        if(succ[i]<=k){
            nnode=succ[i];
            cost[node]=-w[i];
            sum+=w[i];
            break;
        }
    do{
        //cout<<"------"<<node<<"----\n";
        for(i=ptr[node];i;i=next[i])
            if(succ[i]>k){
                cost[node]+=w[i];
                finddfs(node,succ[i],0);
                highest=succ[i];
                for(j=road[node][0];j;--j)
                    if(depth[road[node][j]]<depth[highest])
                        highest=road[node][j];
                belong[highest].push_back(node);
                break;
            }
        for(i=ptr[nnode];i;i=next[i]){
            if(succ[i]!=node&&succ[i]<=k){
                node=nnode;
                nnode=succ[i];
                if(node!=1){
                    cost[node]=-w[i];
                    sum+=w[i];
                }
                break;
            }
        }
    }while(node!=1);
    memset(f,60,sizeof(f));
    /*for(i=1;i<=k;++i){
        cout<<i<<":";
        for(j=1;j<=road[i][0];++j)cout<<road[i][j]<<" ";
        cout<<":"<<cost[i]<<endl;
    }
    for(i=k+1;i<=n;++i){
        cout<<i<<":";
        for(j=belong[i].size();j--;)printf("%d ",belong[i][j]);
        puts("");
    }
    cout<<"------------------\n";*/
    dpdfs(k+1,0);
    outdfs(k+1,0);
    //cout<<sum<<"->"<<sum+f[k+1]<<endl;
    for(i=ptr[1];i;i=next[i])
        if(succ[i]<=k){
            nnode=succ[i];
            break;
        }
    putchar('1');
    do{
        if(flag[node])
            for(i=1;i<=road[node][0];++i)
                printf(" %d",road[node][i]);
        for(i=ptr[nnode];i;i=next[i])
            if(succ[i]!=node&&succ[i]<=k){
                node=nnode;
                nnode=succ[i];
                break;
            }
        if(node!=1)printf(" %d",node);
    }while(node!=1);
    //cout<<":"<<sum+f[k+1]<<endl;
}

Code（O（N））：

#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstring>
#include<iostream>
using namespace std;
#include<algorithm>
int n,k;
int ls[505],ldis[505],rs[505],rdis[505],crate[505];
int cnext[505],cdis[505];//圆上下一点。 
int next[1505],succ[1505],w[1505],ptr[505],etot=1;
int sorted[505],stot=1;
inline void addedge(int u,int v,int wt){
    next[etot]=ptr[u],ptr[u]=etot,w[etot]=wt,succ[etot++]=v;
}
inline void build(int node,int ftr){
    if(node>k){
        for(int i=ptr[node];i;i=next[i])
            if(succ[i]!=ftr){
                build(succ[i],node);
                if(ls[node]){
                    rs[node]=succ[i];
                    rdis[node]=w[i];
                }
                else{
                    ls[node]=succ[i];
                    ldis[node]=w[i];
                }
            }
        if(crate[rs[node]]<crate[ls[node]]){
            swap(ls[node],rs[node]);
            swap(ldis[node],rdis[node]);
        }
        crate[node]=crate[ls[node]];
    }
}
inline void dfs(int node){
    sorted[stot++]=node;
    if(node>k)dfs(ls[node]),dfs(rs[node]);
}
bool used[505];
int now,ans=0x7fffffff,road[505],ansroad[505],ansflag;
inline void work(int flag){
    for(int i=1,j;i<n;++i){
        if(!used[sorted[i]])
            if(sorted[i]>k){
                now+=ldis[sorted[i]]+rdis[sorted[i]];
                for(j=ls[sorted[i]];j>k;j=rs[j]){
                    now+=rdis[j];
                    //cout<<j<<" ";
                    used[j]=1;
                }
                //cout<<j<<" ";
                used[j]=1;
                road[j]=sorted[i];
                //cout<<"("<<sorted[i]<<":<-"<<j<<")";
                for(j=rs[sorted[i]];j>k;j=ls[j]){
                    now+=ldis[j];
                    //cout<<j<<" ";
                    used[j]=1;
                }
                //cout<<j<<"\n";
            }
            else{
                //cout<<sorted[i]<<" chooses go out.\n";

                road[sorted[i]]=sorted[i];
                now+=cdis[sorted[i]];
            }
    }
    if(ans>now){
        //cout<<"Get:"<<flag<<endl;
        ans=now,ansflag=flag;
        memcpy(ansroad,road,sizeof(road));
    }
}
inline void rout(int node){
    if(node>k){
        rout(rs[node]);
        printf(" %d",node);
    }
}
int main(){
    freopen("cave.in","r",stdin);
    freopen("cave.out","w",stdout);
    scanf("%d%d",&n,&k);
    int m=(n>>1)+n;
    int u,v,wt;
    while(m--){
        scanf("%d%d%d",&u,&v,&wt);
        addedge(u,v,wt),addedge(v,u,wt);
    }
    int node=1,nnode,ctot=0,i;
    crate[node]=ctot++;
    for(i=ptr[node];i;i=next[i])
        if(succ[i]<=k){
            nnode=succ[i];
            cdis[1]=w[i];
            break;
        }
    cnext[1]=nnode;
    while(nnode!=1)
        for(i=ptr[nnode];i;i=next[i])
            if(succ[i]<=k&&succ[i]!=node){
                cnext[nnode]=succ[i];
                crate[node=nnode]=ctot++;
                cdis[node]=w[i];
                nnode=succ[i];
                break;
            }
    int outnode,outw;
    for(i=ptr[1];i;i=next[i])
        if(succ[i]>k){
            outnode=succ[i];
            outw=w[i];
            build(succ[i],1);
            dfs(succ[i]);
            break;
        }
    //外到1,1到外。
    //puts("-----1-------");
    memset(used,0,sizeof(used));
    now=cdis[sorted[n-1]]+cdis[1];
    used[1]=used[sorted[n-1]]=1;
    work(1);
    //内到1,1到外。
    //puts("------2------");
    memset(used,0,sizeof(used));
    now=cdis[1]+outw;
    used[sorted[n-1]]=used[1]=1;
    for(i=outnode;i>k;i=rs[i]){
        now+=rdis[i];
        used[i]=1;
    }
    work(2);
    //外到1,1到内。 
    //puts("-----3-----");
    memset(used,0,sizeof(used));
    now=cdis[sorted[n-1]]+outw;
    used[1]=used[sorted[n-1]]=1;
    for(i=outnode;i>k;i=ls[i]){
        now+=ldis[i];
        used[i]=1;
    }
    work(3);

    putchar('1');
    if(ansflag==3)
        for(i=outnode;i>k;i=ls[i])
            printf(" %d",i);
    for(node=cnext[1];node!=sorted[n-1];node=cnext[node]){
        printf(" %d",node);
        if(ansroad[node]!=node){
            //cout<<"("<<ansroad[node]<<":"<<ls[ansroad[node]]<<","<<rs[ansroad[node]]<<")";
            rout(ls[ansroad[node]]);
            printf(" %d",ansroad[node]);
            for(i=rs[ansroad[node]];i>k;i=ls[i])printf(" %d",i);
        }
    }
    printf(" %d",node);
    if(ansflag==2)rout(outnode);
    //cout<<":"<<ans<<endl;
}
TA201314
关注
专栏目录
基于贪心算法对整数区间问题(CEOI1997)的深入研究
PerfectPeter的博客
10-28 319
题目 题目描述 请编程完成以下任务： 1.从文件中读取闭区间的个数及它们的描述； 2.找到一个含元素个数最少的集合,使得对于每一个区间,都至少有一个整数属于该集合，输出该集合的元素个数。 输入 首行包括区间的数目n,1≤n≤10000,接下来的n行,每行包括两个整数a,b,被一空格隔开,0≤a≤b≤10000,它们是某一个区间的开始值和结束值。 输出 第一行集合元素的个数,对于每一个区间都至少有一...
【题解】洛谷P4342（poj1179）[IOI1998]Polygon 区间DP
翻过这座山，他们就会听到你的故事
09-26 261
题目链接 题意翻译 题目可能有些许修改，但大意一致 多边形是一个玩家在一个有 nnn 个顶点的多边形上的游戏，如图所示，其中 n＝4n＝4n＝4 。每个顶点用整数标记，每个边用符号 +++（加）或符号 ∗*∗（乘积）标记。 第一步，删除其中一条边。随后每一步： 选择一条边连接的两个顶点 V1V1V1 和 V2V2V2，用边上的运算符计算 V1V1V1 和 V2V2V2 得到的结果来替换这两个顶点。...
CEOI2005解题报告
03-09
个人以及Amber大牛的CEOI2005算法分析对比。
POJ1724-ROADS 测试数据
06-26
POJ1724-ROADS 测试数据。数据来源：CEOI 1998 Round II
BZOJ3642 : [CEOI 2014] Cake
weixin_34310369的博客
07-11 210
rank[i]表示第i美味的是哪块 left[i]表示在k左边美味度为i的是哪块 right[i]表示在k右边美味度为i的是哪块 用3棵线段树分别维护d序列的区间最大值、left序列的区间最大值、right序列的区间最小值   修改： 把第x块改成第y美味 把第y+1到第9美味的全部后移一位 然后把第x块美味度改成最大值+1 然后把第y-1到第1美味的美味度依次改成最大   ...
Shooting Contest 射击比赛 [POJ1719] [CEOI1997] [一题多解]
weixin_30596735的博客
10-19 187
Description（下有中文题意） Welcome to the Annual Byteland Shooting Contest. Each competitor will shoot to a target which is a rectangular grid. The target consists of r*c squares located in r rows and c col...
P6847 [CEOI2019] Magic Tree
Ajwallet
08-13 287
线段树合并
解题：CEOI 2017 Mousetrap
weixin_30363981的博客
12-29 107
题外话： 这是制杖yd的交流题目 题面 首先把捕鼠夹所在的点提出来当根，然后这变成了一棵有根树，我们先来看耗子移动的影响 可以发现耗子往下走就回不来了，而且最后还会被困在一个叶子上，那么这个时候我们把那个子树到根的路径砍成一条链(显然不砍成链耗子可以半路跑进岔路里，至少要你再清理一次，肯定不如砍了优)再把耗子放出来就可以了。而耗子往上走我们是管不了的(指不能阻止它往上走，但是可以砍旁边的分...
【算法】棋盘游戏(game)解题报告
jyyyyyy
11-07 2044
棋盘游戏(game) 源程序名       game.???  (pas,c,cpp) 可执行文件名   game.exe 输入文件名     game.in 输出文件名     game.out 时限           2s 在一个4*4的棋盘上有8个黑棋和8个白棋，当且仅当两个格子有公共边，这两个格子上的棋是相邻的。移动棋子的规则是交换相邻两个棋子。现在给出一个初始棋盘和一个最终棋
CEOI高中信息学编程竞赛学习资料集测试数据（2001-2016）.rar
最新发布
01-19
《CEOI高中信息学编程竞赛学习资料集测试数据（2001-2016）》是一个专门针对高中学生的信息学编程竞赛的学习资源库，包含了从2001年至2016年间历年的测试数据。这个压缩包是为那些准备参加CEOI（国际中学生奥林匹克...
CEOI1994-2003
02-08
《CEOI 1994-2003：回首早期的编程竞赛之旅》 中国的计算机奥林匹克竞赛（China Girls Mathematical Olympiad，简称CGMO）是中国青少年计算机编程领域的一项重要赛事，自1994年开始举办以来，吸引了众多对编程充满...
CEOI--2008
02-08
【CEOI 2008】是第十三届国际信息学奥林匹克竞赛（International Olympiad in Informatics，简称IOI）的赛事，全称为“国际中学生信息学奥林匹克竞赛”。这一年度的竞赛在中国上海举行，旨在检验世界各国中学生的...
loj#2788-「CEOI2015 Day1」管道【树上差分】
QuantAsk
08-11 256
但是我们不能离线建生成树，因为我们存不下所有的边，考虑一下别的方向的优化。我们会发现对于非树边来说，如果这一条非树边能被其他非树边完全覆盖，那么说明这条边就没有用，所以我们对于非树边来说也只需要保留一棵最小生成树即可。一个朴素的想法是我们搞出一棵生成树来，然后对于非树边。路径上的边都标记成非割边，然后剩下的就是割边了。然后至于标记方面用树上差分来处理就好了。条边的一张图，求它的所有割边。我们存不下所有的边，但是。...
NOIP2014提高组复赛解题报告
TA
11-18 8722
Day1 T1生活大爆炸版剪刀石头布：模拟，水； T2联合权值：树形DP，水； T3Flappy Birds： 这道题我当时算时间复杂度算错了，O(nm^2)的时间复杂度给算成O(nm)了，所以根本就没想优化，以后①算时间复杂度的时候要小心一点了。 其实正解也是很简单的，只是在直译式DP的基础上做了一点小优化。 直译式DP：设f(i,j)为到达当前点的最小步数，则 f(i,j)->f
calc(陈立杰) 解题报告
TA
10-08 6633
感觉最近状态真是烂到爆。。首先不妨令序列有序，然后再乘n！即可。一上来先想到可以倍增，设f[i][j]表示在1~j中选i个数，那么有j->2j，便可以通过枚举一边选了几个得到。但是算错了复杂度以为是O(n3logn)O(n^3\log n)的。。（矩阵乘习惯了一倍增就感觉是三方挂logn。。）（没想到看了题解以后这竟然就是标算。。）然后又想，既然倍增是三次方的。。。那只能看看暴力转移了。f(i,j)
[NOIP2014]子矩阵解题报告
TA
04-18 4901
这题看上去没啥思路，一看数据范围小的可怜，就算了下暴搜的时间复杂度O(C(16,8)∗(C(16,8)+m3))≈108O(C(16,8)*(C(16,8)+m^3))≈10^8似乎没啥问题，然后就写了个暴搜，出了点数据发现T了，又加了个剪枝然后就A了。。 结果一看人家的代码全是DP。。让我有点蛋疼。 其实只要把暴搜的后半部分一改就可以了，把二维压成一维后，就有一个显然的DP方程：处理出选一列的
[COGS193]最多因子数 解题报告
TA
12-06 4660
这真是一道很神的题，看起来似乎只能暴搜，但是暴搜的话又没法解决出现了大质数因子的问题，所以我蛋疼了一下午还是写了个骗分+暴力，但没想到竟然A了！ 后来我看了题解，感到很不满意，因为题解根本就没有处理存在大质数的问题。 让我们先来看看所谓的正解：     本题的要求是，求出一个给定区间内的含因子数最多的整数。     首先，有必要明确一下如何求一个数的因子数。若一个数N满足N=P1N1·
最优贸易解题报告
TA
11-05 1987
----------------------------最优贸易是一个n=10^5级的稀疏图，求max{0,w[j]-w[i]}(g[1][i]&&g[i][j]&&g[j][n]).---------------------------- 一、SPFA的功能与理解，不能仅仅局限于求最短路，而可以是图中某点到图中所有点的某种关系。比如说本题中可以用来求某点到1的所有路径中的Wmax。 二、DF
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值