Difference constraint: each row of Linear Programming matrix A contains A 1 and A-1, and other elements are 0. therefore, the constraint given by Ax <= B is m sets of difference constraints, including n unknown elements. Each constraint is an inequality:
Xj-xi <= bk
Where 1 <= I, j <= n, I <= k <= m
Solution: regard n unknown elements as the vertices of n Directed Graphs. xj-xi <= bk indicates a directed line segment from vertex j to vertex I with a length of bk. Add another v0 vertex, which is a directed line segment from v0 to other vertices with a length of 0. (For example)
It can be proved that xi = β (v0, vi) (β (v0, vi) is the shortest path length from vertex 0 to vertex I ). Therefore, you can use Bellman_Ford to calculate the single-source shortest path (the Dijkstra algorithm cannot be used because the length of a directed line segment can be negative)
// Differential constraint system. cpp: Defines the entry point for the console application.
//
# Include "stdafx. h"
# Include <iostream>
# Deprecision MAX 100
# Define Infinity 65535
Using namespace std;
// Tail node Structure of the edge
Struct edgeNode
{
Int no; // The number of the end of the edge
Int weight; // Edge weight
Struct edgeNode * next; // next
};
// Node Structure
Struct vexNode
{
Char info; // node name
Struct edgeNode * link; // endpoint connected to it
};
// Store node Information
VexNode adjlist [MAX];
// Precursor Node
Int parent [MAX];
//// The cost of the shortest path from the source point to the node j
Int lowcost [MAX];
// Difference matrix
Int a [MAX] [MAX];
// Shard set
Int w [MAX];
// Create an adjacent table store based on the difference matrix
// Adjlist is the node set, and parent [j] is the precursor node of the shortest path from node 0 to node j.
// Lowcost [j] is the cost of the shortest path from 0 nodes to node j.
// W is the input difference Constraint
// M and n are the number of rows and columns of the difference matrix respectively.
Void createGraph (vexNode * adjlist, int * parent, int * lowcost, int * w, int m, int n)
{
Int I, j;
// Initialization, node vi name is char (a + I)
For (I = 0; I <= n; I ++)
{
Adjlist [I]. info = (char) ('A' + I );
Adjlist [I]. link = NULL;
Lowcost [I] = Infinity;
Parent [I] = I;
}
Int col1, col2;
Col1 = col2 = 0;
EdgeNode * p1;
For (I = 1; I <= m; I ++)
{
For (j = 1; j <= n; j ++)
{
If (a [I] [j] =-1)
Col1 = j;
Else if (a [I] [j] = 1)
Col2 = j;
}
P1 = (edgeNode *) malloc (sizeof (edgeNode ));
P1-> no = col2;
P1-> weight = w [I];
P1-> next = adjlist [col1]. link;
Adjlist [col1]. link = p1;
}
For (I = 1; I <= n; I ++)
{
P1 = (edgeNode *) malloc (sizeof (edgeNode ));
P1-> no = I;
P1-> weight = 0;
P1-> next = adjlist [0]. link;
Adjlist [0]. link = p1;
}
Lowcost [0] = 0;
}
// Find the shortest path from v0 to each node
Bool Bellman_Ford (vexNode * adjlist, int * lowcost, int * parent, const int n)
{
Int I, j;
For (j = 0; j <n; j ++)
{
For (I = 0; I <= n; I ++)
{
EdgeNode * p1 = adjlist [I]. link;
While (p1! = NULL)
{
If (lowcost [I] + p1-> weight <lowcost [p1-> no])
{
Lowcost [p1-> no] = lowcost [I] + p1-> weight;
Parent [p1-> no] = I;
}
P1 = p1-> next;
}
}
}
// Check whether there is a negative Loop
For (I = 1; I <= n; I ++)
{
EdgeNode * p2 = adjlist [I]. link;
While (p2! = NULL)
{
If (lowcost [p2-> no]> lowcost [I] + p2-> weight)
Return false;
P2 = p2-> next;
}
}
Return true;
}
Int _ tmain (int argc, _ TCHAR * argv [])
{
Int cases;
Cout <"Enter the number of cases :";
Cin> cases;
While (cases --)
{
Int I, j;
Int n, m;
Cout <"Enter the number of rows (m) and number of columns (n) of the difference matrix ):";
Cin> m> n;
Cout <"Enter the difference matrix:" <endl;
For (I = 1; I <= m; I ++)
For (j = 1; j <= n; j ++)
Cin> a [I] [j];
Cout <"Enter the consumer set:" <endl;
For (I = 1; I <= m; I ++)
Cin> w [I];
// Create an adjacent table
CreateGraph (adjlist, parent, lowcost, w, m, n );
// Output the adjacent table
/*
For (I = 0; I <= n; I ++)
{
EdgeNode * p = adjlist [I]. link;
Cout <I <":";
While (p! = NULL)
{
Cout <"(" <p-> no <"," <p-> weight <")";
P = p-> next;
}
Cout <endl;
}
*/
// Call the Bellman-Ford Algorithm
Bool flag = Bellman_Ford (adjlist, lowcost, parent, n );
If (! Flag)
Cout <"no solution" <endl;
Else
{
// Output solution set
Cout <"one of the solutions sets is (this solution set is added with an arbitrary constant d, which is also its solution set):" <endl;
For (I = 1; I <= n; I ++)
Cout <"x" <I <"=" <lowcost [I] <endl;
}
}
System ("pause ");
Return 0;
}
--------------------------------------------------- Program test ---------------------------------------------------
Enter the number of cases: 1
Enter the number of rows (m) and number of columns (n) of the difference matrix: 8 5
Enter the difference matrix:
1-1 0 0 0
1 0 0 0-1
0 1 0 0-1
-1 0 1 0 0
-1 0 0 1 0
0 0-1 1 0
0 0-1 0 1
0 0 0-1 1
Enter the sequence set:
0-1 1 5 4-1-3-3
One of the solutions sets is (this solution set is added with an arbitrary constant d, which is also its solution set ):
X1 =-5
X2 =-3
X3 = 0
X4 =-1
X5 =-4
Press any key to continue ..
Author heyongluoyao8