hdu1839(二分+优先队列,bfs+优先队列与spfa的区别)
题意:有n个点,标号为点1到点n,每条路有两个属性,一个是经过经过这条路要的时间,一个是这条可以承受的容量。现在给出n个点,m条边,时间t;需要求在时间t的范围内,从点1到点n可以承受的最大容量........
思路:其实我是觉得思路挺简单的,就是二分枚举每条边的容量,然后再看在这个容量的限制下,是否可以从点1到点n........
方法1:二分枚举边的容量,然后一次dfs,判断在容量和时间的双重限制下,是否可以从点1到达点n......
wa代码:
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
typedef __int64 ss;
struct node
{
ss k;
ss t;
ss v;
};
ss n,m,t,a[50005],sum,flag;
vector<node>vet[10005];
ss vist[10005];
void dfs(ss x,ss maxn,ss total)
{
if(x==n)
{
flag=1;
return;
}
if(flag==1)
return;
for(ss i=0;i<vet[x].size();i++)
{
node p=vet[x][i];
if(!vist[p.k]&&p.v>=maxn&&(p.t+total<=t))
{
vist[p.k]=1;
dfs(p.k,maxn,p.t+total);
}
}
}
ss deal(ss num)
{
ss maxn=a[num];
flag=0;
memset(vist,0,sizeof(vist));
dfs(1,maxn,0);
return flag;
}
int main()
{
int text;
scanf("%d",&text);
while(text--)
{
ss cnt=0;
scanf("%I64d%I64d%I64d",&n,&m,&t);
for(int i=0;i<=n;i++)
vet[i].clear();
for(ss i=0;i<m;i++)
{
ss v1,v2,tmp,tmp1;
scanf("%I64d %I64d %I64d %I64d",&v1,&v2,&tmp,&tmp1);
node p;
p.k=v2;
p.t=tmp1;
p.v=tmp;
vet[v1].push_back(p);
p.k=v1;
vet[v2].push_back(p);
a[cnt++]=tmp;
}
sort(a,a+cnt);
//printf("%I64d\n",cnt);
ss ll=0,rr=cnt-1;
ss ans=0;
while(ll<=rr)
{
sum=0;
ss mid=(ll+rr)/2;
if(deal(mid))
{
if(ans<a[mid])
ans=a[mid];
ll=mid+1;
}
else rr=mid-1;
}
printf("%I64d\n",ans);
}
return 0;
}
我倒是很快明白了过来,错误在什么地方。因为我的dfs是每个点只历遍一次,有的路被忽略掉了,从而导致wa,额,可以改改,让dfs回溯,然后重置vist标记数组,但是这样做的话,肯定超时...<..>
方法2:二分枚举边的容量,然后用优先队列+bfs,判断在容量和时间的双重限制下,是否可以从点1到达点n......
wa代码:
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
typedef __int64 ss;
struct node
{
ss k;
ss t;
ss v;
};
struct node1
{
friend bool operator<(const node1 a,const node1 b)
{
if(a.t>b.t)
return 1;
else
return 0;
}
ss e;
ss t;
}; ss n,m,t,a[500005],sum,flag;
vector<node>vet[100005];
ss vist[100005];
/*void dfs(ss x,ss maxn,ss total)
{
if(x==n)
{
flag=1;
return;
}
if(flag==1)
return;
for(ss i=0;i<vet[x].size();i++)
{
node p=vet[x][i];
if(!vist[p.k]&&p.v>=maxn&&(p.t+total<=t))
{
vist[p.k]=1;
dfs(p.k,maxn,p.t+total);
vist[p.k]=0;
}
}
}*/
priority_queue<node1>q;
ss bfs(ss num)
{
ss minx=a[num];
node1 p;
memset(vist,0,sizeof(vist));
p.e=1;
p.t=0;
while(!q.empty())
q.pop();
q.push(p);
vist[p.e]=1;
while(!q.empty())
{
p=q.top();
q.pop();
vist[p.e]=0;
if(p.e==n)
{
if(p.t<=t)
{
return 1;
}
return 0;
}
ss x=p.e;
for(ss i=0; i<vet[x].size(); i++)
{
node p1=vet[x][i];
node1 iter;
iter.e=p1.k;
iter.t=p1.t+p.t;
if(!vist[p1.k]&&p1.v>=minx&&iter.t<=t)
{
vist[p1.k]=1;
q.push(iter);
}
}
}
return 0;
}
int main()
{
int text;
scanf("%d",&text);
while(text--)
{
ss cnt=0;
scanf("%I64d%I64d%I64d",&n,&m,&t);
for(ss i=0; i<=n; i++)
vet[i].clear();
for(ss i=0; i<m; i++)
{
ss v1,v2,tmp,tmp1;
scanf("%I64d %I64d %I64d %I64d",&v1,&v2,&tmp,&tmp1);
node p;
p.k=v2;
p.t=tmp1;
p.v=tmp;
vet[v1].push_back(p);
p.k=v1;
vet[v2].push_back(p);
a[cnt++]=tmp;
}
sort(a,a+cnt);
//printf("%I64d\n",cnt);
ss ll=0,rr=cnt-1;
ss ans=0;
while(ll<=rr)
{
//sum=0;
ss mid=(ll+rr)/2;
if(bfs(mid))
{
if(ans<a[mid])
ans=a[mid];
ll=mid+1;
}
else rr=mid-1;
}
printf("%I64d\n",ans);
}
return 0;
}
思考了很久,也是明白了为什么会wa。在以往,我使用bfs、bfs+优先队列求最小值、最短路什么的时候,都是在一张点图上求解的。换句话说,那样的图上,一个点到另一个点可以到达,那么它们必然相邻,然后路径值固定是1,当然也许会有从某个点到另一个点,路径不是1的,假设从这个点到那个点的距离是k,那么从其他相邻点到那个点的距离也是k,如此就可以使得bfs搜索过去的每个状态只需更新一次,因为更新完一次必然是最小的。
但是,这个题目却是不同。因为它并不是点有权值,而是边的权值,假如我从点1到点3这个点权值为9,那么从点2到点3的权值可以为3......如此就会导致搜索过去,更新了的状态并不是最小的........
这就是bfs与spfa的区别吧,bfs可以实现的时候,必然是点自身带权值,比如说,点1有两个属性,一个是xx,一个是yy,要是从其他可以到达点1的点,那么必须加上这个点的某个权值,然后求最小值........
而spfa却是边带权值.........
方法3:二分+spfa
ac代码:
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
typedef __int64 ss;
struct node
{
ss k;
ss t;
ss v;
};
ss n,m,t,a[50005],sum,flag;
vector<node>vet[10005];
ss vist[10005],dis[10005];
ss spfa(ss num)
{
ss minx=a[num];
for(ss i=0; i<=n; i++)
{
dis[i]=((ss)1<<25);
vist[i]=0;
}
dis[1]=0;
vist[1]=1;
queue<ss>q;
q.push(1);
while(!q.empty())
{
ss x=q.front();
q.pop();
vist[x]=0;
for(ss i=0; i<vet[x].size(); i++)
{
node p=vet[x][i];
if(p.v>=minx)
{
if(dis[p.k]>dis[x]+p.t)
{
dis[p.k]=dis[x]+p.t;
if(!vist[p.k])
q.push(p.k);
vist[p.k]=1;
} }
}
}
if(dis[n]<=t)
return 1;
else return 0;
}
int main()
{
int text;
scanf("%d",&text);
while(text--)
{
ss cnt=0;
scanf("%I64d%I64d%I64d",&n,&m,&t);
for(ss i=0; i<=n; i++)
vet[i].clear();
for(ss i=0; i<m; i++)
{
ss v1,v2,tmp,tmp1;
scanf("%I64d %I64d %I64d %I64d",&v1,&v2,&tmp,&tmp1);
node p;
p.k=v2;
p.t=tmp1;
p.v=tmp;
vet[v1].push_back(p);
p.k=v1;
vet[v2].push_back(p);
a[cnt++]=tmp;
}
sort(a,a+cnt);
//printf("%I64d\n",cnt);
ss ll=0,rr=cnt-1;
ss ans=0;
while(ll<=rr)
{
//sum=0;
ss mid=(ll+rr)/2;
if(spfa(mid))
{
if(ans<a[mid])
ans=a[mid];
ll=mid+1;
}
else rr=mid-1;
}
printf("%I64d\n",ans);
}
return 0;
}
hdu1839(二分+优先队列,bfs+优先队列与spfa的区别)的更多相关文章
- POJ 1724 ROADS(BFS+优先队列)
题目链接 题意 : 求从1城市到n城市的最短路.但是每条路有两个属性,一个是路长,一个是花费.要求在花费为K内,找到最短路. 思路 :这个题好像有很多种做法,我用了BFS+优先队列.崔老师真是千年不变 ...
- hdu 1026 Ignatius and the Princess I【优先队列+BFS】
链接: http://acm.hdu.edu.cn/showproblem.php?pid=1026 http://acm.hust.edu.cn/vjudge/contest/view.action ...
- ZOJ 649 Rescue(优先队列+bfs)
Rescue Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total Sub ...
- 【POJ3635】Full Tank 优先队列BFS
普通BFS:每个状态只访问一次,第一次入队时即为该状态对应的最优解. 优先队列BFS:每个状态可能被更新多次,入队多次,但是只会扩展一次,每次出队时即为改状态对应的最优解. 且对于优先队列BFS来说, ...
- hdu 1242 找到朋友最短的时间 (BFS+优先队列)
找到朋友的最短时间 Sample Input7 8#.#####. //#不能走 a起点 x守卫 r朋友#.a#..r. //r可能不止一个#..#x.....#..#.##...##...#.... ...
- Codeforces 677D - Vanya and Treasure - [DP+优先队列BFS]
题目链接:http://codeforces.com/problemset/problem/677/D 题意: 有 $n \times m$ 的网格,每个网格上有一个棋子,棋子种类为 $t[i][j] ...
- POJ 2449 - Remmarguts' Date - [第k短路模板题][优先队列BFS]
题目链接:http://poj.org/problem?id=2449 Time Limit: 4000MS Memory Limit: 65536K Description "Good m ...
- HDU 1428 漫步校园 (BFS+优先队列+记忆化搜索)
题目地址:HDU 1428 先用BFS+优先队列求出全部点到机房的最短距离.然后用记忆化搜索去搜. 代码例如以下: #include <iostream> #include <str ...
- BFS+优先队列+状态压缩DP+TSP
http://acm.hdu.edu.cn/showproblem.php?pid=4568 Hunter Time Limit: 2000/1000 MS (Java/Others) Memo ...
随机推荐
- scp的两种方式
如果host A 与 host B建立了信任连接(B有A的public key),那么从A向B传送文件,或者从B上传回文件都可以省略密码.但是前提是命令是在A上执行的. 从A向B拷贝文件 on hos ...
- MFC坐标转换
1.GetWindowRect是取得窗口在屏幕坐标系下的RECT坐标(包括客户区和非客户区),这样可以得到窗口的大小和相对屏幕左上角(0,0)的位置. 2.GetClientRect取得窗口客户区(不 ...
- 利用hadoop来解决“共同好友”的问题
假设A有好友B C D:B有好友A C D E:C有好友A B D E:D有好友A B C E;E有好友B C D. A -> B C D B -> A C D E C -> A B ...
- Snip for Mac(桌面截图工具)安装
1.软件简介 Snip 一款用于桌面截图的工具. 2.资源列表 链接 提取密码 系统要求 软件语言 Snip for Mac v2.0 (5771) fgab macOS 10.6.8 及以上 ...
- C++模板”>>”编译问题与词法消歧设计
在编译理论中,通常将编译过程抽象为5个主要阶段:词法分析(Lexical Analysis),语法分析(Parsing),语义分析(Semantic Analysis),优化(Optimization ...
- 在ToolStrip中加入具有更好体验性的DateTimePicker
一. 需求的产生 很多时候,需要根据年月或日期来检索数据.在我的数据库中,如果只需要以月为单位,我一般按照200801这样的格式(yyyyMM)保存为int类型.在做数据检索时,是根据工具栏 ...
- how-to-convert-string-to-localdate
Few Java examples show you how to convert a String to the new Java 8 Date API – java.time.LocalDate ...
- 视图不能由多个 ListView 共享 (View can't be shared by more than one ListView) 的一个解决方法
1.问题的起因 在WPF中遇到一异常,如题. 因此做一个Demo代码来复现问题,代码如下: <Window x:Class="WpfAppThread.MainWindow" ...
- 使用 properties 配置文件装配 bean 的方式
在spring中将bean 注册到spring 容器中常见的有三种方式(两类): 先说明配置文件内容:application.yml,有一段配置如下 persons: youtube: name: y ...
- mysql 主从同步遇到的问题(1032)
event_scheduler对主从的影响: 1 对于已经存在的主从, 新建立events没有影响. 2 对于新建立的主从,如果有events ,那么需要在从库上把event_scheduler设置为 ...