抱歉，我希望这与stackoverflow的主题相差无几。我有一个我想证明是正确的算法，或者找到一个反例，如果不是。
这是问题所在。我有一组严格正的权重：w1，w2，w3，... wn。
我有一个长度为m的布尔矢量，其中m> n。向量必须具有n个真值和m-n个假值。
例如，如果m = 5且n = 3，则v可以是（1,1,0,1,0）
接下来，我们有将v向量映射到自然数的函数：
int f(vector v) {
sum=0, wIndex=1, pow=1;
// v must have exactly n ones
for(int index=0;index<m;index++) {
if(v[index]==1)
sum=sum + w[wIndex++]*pow;
pow=pow*2;
}
return sum;
}
其中w [wIndex]给出权重w1，w2，w3 ...... wn。
EXAMPLE:
suppose v=(0, 1, 1, 0, 1) and w1=3, w2=4, w3=6
f(v) would be 3*2 + 4*4 + 6*16 = 118.
下一步考虑v的圆周旋转，例如，如果v =（0,1,1,0,1），则旋转（v，3）v向左旋转3个位置，或（0,1,0） ，1,1）。圆形旋转保留m（长度）和n（个数）。
我们将minF（v）定义为v的所有可能循环旋转的最小f值。它可以如下实现：
int minF(vector v) {
int min=f(v);
for(int amount=1; amount<m; amount++) {
if(f(rotate(v, amount))<min)
min=f(rotate(v, amount));
}
return min;
}
其中，旋转（v，k）循环旋转v个位置
EXAMPLE:
suppose v=(0, 1, 1, 0, 1) and all weights are 3
The rotation that has the minimum f is v=(1, 1, 0, 1, 0),
Thus minF(v)=3 + 6 + 24 = 33
现在我们终于得到了这个问题：
证明或反证最佳（m，n）产生向量，使得对于所有可能的向量w，minF（最佳（m，n））> = minF（w），长度为m，其中n为1，其中最佳定义如下：
vector optimum(int m, int n) {
vector opt=new vector[m];
int ones=n, zeros=m-n, balance=0;
for(int index=0; index<m; index++)
if(balance<ones) {
opt[index]=1;
balance=balance + zeros;
}
else {
opt[index]=0;
balance=balance - ones;
}
}
return opt;
}
最后，这里有一些优化运行的例子：
optimum(10, 1) --> 1000000000
optimum(10, 2) --> 1000010000
optimum(10, 3) --> 1001001000
optimum(10, 4) --> 1010010100
optimum(10, 5) --> 1010101010
optimum(10, 6) --> 1101011010
optimum(10, 7) --> 1110110110
optimum(10, 8) --> 1111011110
optimum(10, 9) --> 1111111110
最佳实质上是尽可能地扩散那些。
我做了很多实证测试，这个算法似乎总是有效，但我真的需要证明它是正确的。
PS 如果你解决这个问题，我会给你买披萨。
答案 0 :(得分：1)
我发现这意外有趣......这是我昨天2个小时后得到的。它不是一个证明，但它是一个推理的框架 - 现在它足以用于n = 2的一点按摩的证明，我想我可以将它构建到n＆gt; 2但还没到那里。唉，我有一份日常工作，所以我不得不放下一点。
希望它有所帮助 - 对不起，如果没有。
重量不可旋转。 m = 9，n = 3的最大模式总是000000111，最小模式总是111000000.这一点的泛化是微不足道的。
Consder m = 6，n = 2并查看表格。 w1_k表示w1的位置是偏移量k。
w1_5, w1_4, w1_3, w1_2, w1_1, w1_0
w2_5 -- 000011 000101 001001 010001 100001
w2_4 -- -- 000110 001010 010010 100010
w2_3 -- -- -- 001100 010100 100100
w2_2 -- -- -- -- 011000 101000
w2_1 -- -- -- -- -- 110000
w2_0 -- -- -- -- -- --
由于w1的值是常数，因此我们可以对一行进行简单的结论，它随着w1的增加而严格增加。
w1_5, w1_4, w1_3, w1_2, w1_1, w1_0
w2_5 -- 000011 > 000101 > 001001 > 010001 > 100001
w2_4 -- -- 000110 > 001010 > 010010 > 100010
w2_3 -- -- -- 001100 > 010100 > 100100
w2_2 -- -- -- -- 011000 > 101000
w2_1 -- -- -- -- -- 110000
w2_0 -- -- -- -- -- --
关于列和w2的相同结论。
w1_5, w1_4, w1_3, w1_2, w1_1, w1_0
w2_5 -- 000011 > 000101 > 001001 > 010001 > 100001
V V V V
w2_4 -- -- 000110 > 001010 > 010010 > 100010
V V V
w2_3 -- -- -- 001100 > 010100 > 100100
V V
w2_2 -- -- -- -- 011000 > 101000
V
w2_1 -- -- -- -- -- 110000
w2_0 -- -- -- -- -- --
我们可以看到 ring 对应于对角线。 这个例子有三个不同的环。我标有（），[]，{}。
w1_5, w1_4, w1_3, w1_2, w1_1, w1_0
w2_5 -- [000011]>(000101)>{001001}>(010001)>[100001]
V V V V
w2_4 -- -- [000110]>(001010)>{010010}>(100010)
V V V
w2_3 -- -- -- [001100]>(010100)>{100100} <- minF(100100)
V V
w2_2 -- -- -- -- [011000]>(101000) <- minF(010100)
V
w2_1 -- -- -- -- -- [110000] <- minF(000011)
w2_0 -- -- -- -- -- --
戒指有什么共同之处？它是1之间的间隙距离。
[] = {All sets with 4 continuos 0's and an adject one}
= { 100001, 000011, 000110, 001100, 011000, 110000 }
= ((0,4))
() = {All sets with 3 continuos 0's and one single 0}
= { 000101, 001010, 001010, 010100, 101000, 010001, 100010 }
= ((1,3))
{} = {All sets with 2 strings of 2 0's.}
= { 100100, 010010, 001001 }
= ((2,2))
我将调用（（g_1，g_2））为一个环设置的间隙，它描述字符串之间的间隙。 {}描述的环是最中心的环。在奇数尺寸的弦长中，中心环是1宽。在一个均匀的弦长中，中心环是2宽。
w1_6, w1_5, w1_4, w1_3, w1_2, w1_1, w1_0
w2_6 -- [0000011]>(0000101)>{0001001}>{0010001}>(0100001)>[1000001]
V V V V V
w2_5 -- -- [0000110]>(0001010)>{0010010}>{0100010}>(1000010)
V V V V
w2_4 -- -- -- [0001100]>(0010100)>{0100100}>{1000100}
V V V
w2_3 -- -- -- -- [0011000]>(0101000)>{1001000}
V V
w2_2 -- -- -- -- -- [0110000]>(1010000)
V
w2_1 -- -- -- -- -- -- [1100000]
w2_0 -- -- -- -- -- -- --
{} = ((3,2))
() = ((4,1))
[] = ((5,0))
从间隙集中可以推断出距中心线的距离等于2个间隙指标之间的距离除以2到下一个最高的int。
dist_from_center( ((2,2)) ) = ceil(| 2 - 2 | * .5 ) = 0
dist_from_center( ((3,1)) ) = ceil(| 3 - 1 | * .5 ) = 1
dist_from_center( ((4,0)) ) = ceil(| 4 - 0 | * .5 ) = 2
dist_from_center( ((3,2)) ) = ceil(| 3 - 2 | * .5 ) = 1
dist_from_center( ((4,1)) ) = ceil(| 4 - 1 | * .5 ) = 2
dist_from_center( ((5,0)) ) = ceil(| 5 - 0 | * .5 ) = 3
然后将其恢复到那里然后如果gap_set a中的元素之间的dist大于gap_set b中的dist，那么间隙集a中的元素必须小于间隙集b中的某个元素。
dist_from_center( ((a_1,a_2)) ) > dist_from_center( ((b_1,b_2)) )
==Implies==> minF( ((a_1, a_2)) ) < minF( ((b_1, b_2)) )
支持你尽可能地传播1，导致一组字符串的最大minF。