UVA 10816 + HDU 1839 Dijstra + 二分 （待研究）

UVA

题意：两个绿洲之间是沙漠，沙漠的温度不同，告诉起点，终点，求使得从起点到终点的最高温度最小的路径，如果有多条，输出长度最短的路径；

思路：用最小费用（最短路径）最大流（最小温度）也能搞吧，但因为题意是看着博客做的，不小心看到了他的思路，就自己实现了一遍，二分温度，假设当前温度为x，求保证最大温度为x的情况下的最短路；打印路径就是递归打印。

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <algorithm>
 #include <cstring>
 #include <cmath>
 #include <vector>
 #include <queue>
 #include <stack>
 #include <set>
 #include <map>
 #define oo 1e9
 #define repu(i, a, b) for(int i = (a); i < (b); i++)
 using namespace std;
 typedef long long LL;
 const int maxn=;
 const int INF=0x3f3f3f3f;
 int rode[maxn];
 int st,ed;
 struct Edge
 {
     int u, v;
     double t, d;
     Edge(int u, int v, double t, double d):u(u), v(v), t(t), d(d) {}
 };
 struct qnode
 {
     int u;
     double d;
     qnode(int u, double d):u(u), d(d) {}
     bool operator < (const qnode a)const
     {
         return d > a.d;
     }
 };
 struct Dijkstra
 {
     int n;
     vector<int> G[maxn];
     vector<Edge> edge;
     double d[maxn];
     bool vis[maxn];
     void init(int n)
     {
         this->n=n;
         for(int i=; i<=n; i++)
         {
             G[i].clear();
             vis[i]=;
             d[i]=INF;
         }
         edge.clear();
     }
     void AddEdge(int u, int v, double t, double d)
     {
         G[u].push_back(edge.size());
         edge.push_back(Edge(u, v, t, d));
     }
     bool dijkstra(double cur)
     {
         memset(rode, -, sizeof rode);
         memset(vis, , sizeof vis);
         repu(i,,n+)
         d[i] = oo;
         priority_queue<qnode> q;
         d[st]=0.00;
         q.push(qnode(st, ));
         while(!q.empty())
         {
             qnode x=q.top();
             q.pop();
             if(vis[x.u])
                 continue ;
             vis[x.u]=true;
             if(x.u == ed)
                 return true;
             for(int i=; i<G[x.u].size(); i++)
             {
                 Edge& e=edge[G[x.u][i]];
                 if(e.t <= cur&& d[e.v]>d[x.u]+e.d)
                 {
                     ///加条件,保证最大的温度是e.t
                     d[e.v]=d[x.u]+e.d;
                     rode[e.v]=x.u;///保存路径
                     q.push(qnode(e.v, d[e.v]));
                 }
             }
         }
         return d[ed] < oo;
     }
 } dij;
 void printroad(int x)
 {
     if(x==st)
     {
         printf("%d", x);
         return ;
     }
     printroad(rode[x]);
     printf(" %d", x);
 }
 int main()
 {
     int n,m;
     while(~scanf("%d%d",&m,&n))
     {
         dij.init(m);
         scanf("%d%d",&st,&ed);
         int u,v;
         double c,w;
         vector<double> se;
         repu(i,,n)
         {
             scanf("%d%d%lf%lf",&u,&v,&c,&w);
             se.push_back(c);
             dij.AddEdge(u, v, c, w);
             dij.AddEdge(v, u, c, w);
         }
         sort(se.begin(),se.end());///按照温度排序进行二分
         int L = , R = unique(se.begin(),se.end())- se.begin()-;
         int mid;
         while(L<R)
         {
             mid=(L+R)/;
             if(dij.dijkstra(se[mid]))
                 R=mid;///如果存在就找更小的温度
             else L=mid+;
         }
         dij.dijkstra(se[R]);///找到的R就是最终的条件
         printroad(ed);
         printf("\n%.1lf %.1lf\n", dij.d[ed], se[R]);
     }
     return ;
 }

HDU

题意：起点1，终点m,每条道路都有一个最大容量，以及通过的时间，求在时间T内能过的最大的容量；

思路：得用最大流吧，但是可能数据水，跟上一题一样的思路居然也能过。

注意：说代码的话，跟上一题完全一样，除了二分，但我被坑的一点就是二分，L跟R赋值的时候没改掉，就debug其他的地方，花费了不少的时间；

按照从小到大的顺序排好后，进行二分，注意mid = （l + r + 1）/ 2;符合的 l = mid;否则r = mid -1;(这是找越大的越好)---mid为啥+1母鸡啊

按照从小到大的顺序排好后，进行二分，注意mid = （l + r ）/ 2;符合的 l = mid - 1;否则r = mid ;(这是找越小的越好)

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <algorithm>
 #include <cstring>
 #include <cmath>
 #include <vector>
 #include <queue>
 #include <stack>
 #include <set>
 #include <map>
 #define repu(i, a, b) for(int i = (a); i < (b); i++)
 using namespace std;
 typedef long long LL;
 const int maxn=;
 const int INF=0x3f3f3f3f;
 int rode[maxn];
 int st,ed,T;
 struct Edge
 {
     int u, v;
     int t, d;
     Edge(int u, int v, int t, int d):u(u), v(v), t(t), d(d) {}
 };
 struct qnode
 {
     int u;
     int d;
     qnode(int u, int d):u(u), d(d) {}
     bool operator < (const qnode a)const
     {
         return d > a.d;
     }
 };
 struct Dijkstra
 {
     int n;
     vector<int> G[maxn];
     vector<Edge> edge;
     int d[maxn];
     bool vis[maxn];
     void init(int n)
     {
         this->n=n;
         for(int i=; i<=n; i++)
         {
             G[i].clear();
             vis[i]=;
             d[i]=INF;
         }
         edge.clear();
     }
     void AddEdge(int u, int v, int t, int d)
     {
         G[u].push_back(edge.size());
         edge.push_back(Edge(u, v, t, d));
     }
     int dijkstra(int cur)
     {
         memset(vis, , sizeof vis);
         repu(i,,n+)
         d[i]=i==?:INF;
         priority_queue<qnode> q;
         d[st]=;
         q.push(qnode(st, ));
         while(!q.empty())
         {
             qnode x=q.top();
             q.pop();
             if(vis[x.u])
                 continue ;
             vis[x.u]=true;
             if(x.u == ed)
                 return d[ed] <= T;
             for(int i=; i<G[x.u].size(); i++)
             {
                 Edge& e=edge[G[x.u][i]];
                 if(e.t >= cur && d[e.v] > d[x.u]+e.d)
                 {
                     ///加条件,保证最小的容量是cur
                     d[e.v]=d[x.u]+e.d;
                     q.push(qnode(e.v, d[e.v]));
                 }
             }
         }
         return d[ed] <= T;
     }
 } dij;
 int main()
 {
     int n,m,I;
     scanf("%d",&I);
     while(I--)
     {
         scanf("%d%d%d",&m,&n,&T);
         dij.init(m);
         st = ;
         ed = m;
         int u,v;
         int c,w;
         vector<int> se;
         repu(i,,n)
         {
             scanf("%d%d%d%d",&u,&v,&c,&w);
             se.push_back(c);
             dij.AddEdge(u, v, c, w);
             dij.AddEdge(v, u, c, w);
         }
         sort(se.begin(),se.end());///按照容量排序进行二分
         int L = , R = unique(se.begin(),se.end())- se.begin()-;
         int mid;
         while(L < R)///居然在这里栽坑了
         {
             mid=(L + R + )/;
             if(dij.dijkstra(se[mid]))
                 L=mid;///如果存在就找更大的容量
             else R=mid-;
         }
         printf("%d\n", se[L]);
     }
     return ;
 }