二分答案+取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;
}