P4926 [1007]倍杀测量者

二分答案+取log+差分约束+判正环

题目中A能\(k\)倍杀B的条件是：\(s[A] \geq k \times s[B]\)

第一个flag导致没人女装需要满足：\(s[A] \geq k \times s[B]\)。意思是A成功地\(k\)倍杀了B导致A不用女装。

第二个flag导致没人女装需要满足：\(s[B] < k \times s[A]\)即\(s[A] > \frac{s[B]}{k}\)。意思是B并不能成功地\(k\)倍杀A导致A不用女装。

加上正常数\(T\)的影响，第一个flag变为：\(s[A] \geq (k-T) \times s[B]\)，第二个flag变为：\(s[A] > \frac{s[B]}{k+T}\)

显然不等式满足的难易程度跟\(T\)是有关系的。\(T\)越大，女装就越不容易出现。

于是我们用一个近似的思想：令所有人不女装的最小的\(T\)约等于存在一个人女装的最大的\(T\)！因为答案允许误差所以可以进行近似。

然后就是最关键的一步：取log！

取log后，第一个flag变为：\(\log {s[A]} \geq \log{k}+\log{s[B]}\)，第二个flag变为：\(\log{s[A]} > \log{s[B]} - \log{(k+T)}\)。

大于和大于等于在这里可以等价，只要在后面随便加一个eps就可以了，而你的eps肯定比\(10^{-4}\)小得多嘛，所以直接可以忽略。

所以得到了类似于\(dist[v] >= dist[u]+weight\)的方式，我们就能想到差分约束，就可以建图跑最长路来解决这个问题了！

---

问题来了。如何建图？

• 对于flag1，我们由\(B\)向\(A\)连\(\log k\)的边。

• 对于flag2，我们也由\(B\)向\(A\)连\(-\log k\)的边。

• 对于已知的，我们从一个虚拟出来的起点连边表关系，从起点向已知点连\(\log c\)的边，反过来连\(-\log c\)的边即可。

• 最后为了串起整个图，我们从虚拟起点向所有点连权值为0的边。

可以发现，我们这样做，求出来的dist是自带log的。

如何判断答案合法？只需要求出这个方程有解就行了。

如何有解？没有正权环！

正环的判断方式跟负环的判断方式是一样的，这里就不讲了。

代码:

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<queue>
const int maxn = 1005;
const double INF = 1e18;
const double eps = 1e-10;
struct Edges
{
    int next, to, id;
    double weight;
} e[1000005];
int head[maxn], tot;
double dist[maxn];
bool vis[maxn];
int cnt[maxn];
double left = eps, right = INF, ans = -1;
int n, s, t;
int read()
{
    int ans = 0, s = 1;
    char ch = getchar();
    while(ch > '9' || ch < '0'){ if(ch == '-') s = -1; ch = getchar(); }
    while(ch >= '0' && ch <= '9') ans = ans * 10 + ch - '0', ch = getchar();
    return s * ans;
}
void link(int u, int v, double w, int i)
{
    e[++tot] = (Edges){head[u], v, i, w};
    head[u] = tot;
}
bool check(double T)
{
    std::queue<int> q;
    memset(vis, false, sizeof vis);
    for(int i = 0; i <= n + 3; i++) dist[i] = -INF;
    memset(cnt, 0, sizeof cnt);
    q.push(n + 1); dist[n + 1] = 0;
    vis[n + 1] = true; cnt[n + 1]++;
    while(!q.empty())
    {
        int u = q.front(); q.pop(); vis[u] = false;
        for(int i = head[u]; i; i = e[i].next)
        {
            int v = e[i].to;
            double weight;
            if(e[i].id == 1) weight = log2(e[i].weight - T);
            else if(e[i].id == 2) weight = -log2(e[i].weight + T);
            else weight = e[i].weight;
            if(dist[v] < dist[u] + weight)
            {
                dist[v] = dist[u] + weight;
                if(!vis[v])
                {
                    q.push(v); vis[v] = true;
                    if(++cnt[v] == n + 1) return false;
                }
            }
        }
    }
    return true;
}
int main()
{
    n = read(), s = read(), t = read();
    for(int i = 1; i <= s; i++)
    {
        int o = read(), a = read(), b = read(), k = read();
        if(o == 1)
        {
            link(b, a, k, 1);
            right = std::min(right, (double)k);
        }
        else if(o == 2)
        {
            link(b, a, k, 2);
        }
    }
    for(int i = 1; i <= t; i++)
    {
        int c = read(), x = read();
        link(0, c, log2(x), 4);
        link(c, 0, -log2(x), 4);
    }
    for(int i = 0; i <= n; i++) link(n + 1, i, 0, 0);
    
    if(check(0))
    {
        printf("-1\n");
        return 0;
    }
    
    while(right - left > eps)
    {
        double mid = (left + right) / 2;
        if(check(mid)) right = mid;
        else left = mid;
    }
    printf("%.8lf\n", left);
    return 0;
}

转载于:https://www.cnblogs.com/Garen-Wang/p/9873683.html