算法竞赛进阶指南 0x65 负环与差分约数

这里与最短路密切相关

可以使用spfa，利用spfa的原理（cnt数组），如果发现一个点是通过了超过n-1条边更新而来，那么就说明存在负环

AcWing361. 观光奶牛

给定一张 L 个点、P 条边的有向图，每个点都有一个权值 f[i]，每条边都有一个权值 t[i]。

求图中的一个环，使“环上各点的权值之和”除以“环上各边的权值之和”最大。

输出这个最大值。 注意 ：数据保证至少存在一个环。

输入格式

第一行包含两个整数 L 和 P。

接下来 L 行每行一个整数，表示 f[i]。

再接下来 P 行，每行三个整数 a，b，t[i]，表示点 a 和 b 之间存在一条边，边的权值为 t[i]。

输出格式

输出一个数表示结果，保留两位小数。

数据范围

2≤L≤1000,

2≤P≤5000,

1≤f[i],t[i]≤1000

输入样例：

5 7
30
10
10
5
10
1 2 3
2 3 2
3 4 5
3 5 2
4 5 5
5 1 3
5 2 2
1
2
3
4
5
6
7
8
9
10
11
12
13

输出样例：

6.00
1

注意：由于是分数的最优化问题，所以我想到了0/1规划。

#include 
using namespace std;
#define N 1005
#define M 5005
int head[N], tot, ver[M], nxt[M], from[M], edge[M];
int head2[N], tot2, ver2[M], nxt2[M];
double edge2[M];
int n, m;
int a[N];//存放点的权值
const double eps = 1e-5;
int cnt[N];//通过这一个数组配合spfa进行求有没有负环
bool v[N];
queue<int >q;
double d[N];//注意取值

inline void add(int x, int y, int z)
{
    ver[++tot] = y;
    edge[tot] = z;
    from[tot] = x;
    nxt[tot] = head[x];
    head[x] = tot;
}
inline void add2(int x, int y, double z)
{
    ver2[++tot2] = y;
    edge2[tot2] = z;
    nxt2[tot2] = head2[x];;
    head2[x] = tot2;
}
bool judge(double mid)
{
    for(int i = 1; i <= n; i++) head2[i] = 0;
    tot2 = 0;
    for(int i = 1; i <= n; i++) cnt[i] = 0;
    for(int i = 1; i <= tot; i++)
    {
        add2(from[i], ver[i], mid*edge[i] - a[from[i]]);
    }
    for(int i = 1; i <= n; i++) d[i] = 1e13;
    d[1] = 0;
    v[1] = true;
    q.push(1);
    while(q.size())
    {
        int x = q.front();
        q.pop();
        v[x] = false;
        for(int i = head2[x]; i; i = nxt2[i])
        {
            int y = ver2[i];
            double z = edge2[i];
            if(d[y] > d[x] + z)
            {
                d[y] = d[x] + z;
                cnt[y] = cnt[x] + 1;
                if(cnt[y] >= n) return true;
                if(!v[y])
                {
                    v[y] = true;
                    q.push(y);
                }
            }
        }
    }
    return false;   
}
int main()
{
    //tot = 1;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++) scanf("%d", a+i);
    for(int i = 1; i <= m; i++)
    {
        int x, y, z;
        scanf("%d%d%d", &x, &y, &z);
        add(x, y, z);
    }
    double l = 0, r = 1000;
    while(abs(l-r) > eps)
    {
        double mid = (l + r) / 2;
        if(judge(mid)) l = mid;
        else r = mid;
    }
    printf("%.2lf", l);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

差分约束系统

由于差分的形式与图论中长得比较像，所以进行等价为最短路（bellman-ford中的三角不等式）

AcWing362. 区间

给定 n 个区间 [ai,bi**]** 和 n 个整数 ci。

你需要构造一个整数集合 Z，使得 ∀i∈[1,n]，Z 中满足 ai≤x≤bi 的整数 x 不少于 ci 个。

求这样的整数集合 Z 最少包含多少个数。

输入格式

第一行包含整数 n。

接下来 n 行，每行包含三个整数 ai**,bi**,ci。

输出格式

输出一个整数表示结果。

数据范围

1≤n≤50000,

0≤ai**,bi≤50000**,

1≤ci≤bi−ai**+**1

输入样例：

5
3 7 3
8 10 3
6 8 1
1 3 1
10 11 1
1
2
3
4
5
6

输出样例：

6
1

#include 
using namespace std;
#define N 50005
int s[N];
int head[N], tot, ver[3*N], nxt[3*N], edge[3*N];
int d[N];
bool v[N];
queue<int >q;
inline int num(int x)
{
    return x == -1?50001:x;   
}

inline void add(int x, int y, int z)
{
    ver[++tot] = y;
    edge[tot] = z;
    nxt[tot] = head[num(x)];
    head[num(x)] = tot;
}

void spfa()
{
    memset(d, 0xcf, sizeof(d));//尽量往小，让约束之后的值尽可能小
    d[num(-1)] = 0;
    v[num(-1)] = true;
    q.push(-1);
    while(q.size())
    {
        int x = q.front();
        q.pop();
        v[num(x)] = false;
        for(int i = head[num(x)]; i; i = nxt[i])
        {
            int y = ver[i], z = edge[i];
            if(d[num(y)] < d[num(x)]+z)
            {
                d[num(y)] = d[num(x)]+z;
                if(!v[num(y)])
                {
                    v[num(y)] = true;
                    q.push(y);
                }
            }
        }
    }
}

int main()
{
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a-1, b, c);
    }
    for(int i = 0; i <= 50000; i++)
    {
        add(i-1, i, 0);
        add(i, i-1, -1);
    }
    spfa();
    cout << d[50000] << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67