codevs1183 泥泞的道路 图论+奇怪的东西[四星]

以后不打算把题解写到标题了~那样可能对看的人造成影响~

题目链接:戳鸟~

题目描述 Description

CS有n个小区，并且任意小区之间都有两条单向道路（a到b，b到a）相连。因为最近下了很多暴雨，很多道路都被淹了，不同的道路泥泞程度不同。小A经过对近期天气和地形的科学分析，绘出了每条道路能顺利通过的时间以及这条路的长度。

现在小A在小区1，他希望能够很顺利地到达目的地小区n，请帮助小明找出一条从小区1出发到达小区n的所有路线中（总路程/总时间）最大的路线。请你告诉他这个值。

输入描述 Input Description

第一行包含一个整数n，为小区数。

接下来n*n的矩阵P，其中第i行第j个数表示从小区i到小区j的道路长度为Pi,j。第i行第i个数的元素为0，其余保证为正整数。

接下来n*n的矩阵T，第i行第j个数表示从小区i到小区j需要的时间Ti,j。第i行第i个数的元素为0，其余保证为正整数。

输出描述 Output Description

写入一个实数S，为小区1到达n的最大答案，S精确到小数点后3位。

样例输入 Sample Input

3

0 8 7

9 0 10

5 7 0

0 7 6

6 0 6

6 2 0

样例输出 Sample Output

2.125

数据范围及提示 Data Size & Hint

【数据说明】

30%的数据，n<=20

100%的数据，n<=100，p,t<=10000

题目简单易懂，但是思想并不是很简单……

这题的题解是二分+最短路验证，由于很久不做二分的题了，所以开始没能想出来……

这题一看，有double，精度问题肯定不好弄，如果全程用spfa跑，精度误差会非常恶心，所以我们采取二分答案的方法。

二分起始边界l=0，r = INF

二分的是答案，每次二分到得答案，如果通过spfa能得到一个正环，或者可以得到一个dist
>0的答案，就说明这个答案符合条件，左边界扩展，即l = mid,反之，说明这个答案不符合，r = mid.具体的转移：

[code]int v = edges[i].to;
if(dist[v] < dist[f] + edges[i].dist - tmp*edges[i].time)   //dist是距离，time是时间
//dist数组表示答案，即dist[f] + edges[i].dist - tmp*edges[i].time
//要初始化为-INF
{
    dist[v] = dist[f] + edges[i].dist - tmp*edges[i].time;
    if(!vis[v])
    {
        cishu[v] ++;
        vis[v] = 1;
        if(cishu[v] > n)
            return true;
        if(!q.empty() && dist[v] > dist[q.front()]) 
            q.push_front(v);
        else 
            q.push_back(v);
    }

如果非要说这是什么奇怪的东西（开始我并不知道它是这东西），那就叫它分数规划把……，做完后同学才说的，这一类问题统称为分数规划问题，如果你看懂了上面的部分，请自行完成下面例题：例题在这

这也是一个分数规划，不同的人理解不同，如果看不懂，请转下面链接：这里是链接~

这个链接详细介绍了01分数规划。

嗯，下面附上我的代码~、

[code]#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<deque>
#include<algorithm>
using namespace std;
typedef long long ll;
const int size = 30010;
struct Edge{int to; double dist,time;}edges[size];
int head[size],next[size],tot;
double map[233][233],map2[233][233];
int n;
void build(int f,int t,double d,double s)
{
    edges[++tot].to = t;
    edges[tot].dist = d;
    edges[tot].time = s;
    next[tot] = head[f];
    head[f] = tot;
}
int vis[size];
int cishu[size];
double dist[size];
void init()
{
    memset(vis,0,sizeof(vis));
    memset(cishu,0,sizeof(cishu));
}
deque <int> q;
bool spfa(double tmp)
{
    for(int i = 1;i <= n;i ++)  dist[i] = -1000000000.0;
    while(!q.empty())   q.pop_front();
    init();
    q.push_back(1);
    vis[1] = 1;
    dist[1] = 0.0;
    while(!q.empty())
    {
        int f = q.front();
        q.pop_front();
        vis[f] = 0;
        for(int i = head[f];i;i = next[i])
        {
            int v = edges[i].to;
//          printf("qwq %.3lf\n",dis);
            if(dist[v] < dist[f] + edges[i].dist - tmp*edges[i].time)
            {
                dist[v] = dist[f] + edges[i].dist - tmp*edges[i].time;
                if(!vis[v])
                {
                    cishu[v] ++;
                    vis[v] = 1;
                    if(cishu[v] > n)
                        return true;
                    if(!q.empty() && dist[v] > dist[q.front()]) 
                        q.push_front(v);
                    else 
                        q.push_back(v);
                }
//              printf("%d %d %lf\n",f,v,dis);
            }
        }
    }
    if(dist
 > 0)
        return true;
    return false;
}
int main()
{
    scanf("%d",&n);
    for(int i = 1;i <= n;i ++)
        for(int j = 1;j <= n;j ++)
            scanf("%lf",&map[i][j]);
    for(int i = 1;i <= n;i ++)
        for(int j = 1;j <= n;j ++)
            scanf("%lf",&map2[i][j]);
    for(int i = 1;i <= n;i ++)
        for(int j = 1;j <= n;j ++)
        {
            if(map[i][j] == 0.0 && map2[i][j] == 0.0) continue;
            build(i,j,map[i][j],map2[i][j]);
        }
/*  for(int i = 1;i <= tot;i ++)
    {
        printf("%d %.2lf %.2lf\n",edges[i].to,edges[i].dist,edges[i].time);
    }*/
    double l = 0,r = 100000000;
    int k = 0;
    while(k <= 100)
    {
        double mid = ((l + r) / (double)(2));
//      cout<<"qaq "<<l<<" "<<r<<" "<<mid<<endl;
        if(!spfa(mid))  r = mid;
        else    l = mid;
        k ++;
    }
    printf("%.3lf",l);
    return 0;
}
/*
3
0 8 7 
9 0 10 
5 7 0 
0 7 6 
6 0 6 
6 2 0
2.125

10
0 6 3 10 2 7 5 3 8 9 
6 0 4 6 6 3 4 6 5 2 
4 8 0 5 4 10 1 10 7 4 
4 7 5 0 7 6 6 1 4 9 
5 10 9 1 0 2 3 9 7 6 
1 1 7 2 1 0 7 8 5 8 
2 1 9 3 9 8 0 1 9 4 
2 2 1 7 10 5 6 0 1 1 
8 10 7 10 3 1 9 3 0 4 
10 7 7 9 9 2 2 10 5 0 
0 7 4 1 3 7 9 5 5 7 
7 0 7 10 7 6 5 3 1 6 
5 2 0 2 5 8 2 3 6 8 
3 6 7 0 2 4 3 7 9 2 
6 9 1 6 0 7 8 4 4 4 
8 2 7 10 2 0 8 3 6 10 
3 1 9 4 8 1 0 1 4 1 
1 5 9 8 6 5 6 0 5 1 
10 6 7 3 10 1 9 6 0 5 
3 5 7 8 7 9 7 8 6 0 
6.33
*/