JavaScript (ES6) 126 130 104 115 156 162 194
Depois de todos os comentários e casos de teste na resposta do @ CarpetPython, voltemos ao meu primeiro algoritmo. Infelizmente, a solução inteligente não funciona. A implementação encurtou um pouco, ainda tenta todas as soluções possíveis, calcula a distância ao quadrado e mantém o mínimo.
Editar Para cada elemento de saída com peso w, 'todos' os valores possíveis são apenas 2: trunc (w * s) e trunc (w * s) +1, portanto, existem apenas (2 ** elemensts) soluções possíveis para tentar.
Q=(s,w)=>
(n=>{
for(i=0;
r=q=s,(y=i++)<1<<w.length;
q|r>n||(n=r,o=t))
t=w.map(w=>(f=w*s,q-=d=0|f+(y&1),y/=2,f-=d,r+=f*f,d));
})()||o
Teste no console Firefox / FireBug
;[[ 1, [0.4, 0.3, 0.3] ]
, [ 3, [0, 1, 0] ]
, [ 4, [0.3, 0.4, 0.3] ]
, [ 5, [0.3, 0.4, 0.3] ]
, [ 21, [0.3, 0.2, 0.5] ]
, [ 5, [0.1, 0.2, 0.3, 0.4] ]
, [ 4, [0.11, 0.3, 0.59] ]
, [ 10, [0.47, 0.47, 0.06] ]
, [ 10, [0.43, 0.43, 0.14] ]
, [ 11, [0.43, 0.43, 0.14] ]]
.forEach(v=>console.log(v[0],v[1],Q(v[0],v[1])))
Resultado
1 [0.4, 0.3, 0.3] [1, 0, 0]
3 [0, 1, 0] [0, 3, 0]
4 [0.3, 0.4, 0.3] [1, 2, 1]
5 [0.3, 0.4, 0.3] [1, 2, 2]
21 [0.3, 0.2, 0.5] [6, 4, 11]
5 [0.1, 0.2, 0.3, 0.4] [0, 1, 2, 2]
4 [0.11, 0.3, 0.59] [1, 1, 2]
10 [0.47, 0.47, 0.06] [5, 5, 0]
10 [0.43, 0.43, 0.14] [4, 4, 2]
11 [0.43, 0.43, 0.14] [5, 5, 1]
Essa é uma solução mais inteligente. Passagem única na matriz de peso.
Para cada passagem, encontro o valor máximo atual em w. Eu mudo esse valor no lugar com o valor inteiro ponderado (arredondado para cima), portanto, se s == 21 ew = 0,4, obtemos 0,5 * 21 -> 10,5 -> 11. Eu armazeno esse valor negado, por isso não pode seja encontrado como max no próximo loop. Então, reduzo a soma total de acordo (s = s-11) e também reduzo o total de pesos na variável f.
O loop termina quando não há um máximo acima de 0 a ser encontrado (todos os valores! = 0 foram gerenciados).
Por fim, retorno os valores alterados para positivo novamente.
Aviso: este código modifica a matriz de pesos no local, portanto deve ser chamada com uma cópia da matriz original
F=(s,w)=>
(f=>{
for(;j=w.indexOf(z=Math.max(...w)),z>0;f-=z)
s+=w[j]=-Math.ceil(z*s/f);
})(1)||w.map(x=>0-x)
Minha primeira tentativa
Não é uma solução inteligente. Para cada resultado possível, avalia a diferença e mantém o mínimo.
F=(s,w,t=w.map(_=>0),n=NaN)=>
(p=>{
for(;p<w.length;)
++t[p]>s?t[p++]=0
:t.map(b=>r+=b,r=p=0)&&r-s||
t.map((b,i)=>r+=(z=s*w[i]-b)*z)&&r>n||(n=r,o=[...t])
})(0)||o
Ungolfed And Explained
F=(s, w) =>
{
var t=w.map(_ => 0), // 0 filled array, same size as w
n=NaN, // initial minumum NaN, as "NaN > value" is false for any value
p, r
// For loop enumerating from [1,0,0,...0] to [s,s,s...s]
for(p=0; p<w.length;)
{
++t[p]; // increment current cell
if (t[p] > s)
{
// overflow, restart at 0 and point to next cell
t[p] = 0;
++p;
}
else
{
// increment ok, current cell is the firts one
p = 0;
r = 0;
t.map(b => r += b) // evaluate the cells sum (must be s)
if (r==s)
{
// if sum of cells is s
// evaluate the total squared distance (always offset by s, that does not matter)
t.map((b,i) => r += (z=s*w[i]-b)*z)
if (!(r > n))
{
// if less than current mininum, keep this result
n=r
o=[...t] // copy of t goes in o
}
}
}
}
return o
}