hdu2460 和 poj3694

最新推荐文章于 2021-05-20 11:52:07 发布
最新推荐文章于 2021-05-20 11:52:07 发布
阅读量287 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_A_N_T_I_A_NH/article/details/8573926
版权
poj3694:先预处理出询问边（u，v）的最小公共祖先lca{u,v}（用tarjan的lca离线算法）和桥的总数scc，最后每次从u到lca{u,v},v到lca{u,v}，找出其中桥的数量，用scc减去，就是答案了。因为每次形成了圈，所以用并查集缩点，不然会TLE；写了一天就T在这儿了。

hdu2460:尼玛啊？hdu太坑爹了，个种深搜都不行啊？ 连并查集路径压缩 的深搜都不行 害我改了一晚上…各种RE啊？其它和poj3694一样。

//poj3694 代码：
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define INF 100005
#define maxc 400005
using namespace std;
struct node
{
     int e,next;
}edge[maxc],Tedge[2005];
struct node1
{
     int a,b;
}qurey[1005],fa[INF];
int num,top,scc,bleg[INF],st[INF],first1[INF],first[INF],dfn[INF],low[INF],blegs[INF];
int used[INF],edges[maxc],ancestor[INF],lca[2005],ids[maxc],fids[maxc],ids1[maxc],fids1[maxc];
int Find( int x)
{
     return bleg[x]==x?x:bleg[x]=Find(bleg[x]);
}
void Union( int a, int b)
{
     a=Find(a),b=Find(b);
     bleg[b]=a;
}
int Finds( int x)
{
     return blegs[x]==x?x:blegs[x]=Finds(blegs[x]);
}
void Unions( int a, int b)
{
     a=Finds(a),b=Finds(b);
     blegs[a]=b;
}
void tarjan( int v)
{
     dfn[v]=low[v]=++num;
     st[++top]=v;
     ancestor[Find(v)]=v;
     for ( int i=first[v];i!=-1;i=edge[i].next)
     {
         int u=edge[i].e;
         if (fids[ids[i]])
         continue ;
         fids[ids[i]]=1;
         if (!dfn[u])
         {
             fa[u].a=v,fa[u].b=i;
             tarjan(u);
             Union(v,u);
             ancestor[Find(v)]=v;
             low[v]=min(low[v],low[u]);
             if (low[u]>dfn[v])
             {
                 scc++;
                 edges[ids[i]]=1;
                 while ( true )
                 {
                     int x=st[top--];
                     if (x==u)
                     break ;
                 }
             }
         }
         else
         low[v]=min(low[v],dfn[u]);
     }
     used[v]=1;
     for ( int i=first1[v];i!=-1;i=Tedge[i].next)
     if (used[Tedge[i].e] && !fids1[ids1[i]])
     {
         lca[ids1[i]]=ancestor[Find(Tedge[i].e)];
         fids1[ids1[i]]=1;
     }
}
int main()
{
     int n,m,q,cas=0;
     while ( scanf ( "%d%d" ,&n,&m),m+n)
     {
         cas++;
         memset (first,-1, sizeof (first));
         memset (first1,-1, sizeof (first1));
         memset (dfn,0, sizeof (dfn));
         memset (edges,0, sizeof (edges));
         memset (fids,0, sizeof (fids));
         memset (fids1,0, sizeof (fids1));
         memset (used,0, sizeof (used));
         int a,b,nume,number;
         number=nume=top=scc=num=0;
         for ( int i=1;i<=n;i++)
         blegs[i]=fa[i].a=bleg[i]=i;
         while (m--)
         {
             scanf ( "%d%d" ,&a,&b);
             ids[nume]=number;
             edge[nume].e=b,edge[nume].next=first[a],first[a]=nume++;
             ids[nume]=number++;
             edge[nume].e=a,edge[nume].next=first[b],first[b]=nume++;
         }
         number=nume=0;
         scanf ( "%d" ,&q);
         for ( int i=0;i<q;i++)
         {
             scanf ( "%d%d" ,&a,&b);
             qurey[i].a=a,qurey[i].b=b;
             ids1[nume]=number;
             Tedge[nume].e=b,Tedge[nume].next=first1[a],first1[a]=nume++;
             ids1[nume]=number++;
             Tedge[nume].e=a,Tedge[nume].next=first1[b],first1[b]=nume++;
         }
         tarjan(1);
         printf ( "Case %d:n" ,cas);
         for ( int i=0;i<q;i++)
         {
             if (scc!=0)
             {
                 for ( int k=qurey[i].a,j=Finds(fa[k].a);j!=Finds(qurey[i].a);k=j,j=Finds(fa[j].a))
                 {
                     Unions(qurey[i].a,j);
                     if (edges[ids[fa[k].b]])
                     {
                         scc--;
                         edges[ids[fa[k].b]]=0;
                     }
                     if (j==Find(lca[i]))
                     break ;
                 }
                 for ( int k=qurey[i].b,j=Finds(fa[k].a);j!=Finds(qurey[i].b);k=j,j=Finds(fa[j].a))
                 {
                     Unions(qurey[i].b,j);
                     if (edges[ids[fa[k].b]])
                     {
                         scc--;
                         edges[ids[fa[k].b]]=0;
                     }
                     if (j==Finds(lca[i]))
                     break ;
                 }
                 Union(qurey[i].a,qurey[i].b);
             }
             printf ( "%dn" ,scc);
         }
         printf ( "n" );
     }
     return 0;
}
 

//hdu2460  代码：
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define INF 100005
#define maxc 400005
using namespace std;
struct node
{
     int e,next;
}edge[maxc],Tedge[2005];
struct node1
{
     int a,b;
}qurey[1005],fa[INF];
int num,top,scc,bleg[INF],st[INF],first1[INF],first[INF],dfn[INF],low[INF],blegs[INF],vis[INF];
int used[INF],edges[maxc],ancestor[INF],lca[2005],ids[maxc],fids[maxc],ids1[maxc],fids1[maxc];
int Find( int x)
{
     int y=x;
     while (y!=bleg[y])
     y=bleg[y];
     while (x!=bleg[x])
     {
         int px=bleg[x];
         bleg[x]=y;
         x=px;
     }
     return y;
}
void Union( int a, int b)
{
     a=Find(a),b=Find(b);
     bleg[b]=a;
}
int Finds( int x)
{
     int y=x;
     while (y!=blegs[y])
     y=blegs[y];
     while (x!=blegs[x])
     {
         int px=blegs[x];
         blegs[x]=y;
         x=px;
     }
     return y;
}
void Unions( int a, int b)
{
     a=Finds(a),b=Finds(b);
     blegs[a]=b;
}
void tarjan( int v)
{
     st[++top]=v;
     while (top)
     {
         v=st[top];
         if (!vis[v])
         dfn[v]=low[v]=++num,vis[v]=1;
         ancestor[Find(v)]=v;
         int i;
         for (i=first[v];i!=-1;i=edge[i].next)
         {
             int u=edge[i].e;
             if (fids[ids[i]])
             continue ;
             fids[ids[i]]=1;
             if (!vis[u])
             {
                 fa[u].a=v,fa[u].b=i;
                 break ;
             }
             else if (vis[u]==1)
             low[v]=min(low[v],dfn[u]);
         }
         if (i==-1 && top>1)
         {
             Union(st[top-1],v);
             low[st[top-1]]=min(low[st[top-1]],low[v]);
             if (low[v]>dfn[st[top-1]])
             {
                 scc++;
                 edges[ids[fa[v].b]]=1;
             }
         }
         if (i==-1)
         {
             vis[v]=2;
             top--;
             used[v]=1;
             for (i=first1[v];i!=-1;i=Tedge[i].next)
             if (used[Tedge[i].e] && !fids1[ids1[i]])
             {
                 lca[ids1[i]]=ancestor[Find(Tedge[i].e)];
                 fids1[ids1[i]]=1;
             }
         }
         else
         st[++top]=edge[i].e;
     }
}
int main()
{
     int n,m,q,cas=0;
     while ( scanf ( "%d%d" ,&n,&m),m+n)
     {
         cas++;
         memset (first,-1, sizeof (first));
         memset (first1,-1, sizeof (first1));
         memset (dfn,0, sizeof (dfn));
         memset (edges,0, sizeof (edges));
         memset (fids,0, sizeof (fids));
         memset (fids1,0, sizeof (fids1));
         memset (used,0, sizeof (used));
         memset (vis,0, sizeof (vis));
         int a,b,nume,number;
         number=nume=top=scc=num=0;
         for ( int i=1;i<=n;i++)
         blegs[i]=fa[i].a=bleg[i]=i;
         while (m--)
         {
             scanf ( "%d%d" ,&a,&b);
             ids[nume]=number;
             edge[nume].e=b,edge[nume].next=first[a],first[a]=nume++;
             ids[nume]=number++;
             edge[nume].e=a,edge[nume].next=first[b],first[b]=nume++;
         }
         number=nume=0;
         scanf ( "%d" ,&q);
         for ( int i=0;i<q;i++)
         {
             scanf ( "%d%d" ,&a,&b);
             qurey[i].a=a,qurey[i].b=b;
             ids1[nume]=number;
             Tedge[nume].e=b,Tedge[nume].next=first1[a],first1[a]=nume++;
             ids1[nume]=number++;
             Tedge[nume].e=a,Tedge[nume].next=first1[b],first1[b]=nume++;
         }
         tarjan(1);
         printf ( "Case %d:n" ,cas);
         for ( int i=0;i<q;i++)
         {
             if (scc!=0)
             {
                 for ( int k=qurey[i].a,j=Finds(fa[k].a);j!=Finds(qurey[i].a);k=j,j=Finds(fa[j].a))
                 {
                     Unions(qurey[i].a,j);
                     if (edges[ids[fa[k].b]])
                     {
                         scc--;
                         edges[ids[fa[k].b]]=0;
                     }
                     if (j==Find(lca[i]))
                     break ;
                 }
                 for ( int k=qurey[i].b,j=Finds(fa[k].a);j!=Finds(qurey[i].b);k=j,j=Finds(fa[j].a))
                 {
                     Unions(qurey[i].b,j);
                     if (edges[ids[fa[k].b]])
                     {
                         scc--;
                         edges[ids[fa[k].b]]=0;
                     }
                     if (j==Finds(lca[i]))
                     break ;
                 }
                 Union(qurey[i].a,qurey[i].b);
             }
             printf ( "%dn" ,scc);
         }
         printf ( "n" );
     }
     return 0;
}
L_A_N_T_I_A_NH
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
POJ+HDU题库使用指南
qq_46476515的博客
09-03 2274
POJ解题指南
HDU&&POJ图论题集
04-24
图论〔Graph Theory〕是数学的一个分支。它以图为研究对象。图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个...
HDU2460 && POJ3694：桥
FlyingJack
03-13 199
POJ3694 题解： 首先说一下，一模一样的题目在HDU和POJ上得到的结果与众不同。HDU在vector记录边AC，在POJ上用C++和G++不是TLE就是RE。最后改为邻接矩阵，C++1400ms左右AC，G++WA。 这一题要求桥，这和求个割点有一点不一样。如果（u，v）是桥，u是父节点，v是子节点，那么我们用v来记录桥。因为子节点有唯一的父节点，唯一确定一座桥。并且不用特殊考虑根节...
hdu2460 poj3694 求桥 + 求lca
liujc_的专栏
05-09 1151
http://poj.org/problem?id=3694 题意： 给定一个图，对这个图进行加边，求出每加一条边后，图中桥的个数。 思路： 首先肯定是要先求出原图中桥的个数，并且把桥标记起来。思考加一条边以后桥的数量会减少多少，联想到之前的那道题，就是加一条边，能够使桥的数量最少是多少。之前那个做法就是缩点后树的直径，这个就是可以减少的最多的桥的数量。因为如果这是一条链，将两个端点连起来，
hdu 2460 poj 3694 (双联通+LCA)
菜鸟起航的专栏
08-02 984
在给出的两个点上加一条边，求剩下桥的数量，，不会LCA在线，就用了最普通的，先Tarjan双联通缩点，然后将缩完的图建成一棵树，树的所有边就是桥了，如果在任意两点间加一条边的话，那么从两点到最近公共祖先的所有边都不是桥了。。。。。。 #pragma comment(linker, "/STACK:10240000000000,10240000000000"
hdu2460&&poj3694 缩点+lca变形
ACM,再见！
03-02 823
http://acm.hdu.edu.cn/showproblem.php?pid=2460 http://poj.org/problem?id=3694 Problem Description A network administrator manages a large network. The network consists of N computers and M
Hdu 2844 & Poj 1742 结题报告
o670783915的博客
07-27 258
首先上面的两道题都是同一道题，之所以同时拿出来是因为 Hdu 的数据比 Poj 的水，所以想区分一下。 Hdu 的数据对时间要求不高 但是 Poj 如果你想用简单的 多重背包解决的话，就会TLE 别问我怎么知道。首先大家肯定会想到用多重背包来做 毕竟题意可以嵌套模板如下#include <cstdio> #include <cstring> #include <algorithm> #inc
HDU 1338 POJ 1323(贪心）
JACK_JYH的博客
08-20 446
#include<cstdio> #include<cstring> #include<string> #include<cmath> #include<vector> #include<algorithm> #include<iostream> #include<time.h> using namespace std;bool f[1005]; int a[1005];int vs_main()
hdu 1540/POJ 2892 Tunnel Warfare 【线段树区间合并】
Fighting!
08-10 2170
Tunnel Warfare Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) 链接：hdu 1540        POJ 2892 Problem Description  During the War of Resistance Against Jap
HDU2716 POJ2141 Message Decowding【密码】
海岛Blog
02-19 193
Message Decowding Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1934 Accepted Submission(s): 834 Problem Description The cows are thrilled because they’ve just learned about encrypting messages.
POJ2460 HDU1152 Brownie Points I【水题】
海岛Blog
05-20 168
Brownie Points I Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 1438 Accepted: 903 Description Stan and Ollie play the game of Odd Brownie Points. Some brownie points are located in the plane, at integer coordinates. Stan plays first and plac
hdu oj poj 题目代码与详解
09-08
【题目代码与详解】是针对在线编程竞赛平台HDU（杭州电子科技大学在线评测系统）和POJ（普林斯顿大学在线判题系统）中的经典题目所编写的解决方案和解析的集合。这些平台是程序员和计算机科学学生提升算法技能、熟悉...
leetcode下载-algorithm-1:力扣、HDU、ZOJ、POJ
06-29
Interview，ZOJ，POJ 等平台。 欢迎Coders对代码加以指正和提议！ 常见问题总结 两整数求平均值 average = min + (max - min) / 2 防止两整数的和越界 整数乘积对比 1.0 * m * m == num 类似乘积对比， 需转为double...
【包教包会】用树的定义去判断树！(HDU1272)(HDU1325)(POJ1308)
01-20
在计算机科学中，树是一种非常基础且重要的数据...通过编程实现这些条件的检查，可以解决如HDU1272、HDU1325和POJ1308这类题目。掌握这些基本概念和技巧，不仅有助于解决这类问题，也是深入学习图论和数据结构的基础。
algorithm:记录我的在线裁判（hdu，poj等）的算法问题代码
05-17
记录我的在线裁判（hdu，poj等）的算法问题代码" 暗示了这个压缩包可能包含一系列用C++语言编写的算法解决方案，这些方案是为了解决在线编程竞赛或者练习平台如HDU（杭州电子科技大学在线评测系统）和POJ（普林斯顿...
聚类算法-一种无监督学习方法.docx
最新发布
08-12
聚类算法是一种无监督学习方法，用于将数据集中的数据点自动分组到不同的类别中，这些类别也称为“簇”或“群”。聚类的目标是让同一簇内的数据点尽可能相似，而不同簇之间的数据点尽可能不相似。聚类算法广泛应用于多种领域，如数据挖掘、模式识别、图像分析、信息检索等。 聚类算法的基本概念 无监督学习：聚类算法不需要事先标记数据点的类别标签，而是根据数据本身的相似性来分组。 相似性度量：聚类算法依赖于某种相似性或距离度量来决定数据点之间的相似程度。常用的度量包括欧氏距离、曼哈顿距离等。 目标函数：大多数聚类算法都会尝试最小化某种目标函数，例如簇内的平方误差和（SSE）。 常见的聚类算法 K-Means K-Means 是一种原型聚类算法，它通过迭代地将数据点分配到最近的质心来形成簇，并重新计算每个簇的质心，直到质心不再显著变化为止。 在 Python 的 scikit-learn 库中，可以通过 KMeans 类实现 K-Means 聚类。 层次聚类 层次聚类构建一个树状图（称为树状图或 dendrogram），显示数据点是如何逐渐合并成簇的。 这种算法可以是凝聚型（自底向上）或分裂型（自顶向下）。
45ft集装箱模型3D图纸 STEP格式.zip
08-12
45ft集装箱模型3D图纸 STEP格式.zip
Spring Boot网吧管理系统.zip
08-12
该系统严格按照需求分析制作相关模块，并利用所学知识尽力完成，但是本人由于学识浅薄，无法真正做到让该程序可以投入市场使用，仅仅简单实现部分功能，希望日后还能改善。 本系统具有以下优点： 该系统具有较高的适用性，选用B/S结构，可以在绝大部分个人平台上使用该系统。 系统将用户权限进行划分，管理员，网管和会员都能看到及操作的信息不一样，三者具备不同的操作权限。 该系统操作界面简单明了，大部分人都可以正常使用。 但也存在以下问题需要改进： 运行时窗口不能被刷新，可以改进。 系统过于简单，显示的信息有限。。 不能添加多个管理员账号，如果可以则将利于发展网吧规模，便于网吧信息集中管理。 不能实时预约接待消息和网吧反馈建议，容易被忽视，不利于管理员服务客户。
微信小程序大作业 新闻小程序
08-12
微信小程序大作业 新闻小程序
博弈问题解析：HDU Online Judge与Poj1067的石子游戏策略
而POJ 1067和HDU 1527则涉及到两堆石子的博弈，游戏规则是玩家轮流从任意一堆中取出任意数量的石子，但不能从同一堆中连续取石子。目标同样是取完石子，这里可能需要用到动态规划或搜索算法来找出最优解。 至于HDU ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值