BZOJ ~ 1486 ~ [HNOI2009]最小圈（01分数规划 + dfs版spfa）

最新推荐文章于 2019-06-28 21:37:20 发布

原创最新推荐文章于 2019-06-28 21:37:20 发布 · 251 阅读

0 ·

CC 4.0 BY-SA版权

【最短路/差分约束】同时被 2 个专栏收录

40 篇文章

订阅专栏

【线性规划】

4 篇文章

订阅专栏

本文介绍了一种利用SPFA算法解决带负权边的最短路径问题的方法，通过建立边权减去答案的图模型，采用二分查找策略确定是否存在负环，从而找到最小的最短路径。代码示例展示了如何初始化图结构、添加边、执行SPFA算法及判断负环的存在。

题解

假设答案为ans， $ans=\frac{\sum {w[i]}}{k}$ 转化为 $\sum {w[i]}-ans*k=0$ 。所以对于每条边，建边w[i] - ans，根据是否有负环进行二分求解即可。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int INF = 0x3f3f3f3f;

struct Edge
{
    int from, to; double dist;       //起点,终点,距离
    Edge(int u, int v, double w):from(u), to(v), dist(w) {}
};

struct SPFA
{
    int n, m;                      //结点数,边数(包括反向弧)
    vector<Edge> edges;            //边表。edges[e]和edges[e^1]互为反向弧
    vector<int> G[MAXN];           //邻接表，G[i][j]表示结点i的第j条边在edges数组中的序号
    bool vis[MAXN];                //是否在走过
    double d[MAXN];                   //spfa
    int p[MAXN];                   //上一条弧
    bool flag;                     //有没有负环

    void init(int n)
    {
        flag = false;
        this->n = n;
        edges.clear();
        for (int i = 0; i <= n; i++) G[i].clear();
    }

    void AddEdge(int from, int to, double dist)
    {
        edges.push_back(Edge(from, to, dist));
        m = edges.size();
        G[from].push_back(m - 1);
    }


    void dfs(int u)//spfa
    {
        vis[u] = true;
        for (int i = 0; i < G[u].size(); i++)
        {
            Edge& e = edges[G[u][i]];
            if (d[e.to] > d[u] + e.dist)
            {
                if (vis[e.to]) { flag = 1; break ; }
                d[e.to] = d[u] + e.dist;
                p[e.to] = G[u][i];
                dfs(e.to);
            }
        }
        vis[u] = false;
    }

    bool spfa(int s)
    {
        //memset(d, INF, sizeof(d));
        memset(d, 0, sizeof(d));
        memset(vis, 0, sizeof(vis));
        //dfs(s);
        for (int i = 1; i <= n; i++)//起点不固定
        {
            dfs(i);
            if (flag) return false;//有负环
        }
        return true;//无负环
    }

}solve;

const double eps = 1e-10;
int n, m;
vector<Edge> G;

bool check(double x)
{
    solve.init(n);
    for (int i = 0; i < m; i++)
    {
        int u = G[i].from, v = G[i].to;
        double w = G[i].dist - x;
        solve.AddEdge(u, v, w);
    }
    return solve.spfa(0);
}
int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++)
    {
        int u, v; double w; scanf("%d%d%lf", &u, &v, &w);
        G.push_back(Edge(u, v, w));
    }
    double l = -1e7, r = 1e7;
    while (r-l > eps)
    {
        double mid = (l+r)/2;
        if (check(mid)) l = mid;
        else r = mid;
    }
    printf("%.8f\n", l);
    return 0;
}

/*
4 5
1 2 5
2 3 5
3 1 5
2 4 3
4 1 3
*/