Il mio primo pensiero è stato
select
<best solution>
from
<all possible combinations>
La parte "migliore soluzione" è definita nella domanda: la più piccola differenza tra i camion più caricati e meno caricati. L'altro bit, tutte le combinazioni, mi ha fatto riflettere.
Considera una situazione in cui abbiamo tre ordini A, B e C e tre camion. Le possibilità sono
Truck 1 Truck 2 Truck 3
------- ------- -------
A B C
A C B
B A C
B C A
C A B
C B A
AB C -
AB - C
C AB -
- AB C
C - AB
- C AB
AC B -
AC - B
B AC -
- AC B
B - AC
- B AC
BC A -
BC - A
A BC -
- BC A
A - BC
- A BC
ABC - -
- ABC -
- - ABC
Table A: all permutations.
Molti di questi sono simmetrici. Le prime sei file, ad esempio, differiscono solo in quale camion viene inserito ciascun ordine. Poiché i camion sono fungibili, questi arrangemets produrranno lo stesso risultato. Per ora lo ignorerò.
Esistono query note per la produzione di permutazioni e combinazioni. Tuttavia, questi produrranno accordi all'interno di un singolo secchio. Per questo problema ho bisogno di accordi su più secchi.
Osservando l'output della query standard "tutte le combinazioni"
;with Numbers as
(
select n = 1
union
select 2
union
select 3
)
select
a.n,
b.n,
c.n
from Numbers as a
cross join Numbers as b
cross join Numbers as c
order by 1, 2, 3;
n n n
--- --- ---
1 1 1
1 1 2
1 1 3
1 2 1
<snip>
3 2 3
3 3 1
3 3 2
3 3 3
Table B: cross join of three values.
Ho notato che i risultati formavano lo stesso schema della Tabella A. Facendo il salto congnativo di considerare ogni colonna come un Ordine 1 , i valori per dire quale camion conterrà quell'Ordine e una fila per essere una disposizione di Ordini all'interno dei camion. La query diventa quindi
select
Arrangement = ROW_NUMBER() over(order by (select null)),
First_order_goes_in = a.TruckNumber,
Second_order_goes_in = b.TruckNumber,
Third_order_goes_in = c.TruckNumber
from Trucks a -- aka Numbers in Table B
cross join Trucks b
cross join Trucks c
Arrangement First_order_goes_in Second_order_goes_in Third_order_goes_in
----------- ------------------- -------------------- -------------------
1 1 1 1
2 1 1 2
3 1 1 3
4 1 2 1
<snip>
Query C: Orders in trucks.
Espandendo questo per coprire i quattordici Ordini nei dati di esempio e semplificando i nomi otteniamo questo:
;with Trucks as
(
select *
from (values (1), (2), (3)) as T(TruckNumber)
)
select
arrangement = ROW_NUMBER() over(order by (select null)),
First = a.TruckNumber,
Second = b.TruckNumber,
Third = c.TruckNumber,
Fourth = d.TruckNumber,
Fifth = e.TruckNumber,
Sixth = f.TruckNumber,
Seventh = g.TruckNumber,
Eigth = h.TruckNumber,
Ninth = i.TruckNumber,
Tenth = j.TruckNumber,
Eleventh = k.TruckNumber,
Twelth = l.TruckNumber,
Thirteenth = m.TruckNumber,
Fourteenth = n.TruckNumber
into #Arrangements
from Trucks a
cross join Trucks b
cross join Trucks c
cross join Trucks d
cross join Trucks e
cross join Trucks f
cross join Trucks g
cross join Trucks h
cross join Trucks i
cross join Trucks j
cross join Trucks k
cross join Trucks l
cross join Trucks m
cross join Trucks n;
Query D: Orders spread over trucks.
Ho scelto di conservare i risultati intermedi in tabelle temporanee per comodità.
I passaggi successivi saranno molto più semplici se i dati vengono prima PIPATI.
select
Arrangement,
TruckNumber,
ItemNumber = case NewColumn
when 'First' then 1
when 'Second' then 2
when 'Third' then 3
when 'Fourth' then 4
when 'Fifth' then 5
when 'Sixth' then 6
when 'Seventh' then 7
when 'Eigth' then 8
when 'Ninth' then 9
when 'Tenth' then 10
when 'Eleventh' then 11
when 'Twelth' then 12
when 'Thirteenth' then 13
when 'Fourteenth' then 14
else -1
end
into #FilledTrucks
from #Arrangements
unpivot
(
TruckNumber
for NewColumn IN
(
First,
Second,
Third,
Fourth,
Fifth,
Sixth,
Seventh,
Eigth,
Ninth,
Tenth,
Eleventh,
Twelth,
Thirteenth,
Fourteenth
)
) as q;
Query E: Filled trucks, unpivoted.
I pesi possono essere introdotti unendosi alla tabella degli ordini.
select
ft.arrangement,
ft.TruckNumber,
TruckWeight = sum(i.Size)
into #TruckWeights
from #FilledTrucks as ft
inner join #Order as i
on i.OrderId = ft.ItemNumber
group by
ft.arrangement,
ft.TruckNumber;
Query F: truck weights
Ora è possibile rispondere alla domanda trovando gli accordi che hanno la differenza più piccola tra i camion più caricati e quelli meno caricati
select
Arrangement,
LightestTruck = MIN(TruckWeight),
HeaviestTruck = MAX(TruckWeight),
Delta = MAX(TruckWeight) - MIN(TruckWeight)
from #TruckWeights
group by
arrangement
order by
4 ASC;
Query G: most balanced arrangements
Discussione
Ci sono molti problemi con questo. Innanzitutto è un algoritmo a forza bruta. Il numero di file nelle tabelle di lavoro è esponenziale nel numero di camion e ordini. Il numero di righe in #Arrangements è (numero di camion) ^ (numero di ordini). Questo non si ridimensionerà bene.
Il secondo è che nelle query SQL è incorporato il numero di ordini. L'unico modo per aggirare questo è utilizzare SQL dinamico, che ha problemi propri. Se il numero di ordini è in migliaia, potrebbe arrivare un momento in cui l'SQL generato diventa troppo lungo.
Terzo è la ridondanza negli accordi. Questo gonfia le tabelle intermedie aumentando enormemente il tempo di esecuzione.
Quarto, molte file in #Arrangements lasciano vuoti uno o più camion. Questa non può essere la configurazione ottimale. Sarebbe facile filtrare queste righe al momento della creazione. Ho scelto di non farlo per mantenere il codice più semplice e mirato.
Sul lato positivo, questo gestisce pesi negativi, nel caso in cui la tua azienda dovesse mai iniziare a spedire baloons pieni di elio!
Pensieri
Se ci fosse un modo per popolare #FilledTrucks direttamente dall'elenco dei camion e degli ordini, penso che il peggio di queste preoccupazioni sarebbe gestibile. Purtroppo la mia immaginazione è inciampata su quell'ostacolo. La mia speranza è che un futuro collaboratore possa essere in grado di fornire ciò che mi ha eluso.
1 Dici che tutti gli articoli per un ordine devono essere sullo stesso camion. Ciò significa che l'atomo di assegnazione è l'Ordine, non il OrderDetail. Ho generato questi dai tuoi dati di test così:
select
OrderId,
Size = sum(OrderDetailSize)
into #Order
from #OrderDetail
group by OrderId;
Tuttavia, non fa alcuna differenza se etichettiamo gli articoli in questione "Ordine" o "Ordine dettagli", la soluzione rimane la stessa.