P4926 [1007]倍杀测量者

Posted 2021-01-16 garen-wang

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

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

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

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

加上正常数(T)的影响，第一个flag变为：(s[A] geq (k-T) imes 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
");
        return 0;
    }
    
    while(right - left > eps)
    {
        double mid = (left + right) / 2;
        if(check(mid)) right = mid;
        else left = mid;
    }
    printf("%.8lf
", left);
    return 0;
}