June 2018 Update
This commit is contained in:
Ingy döt Net
parent
ba8067c3b7
commit
22f33d4004
5278 changed files with 84726 additions and 14379 deletions
108
Task/Vogels-approximation-method/C/vogels-approximation-method.c
Normal file
108
Task/Vogels-approximation-method/C/vogels-approximation-method.c
Normal file
|
|
@ -0,0 +1,108 @@
|
|||
#include <stdio.h>
|
||||
#include <limits.h>
|
||||
|
||||
#define TRUE 1
|
||||
#define FALSE 0
|
||||
#define N_ROWS 4
|
||||
#define N_COLS 5
|
||||
|
||||
typedef int bool;
|
||||
|
||||
int supply[N_ROWS] = { 50, 60, 50, 50 };
|
||||
int demand[N_COLS] = { 30, 20, 70, 30, 60 };
|
||||
|
||||
int costs[N_ROWS][N_COLS] = {
|
||||
{ 16, 16, 13, 22, 17 },
|
||||
{ 14, 14, 13, 19, 15 },
|
||||
{ 19, 19, 20, 23, 50 },
|
||||
{ 50, 12, 50, 15, 11 }
|
||||
};
|
||||
|
||||
bool row_done[N_ROWS] = { FALSE };
|
||||
bool col_done[N_COLS] = { FALSE };
|
||||
|
||||
void diff(int j, int len, bool is_row, int res[3]) {
|
||||
int i, c, min1 = INT_MAX, min2 = min1, min_p = -1;
|
||||
for (i = 0; i < len; ++i) {
|
||||
if((is_row) ? col_done[i] : row_done[i]) continue;
|
||||
c = (is_row) ? costs[j][i] : costs[i][j];
|
||||
if (c < min1) {
|
||||
min2 = min1;
|
||||
min1 = c;
|
||||
min_p = i;
|
||||
}
|
||||
else if (c < min2) min2 = c;
|
||||
}
|
||||
res[0] = min2 - min1; res[1] = min1; res[2] = min_p;
|
||||
}
|
||||
|
||||
void max_penalty(int len1, int len2, bool is_row, int res[4]) {
|
||||
int i, pc = -1, pm = -1, mc = -1, md = INT_MIN;
|
||||
int res2[3];
|
||||
|
||||
for (i = 0; i < len1; ++i) {
|
||||
if((is_row) ? row_done[i] : col_done[i]) continue;
|
||||
diff(i, len2, is_row, res2);
|
||||
if (res2[0] > md) {
|
||||
md = res2[0]; /* max diff */
|
||||
pm = i; /* pos of max diff */
|
||||
mc = res2[1]; /* min cost */
|
||||
pc = res2[2]; /* pos of min cost */
|
||||
}
|
||||
}
|
||||
|
||||
if (is_row) {
|
||||
res[0] = pm; res[1] = pc;
|
||||
}
|
||||
else {
|
||||
res[0] = pc; res[1] = pm;
|
||||
}
|
||||
res[2] = mc; res[3] = md;
|
||||
}
|
||||
|
||||
void next_cell(int res[4]) {
|
||||
int i, res1[4], res2[4];
|
||||
max_penalty(N_ROWS, N_COLS, TRUE, res1);
|
||||
max_penalty(N_COLS, N_COLS, FALSE, res2);
|
||||
|
||||
if (res1[3] == res2[3]) {
|
||||
if (res1[2] < res2[2])
|
||||
for (i = 0; i < 4; ++i) res[i] = res1[i];
|
||||
else
|
||||
for (i = 0; i < 4; ++i) res[i] = res2[i];
|
||||
return;
|
||||
}
|
||||
if (res1[3] > res2[3])
|
||||
for (i = 0; i < 4; ++i) res[i] = res2[i];
|
||||
else
|
||||
for (i = 0; i < 4; ++i) res[i] = res1[i];
|
||||
}
|
||||
|
||||
int main() {
|
||||
int i, j, r, c, q, supply_left = 0, total_cost = 0, cell[4];
|
||||
int results[N_ROWS][N_COLS] = { 0 };
|
||||
|
||||
for (i = 0; i < N_ROWS; ++i) supply_left += supply[i];
|
||||
while (supply_left > 0) {
|
||||
next_cell(cell);
|
||||
r = cell[0];
|
||||
c = cell[1];
|
||||
q = (demand[c] <= supply[r]) ? demand[c] : supply[r];
|
||||
demand[c] -= q;
|
||||
if (!demand[c]) col_done[c] = TRUE;
|
||||
supply[r] -= q;
|
||||
if (!supply[r]) row_done[r] = TRUE;
|
||||
results[r][c] = q;
|
||||
supply_left -= q;
|
||||
total_cost += q * costs[r][c];
|
||||
}
|
||||
|
||||
printf(" A B C D E\n");
|
||||
for (i = 0; i < N_ROWS; ++i) {
|
||||
printf("%c", 'W' + i);
|
||||
for (j = 0; j < N_COLS; ++j) printf(" %2d", results[i][j]);
|
||||
printf("\n");
|
||||
}
|
||||
printf("\nTotal cost = %d\n", total_cost);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,139 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
)
|
||||
|
||||
var supply = []int{50, 60, 50, 50}
|
||||
var demand = []int{30, 20, 70, 30, 60}
|
||||
|
||||
var costs = make([][]int, 4)
|
||||
|
||||
var nRows = len(supply)
|
||||
var nCols = len(demand)
|
||||
|
||||
var rowDone = make([]bool, nRows)
|
||||
var colDone = make([]bool, nCols)
|
||||
var results = make([][]int, nRows)
|
||||
|
||||
func init() {
|
||||
costs[0] = []int{16, 16, 13, 22, 17}
|
||||
costs[1] = []int{14, 14, 13, 19, 15}
|
||||
costs[2] = []int{19, 19, 20, 23, 50}
|
||||
costs[3] = []int{50, 12, 50, 15, 11}
|
||||
|
||||
for i := 0; i < len(results); i++ {
|
||||
results[i] = make([]int, nCols)
|
||||
}
|
||||
}
|
||||
|
||||
func nextCell() []int {
|
||||
res1 := maxPenalty(nRows, nCols, true)
|
||||
res2 := maxPenalty(nCols, nRows, false)
|
||||
switch {
|
||||
case res1[3] == res2[3]:
|
||||
if res1[2] < res2[2] {
|
||||
return res1
|
||||
} else {
|
||||
return res2
|
||||
}
|
||||
case res1[3] > res2[3]:
|
||||
return res2
|
||||
default:
|
||||
return res1
|
||||
}
|
||||
}
|
||||
|
||||
func diff(j, l int, isRow bool) []int {
|
||||
min1 := math.MaxInt32
|
||||
min2 := min1
|
||||
minP := -1
|
||||
for i := 0; i < l; i++ {
|
||||
var done bool
|
||||
if isRow {
|
||||
done = colDone[i]
|
||||
} else {
|
||||
done = rowDone[i]
|
||||
}
|
||||
if done {
|
||||
continue
|
||||
}
|
||||
var c int
|
||||
if isRow {
|
||||
c = costs[j][i]
|
||||
} else {
|
||||
c = costs[i][j]
|
||||
}
|
||||
if c < min1 {
|
||||
min2, min1, minP = min1, c, i
|
||||
} else if c < min2 {
|
||||
min2 = c
|
||||
}
|
||||
}
|
||||
return []int{min2 - min1, min1, minP}
|
||||
}
|
||||
|
||||
func maxPenalty(len1, len2 int, isRow bool) []int {
|
||||
md := math.MinInt32
|
||||
pc, pm, mc := -1, -1, -1
|
||||
for i := 0; i < len1; i++ {
|
||||
var done bool
|
||||
if isRow {
|
||||
done = rowDone[i]
|
||||
} else {
|
||||
done = colDone[i]
|
||||
}
|
||||
if done {
|
||||
continue
|
||||
}
|
||||
res := diff(i, len2, isRow)
|
||||
if res[0] > md {
|
||||
md = res[0] // max diff
|
||||
pm = i // pos of max diff
|
||||
mc = res[1] // min cost
|
||||
pc = res[2] // pos of min cost
|
||||
}
|
||||
}
|
||||
if isRow {
|
||||
return []int{pm, pc, mc, md}
|
||||
}
|
||||
return []int{pc, pm, mc, md}
|
||||
}
|
||||
|
||||
func main() {
|
||||
supplyLeft := 0
|
||||
for i := 0; i < len(supply); i++ {
|
||||
supplyLeft += supply[i]
|
||||
}
|
||||
totalCost := 0
|
||||
for supplyLeft > 0 {
|
||||
cell := nextCell()
|
||||
r, c := cell[0], cell[1]
|
||||
q := demand[c]
|
||||
if q > supply[r] {
|
||||
q = supply[r]
|
||||
}
|
||||
demand[c] -= q
|
||||
if demand[c] == 0 {
|
||||
colDone[c] = true
|
||||
}
|
||||
supply[r] -= q
|
||||
if supply[r] == 0 {
|
||||
rowDone[r] = true
|
||||
}
|
||||
results[r][c] = q
|
||||
supplyLeft -= q
|
||||
totalCost += q * costs[r][c]
|
||||
}
|
||||
|
||||
fmt.Println(" A B C D E")
|
||||
for i, result := range results {
|
||||
fmt.Printf("%c", 'W' + i)
|
||||
for _, item := range result {
|
||||
fmt.Printf(" %2d", item)
|
||||
}
|
||||
fmt.Println()
|
||||
}
|
||||
fmt.Println("\nTotal cost =", totalCost)
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
var costs = :(
|
||||
W => :(A => 16, B => 16, C => 13, D => 22, E => 17),
|
||||
X => :(A => 14, B => 14, C => 13, D => 19, E => 15),
|
||||
Y => :(A => 19, B => 19, C => 20, D => 23, E => 50),
|
||||
Z => :(A => 50, B => 12, C => 50, D => 15, E => 11)
|
||||
)
|
||||
|
||||
var demand = :(A => 30, B => 20, C => 70, D => 30, E => 60)
|
||||
var supply = :(W => 50, X => 60, Y => 50, Z => 50)
|
||||
|
||||
var cols = demand.keys.sort
|
||||
var res = :(); costs.each {|k| res{k} = :() }
|
||||
var g = :(); supply.each {|x| g{x} = costs{x}.keys.sort_by{|g| costs{x}{g} }}
|
||||
|
||||
demand.each {|x| g{x} = costs.keys.sort_by{|g| costs{g}{x} }}
|
||||
|
||||
while (g) {
|
||||
var d = demand.collect {|x|
|
||||
[x, var z = costs{g{x}[0]}{x}, g{x}[1] ? costs{g{x}[1]}{x}-z : z]
|
||||
}
|
||||
|
||||
var s = supply.collect {|x|
|
||||
[x, var z = costs{x}{g{x}[0]}, g{x}[1] ? costs{x}{g{x}[1]}-z : z]
|
||||
}
|
||||
|
||||
with (d.max_by { .[2] }) { |dmax|
|
||||
d.grep! { .[2] == dmax[2] }.min_by! { .[1] }
|
||||
}
|
||||
|
||||
with (s.max_by { .[2] }) { |dmax|
|
||||
s.grep! { .[2] == dmax[2] }.min_by! { .[1] }
|
||||
}
|
||||
|
||||
var (t,f) = (d[2] == s[2] ? ((s[1], d[1])) : ((d[2], s[2])))
|
||||
(d,s) = (t > f ? ((d[0], g{d[0]}[0])) : ((g{s[0]}[0],s[0])))
|
||||
|
||||
var v = (supply{s} `min` demand{d})
|
||||
|
||||
res{s}{d} := 0 += v
|
||||
demand{d} -= v
|
||||
|
||||
if (demand{d} == 0) {
|
||||
supply.grep {|_,n| n != 0 }.each {|x| g{x}.delete(d) }
|
||||
g.delete(d)
|
||||
demand.delete(d)
|
||||
}
|
||||
|
||||
supply{s} -= v
|
||||
|
||||
if (supply{s} == 0) {
|
||||
demand.grep {|_,n| n != 0 }.each {|x| g{x}.delete(s) }
|
||||
g.delete(s)
|
||||
supply.delete(s)
|
||||
}
|
||||
}
|
||||
|
||||
say("\t", cols.join("\t"))
|
||||
|
||||
var cost = 0
|
||||
costs.keys.sort.each { |g|
|
||||
print(g, "\t")
|
||||
cols.each { |n|
|
||||
if (defined(var y = res{g}{n})) {
|
||||
print(y)
|
||||
cost += (y * costs{g}{n})
|
||||
}
|
||||
print("\t")
|
||||
}
|
||||
print("\n")
|
||||
}
|
||||
|
||||
say "\n\nTotal Cost = #{cost}"
|
||||
Loading…
Add table
Add a link
Reference in a new issue