差分约束

最新推荐文章于 2024-08-05 15:41:47 发布
最新推荐文章于 2024-08-05 15:41:47 发布
阅读量384 收藏 7
点赞数 10
分类专栏： 日志 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73165551/article/details/136577223
版权
文章讲述了如何通过将不等式转化为边并构建图，利用超级源点和队列/栈来求解最短路或最长路，从而找到不等式组的可行解或确定最值。涉及AcWing题库中的实例和两种不同的实现方法：用队列和栈进行SPFA（SingleSourceShortestPath）算法。
摘要由CSDN通过智能技术生成

（1）求不等式组的可行解

        源点需满足的条件：从源点出发，一定可以到达所有的边

求最短路

        步骤：1.先将每个不等式xi<=xj + ck，转化成一条从xj走到xi，长度为ck的一条边

                   2.找一个超级源点，使得该源点一定可以遍历到所有的边

                   3.从该源点求一遍单源最短路

                        结果1：如果存在负环，则原不等式一定无解

                        结果2：如果没有负环，则dist[i]就是原不等式组的一个可行解

（2）如何求最大值或者最小值（这里的最值指的是每个变量的最值）

        问题：如何转化xi<=c，其中c是一个常数，这类的不等式

        方法：建立一个超级源点0，然后建立一条0->i，长度为c的边

        结论：如果求的是最小值，则应该求最长路；如果求的是最大值，则应该求最短路

 

1169. 糖果 - AcWing题库 

 

超时：用队列来写

import java.util.*;

//要求最小值应求最长路
public class Main{
    static int N = 100010, M = 3 * N;
    static int[] h = new int[N], e = new int[M], ne = new int[M], w = new int[M];
    static long[] dist = new long[N];
    static boolean[] st = new boolean[N];
    static int[] q = new int[N];
    static int[] cnt = new int[N];//边数
    static int n, m, idx;
    
    //邻接表存储
    public static void add(int a, int b, int c){
        e[idx] = b;
        w[idx] = c;
        ne[idx] = h[a];
        h[a] = idx ++;
    }
    
    public static boolean spfa(){
        Arrays.fill(dist, -0x3f3f3f3f);//求最长路，应更新为负无穷
        int hh = 0, tt = 1;
        q[0] = 0;
        dist[0] = 0;
        st[0] = true;
        
        while(hh != tt){
            int t = q[hh ++];//一开始写成循环队列
            if(hh == N) hh = 0;
            st[t] = false;
            
            for(int i = h[t]; i != -1; i = ne[i]){
                int j = e[i];
                if(dist[j] < dist[t] + w[i]){
                    dist[j] = dist[t] + w[i];
                    cnt[j] = cnt[t] + 1;
                    if(cnt[j] >= n + 1) return true;
                    if(!st[j]){
                        q[tt ++] = j;
                        if(tt == N) tt = 0;
                        st[j] = true;
                    }
                }
            }
        }
        return false;
    }
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        
        Arrays.fill(h, -1);//初始化队头
        
        while(m -- > 0){
            int x = sc.nextInt();
            int a = sc.nextInt();
            int b = sc.nextInt();
            
            if(x == 1){
                add(b, a, 0);
                add(a, b, 0);
            }else if(x == 2){
                add(a, b, 1);
            }else if(x == 3){
                add(b, a, 0);
            }else if(x == 4){
                add(b, a, 1);
            }else add(a, b, 0);
        }
        
        for(int i = 1; i <= n; i ++){
            add(0, i, 1);//超级源点到每个点连一条边
        }
        
        if(spfa()){
            System.out.print("-1");
        }else{
            long res = 0;
            for(int i = 1; i <= n; i ++){
                res += dist[i];
            }
            System.out.print(res);
        }
    }
}

 

正确解法：用栈来写 

import java.util.*;

//要求最小值应求最长路
public class Main{
    static int N = 100010, M = 3 * N;
    static int[] h = new int[N], e = new int[M], ne = new int[M], w = new int[M];
    static long[] dist = new long[N];
    static boolean[] st = new boolean[N];
    static int[] q = new int[N];
    static int[] cnt = new int[N];//边数
    static int n, m, idx;
    
    //邻接表存储
    public static void add(int a, int b, int c){
        e[idx] = b;
        w[idx] = c;
        ne[idx] = h[a];
        h[a] = idx ++;
    }
    
    public static boolean spfa(){
        Arrays.fill(dist, -0x3f3f3f3f);//求最长路，应更新为负无穷
        Stack<Integer> sk = new Stack<>();//栈
        sk.push(0);
        dist[0] = 0;
        st[0] = true;
        
        while(!sk.isEmpty()){
            int t = sk.pop();//一开始写成循环队列

            st[t] = false;
            
            for(int i = h[t]; i != -1; i = ne[i]){
                int j = e[i];
                if(dist[j] < dist[t] + w[i]){
                    dist[j] = dist[t] + w[i];
                    cnt[j] = cnt[t] + 1;
                    if(cnt[j] >= n + 1) return true;
                    if(!st[j]){
                        sk.push(j);
                        st[j] = true;
                    }
                }
            }
        }
        return false;
    }
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        
        Arrays.fill(h, -1);//初始化队头
        
        while(m -- > 0){
            int x = sc.nextInt();
            int a = sc.nextInt();
            int b = sc.nextInt();
            
            if(x == 1){
                add(b, a, 0);
                add(a, b, 0);
            }else if(x == 2){
                add(a, b, 1);
            }else if(x == 3){
                add(b, a, 0);
            }else if(x == 4){
                add(b, a, 1);
            }else add(a, b, 0);
        }
        
        for(int i = 1; i <= n; i ++){
            add(0, i, 1);//超级源点到每个点连一条边
        }
        
        if(spfa()){
            System.out.print("-1");
        }else{
            long res = 0;
            for(int i = 1; i <= n; i ++){
                res += dist[i];
            }
            System.out.print(res);
        }
    }
}

 正确解法：手写栈

import java.util.*;

//要求最小值应求最长路
public class Main{
    static int N = 100010, M = 3 * N;
    static int[] h = new int[N], e = new int[M], ne = new int[M], w = new int[M];
    static long[] dist = new long[N];
    static boolean[] st = new boolean[N];
    static int[] q = new int[N];
    static int[] cnt = new int[N];//边数
    static int n, m, idx;
    
    //邻接表存储
    public static void add(int a, int b, int c){
        e[idx] = b;
        w[idx] = c;
        ne[idx] = h[a];
        h[a] = idx ++;
    }
    
    public static boolean spfa(){
        Arrays.fill(dist, -0x3f3f3f3f);//求最长路，应更新为负无穷
        int hh = 0, tt = 1;
        q[0] = 0;
        dist[0] = 0;
        st[0] = true;
        
        while(hh != tt){
            int t = q[-- tt];//手写栈
            st[t] = false;
            
            for(int i = h[t]; i != -1; i = ne[i]){
                int j = e[i];
                if(dist[j] < dist[t] + w[i]){
                    dist[j] = dist[t] + w[i];
                    cnt[j] = cnt[t] + 1;
                    if(cnt[j] >= n + 1) return true;
                    if(!st[j]){
                        q[tt ++] = j;

                        st[j] = true;
                    }
                }
            }
        }
        return false;
    }
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        
        Arrays.fill(h, -1);//初始化队头
        
        while(m -- > 0){
            int x = sc.nextInt();
            int a = sc.nextInt();
            int b = sc.nextInt();
            
            if(x == 1){
                add(b, a, 0);
                add(a, b, 0);
            }else if(x == 2){
                add(a, b, 1);
            }else if(x == 3){
                add(b, a, 0);
            }else if(x == 4){
                add(b, a, 1);
            }else add(a, b, 0);
        }
        
        for(int i = 1; i <= n; i ++){
            add(0, i, 1);//超级源点到每个点连一条边
        }
        
        if(spfa()){
            System.out.print("-1");
        }else{
            long res = 0;
            for(int i = 1; i <= n; i ++){
                res += dist[i];
            }
            System.out.print(res);
        }
    }
}

 

362. 区间 - AcWing题库

 

import java.util.*;

public class Main{
    static int N = 50010, M = 3 * N + 10;
    static int[] h = new int[N], e = new int[M], ne = new int[M], w = new int[M];
    static int[] dist = new int[N];
    static boolean[] st = new boolean[N];
    static int n, idx;
    
    public static void add(int a, int b, int c){
        e[idx] = b;
        w[idx] = c;
        ne[idx] = h[a];
        h[a] = idx ++;
    }
    
    public static void spfa(){
        Arrays.fill(dist, -0x3f3f3f3f);//求最小值也就是求最长路，先初始化为负无穷
        Queue<Integer> q = new LinkedList<>();
        q.offer(0);
        dist[0] = 0;
        st[0] = true;
        
        while(!q.isEmpty()){
            int t = q.poll();
            st[t] = false;
            
            for(int i = h[t]; i != -1; i = ne[i]){
                int j = e[i];
                if(dist[j] < dist[t] + w[i]){
                    dist[j] = dist[t] + w[i];
                    if(!st[j]){
                        q.offer(j);
                        st[j] = true;
                    }
                }
            }
        }
    }
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        
        Arrays.fill(h, -1);
        
        for(int i = 1; i < N; i ++){
            add(i - 1, i, 0);
            add(i, i - 1, -1);
        }
        
        while(n -- > 0){
            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = sc.nextInt();
            a ++;//整体右移一位
            b ++;
            add(a - 1, b, c);
        }
        
        spfa();//数据保证一定有解，不用判断是否有负环
        
        System.out.print(dist[50001]);
    }
}

 

1170. 排队布局 - AcWing题库

import java.util.*;

public class Main{
    static int N = 1010, M = 21010, INF = 0x3f3f3f3f;
    static int[] h = new int[N], e = new int[M], ne = new int[M], w = new int[M];
    static int[] dist = new int[N];
    static int[] cnt = new int[N];
    static boolean[] st = new boolean[N];
    static int n, ml, md, idx;
    
    public static void temp(int a, int b){
        int temp = a;
        a = b;
        b = a;
    }
    
    public static void add(int a, int b, int c){
        e[idx] = b;
        w[idx] = c;
        ne[idx] = h[a];
        h[a] = idx ++;
    }
    
    public static boolean spfa(int size){
        Arrays.fill(dist, INF);
        Arrays.fill(cnt, 0);
        Arrays.fill(st, false);
        
        Queue<Integer> q = new LinkedList<>();
        for(int i = 1; i <= size; i ++){
            dist[i] = 0;
            q.offer(i);
            st[i] = true;
        }
        
        while(!q.isEmpty()){
            int t = q.poll();
            st[t] = false;
            
            for(int i = h[t]; i != -1; i = ne[i]){
                int j = e[i];
                if(dist[j] > dist[t] + w[i]){
                    dist[j] = dist[t] + w[i];
                    cnt[j] = cnt[t] + 1;
                    if(cnt[j] >= n) return true;
                    
                    if(!st[j]){
                        q.offer(j);
                        st[j] = true;
                    }
                }
            }
        }
        return false;
    }
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        Arrays.fill(h, -1);
        
        n = sc.nextInt();
        ml = sc.nextInt();
        md = sc.nextInt();
        
        for(int i = 1; i < n; i ++){
            add(i + 1, i, 0);
        }
        
        while(ml -- > 0){
            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = sc.nextInt();
            if(b < a) temp(a, b);
            add(a, b, c);
        }
        
        while(md -- > 0){
            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = sc.nextInt();
            if(b < a) temp(b, a);
            add(b, a, -c);
        }
        
        if(spfa(n)) System.out.print("-1");//判断是否有负环
        else{
            spfa(1);
            if(dist[n] == INF) System.out.print("-2");
            else System.out.print(dist[n]);
        }
    }
}

 

393. 雇佣收银员 - AcWing题库

 

import java.util.*;

public class Main{
    static int N = 30, M = 110;
    static int[] h = new int[N], e = new int[M], ne = new int[M], w = new int[M];
    static int[] dist = new int[N];
    static int[] cnt = new int[N];
    static int[] r = new int[N];//最小需求量
    static int[] nums = new int[N];//申请数
    static boolean[] st = new boolean[N];
    static int n, idx;
    
    //邻接表存储
    public static void add(int a, int b, int c){
        e[idx] = b;
        w[idx] = c;
        ne[idx] = h[a];
        h[a] = idx ++;
    }
    
    //建图
    public static void build(int c){
        Arrays.fill(h, -1);//多组数据，每次都要进行初始化
        idx = 0;
        
        add(0, 24, c);
        add(24, 0, -c);
        
        for(int i = 1; i <= 24; i ++){
            add(i - 1, i, 0);
            add(i, i - 1, - nums[i]);
        }
        
        for(int i = 1; i <= 7; i ++){
            add(i + 16, i, r[i] - c);
        }
        
        for(int i = 8; i <= 24; i ++){
            add(i - 8, i, r[i]);
        }
    }
    
    public static boolean spfa(int c){
        build(c);
        
        Arrays.fill(dist, -0x3f3f3f3f);
        Arrays.fill(st, false);
        Arrays.fill(cnt, 0);
        
        Queue<Integer> q = new LinkedList<>();
        dist[0] = 0;
        st[0] = true;
        q.offer(0);
        
        while(!q.isEmpty()){
            int t = q.poll();
            st[t] = false;
            
            for(int i = h[t]; i != -1; i = ne[i]){
                int j = e[i];
                if(dist[j] < dist[t] + w[i]){
                    dist[j] = dist[t] + w[i];
                    cnt[j] = cnt[t] + 1;
                    if(cnt[j] >= 25) return false;
                    
                    if(!st[j]){
                        q.offer(j);
                        st[j] = true;
                    }
                }
            }
        }
        return true;
    }
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
        while(T -- > 0){
            for(int i = 1; i <= 24; i ++){
                r[i] = sc.nextInt();
            }
            
            Arrays.fill(nums, 0);
            n = sc.nextInt();
            for(int i = 0; i < n; i ++){
                int t = sc.nextInt();
                nums[t + 1] ++;
            }
            
            boolean flag = false;
            for(int i = 0; i <= 1000; i ++){//枚举所有s24可能的值
                if(spfa(i)){
                    System.out.println(i);
                    flag = true;//只要有一个可以就行
                    break;
                }
            }
            
            if(!flag) System.out.println("No Solution");
        }
    }
}

 

m0_73165551
关注
  • 10
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cadence16.6差分约束规则
09-19
cadence16.6差分约束规则 cadence16.6差分约束规则是指在 Cadence 16.6 版本中的差分约束设置规则。差分约束规则是指在PCB设计中对差分对的约束设置，旨在确保差分对的信号传输质量和可靠性。 Cadence 16.6 版本中...
差分约束系统
05-22
### 差分约束系统及其应用解析 #### 一、差分约束系统概念 差分约束系统是一种用于解决特定类型线性规划问题的数学工具。它主要处理的是关于一组变量的特殊不等式组，其中每个不等式都描述了两个变量之间的关系。...
差分约束SPFA
都凉儿的博客
02-14 508
Bellman-Ford 算法和 Dijkstra 算法同为解决单源最短路径的算法 Bellman-Ford 算法采用DP思想，时间复杂度为 O(V*E)，Dijkstra 算法采用贪心策略，普通实现的时间复杂度为 O(V2)其中 V 为顶点数量，E 为边的数量。 Dijkstra有一个特点：一旦一个顶点添加到S中后，其最短路径长度不再改变，所以不适合含有非负权值的带权图求单源最短路径 对于带权有向图 G = (V, E)，Dijkstra 算法要求图 G 中边的权值均为非负，而 Bellman-Ford
差分约束 详解
蒟蒻柴犬首相的博客
11-06 951
引子差分约束，是一个建模的思想。也就是把一些代数上的约束关系建模成图论的相关问题。差分约束的一些题目往往对思维上建模能力的要求比较高，而对具体算法的考察却比较低，所以做差分约束的题目，一般建模之后会给人一种敲板子的那种流畅和虐题的感觉哈哈哈哈。 我们从最简单的不等式说起。（不等式的关系就是代数式之间的大小约束关系） 已知 x1−x0≤2x_1-x_0\leq2 x2−x0≤7x_2-x_0\
差分约束总结
weixin_45729807的博客
10-05 2463
差分约束概念 如果一个系统由nnn个变量和mmm个约束条件组成，形成mmm个形如xi−xj≤kx_i - x_j ≤ kxi​−xj​≤k的不等式(i,j∈[1,n],k为常数),则称其为差分约束系统。亦即，差分约束系统是求解关于一组变量的特殊不等式组的方法。 求解差分约束系统，可以转化成图论的单源最短路径（或最长路径）问题。 观察xi−xj<=ckx_i - x_j <= c_kxi​−xj​<=ck​，会发现它类似最短路中的三角不等式dis[v]<=dis[u]+w[u,v]di
差分约束 C++ 算法&例题
Brilliant_Sky的博客
05-12 738
差分约束的图论解决方法
浅谈差分约束系统
Caristra的博客
08-21 1862
差分约束系统 简介： 背景是给你若干个不等式，形如xi−xj≤bxi−xj≤bxi-xj \le b，需要你判断x的解的存在性或是最优解。 而差分约束系统即为这个问题转化为一个图论问题，进而跑最短路来判环或求最值距离（最优解）。 这里转化的原理是三角不等式，即d(v)−d(u)≤cost(u,v)d(v)−d(u)≤cost(u,v)d(v)-d(u) \le cost(u,v)，可以建...
差分约束系统学习笔记
终有绿洲摇曳在沙漠
05-08 5060
差分约束系统 一、预备知识 最短路基本性质 #define inf 0x3fffffff #define M 1005 //最大点数 struct edge{ int v, w, next; }e[10005]; //估计好有多少条边 int pre[M], cnt, dist[M], n; bool inq[M]; //注意初始化 void init (...
差分约束算法
wanglianda2007的博客
01-05 1137
差分约束理论原理。
【图论】差分约束算法详解
qq_49688477的博客
07-05 2281
详解差分约束算法解题过程中的注意事项
差分约束系统例题详解[总结].pdf
10-12
差分约束系统(Differential Constraint System, 简称DCS)是一种在算法和数学规划中常见的模型，用于处理一系列变量间的关系。在这个例题中，我们面对的是一个序列的子序列约束问题，需要找到满足所有约束条件的序列...
差分约束系统题解1
08-03
【差分约束系统】是一种用于解决一系列线性不等式约束问题的模型，常用于最优化问题，如求解最短路径、最长路径或者判断是否存在满足条件的解。在这个模型中，我们通常需要将问题转化为寻找图中的最短路径或最长路径...
(leetcode学习)50. Pow(x, n)
最新发布
m0_54888411的博客
08-05 205
快速幂，第一次写的时候用 n%2==1，这样不能处理负数的问题。
5力扣：最长回文子串
m0_75015083的博客
08-02 254
从后到前遍历是为了让每一次遍历时所需用到的子串提前被计算过。
算法第十七天：leetcode242.有效的字母异位词
m0_75068978的博客
08-02 484
如下表所示，您可以直接复制下面网址进入力扣学习，在观看下面的内容之前您一定要先做一遍哦，以便让你印象更加深刻！
代码随想录算法训练营第三十三天 | 动态规划理论基础、509. 斐波那契数、70. 爬楼梯、746. 使用最小花费爬楼梯
weixin_43581681的博客
08-01 291
1. 动态规划基础；2. 背包问题；3. 打家劫舍；4. 股票问题；5. 子序列问题。1. 确定 dp[ i ] 数组及下标含义；2. 确定递推公式；3.确定dp数组如何初始化；4. 确定遍历顺序（背包问题中很重要）；5. 举例推导dp数组。
TypeScript 及算法准备
qq_25416827的博客
08-02 828
typescript复制代码function mergeSortedArrays(arr1: number[], arr2: number[]): number[] {typescript复制代码function flattenArray(arr: any[]): any[] {typescript复制代码function flattenArray(arr: any[]): any[] {typescript复制代码function flattenArray(arr: any[]): any[] {
差分专题的练习
wniuniu_的博客
08-05 169
神经，树状数组做多了一开始还想着用树状数组来查询差分数组，但是我们要进行所有元素的查询，直接过一遍就好啦。就好像这个题目，我们可以小试牛刀直接进行树状数组。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值