jigloo
- 浏览: 6208 次
- 性别:
- 来自: 北京
-
最近访客 更多访客>>
文章分类
最新评论
-
leero：
看不懂python，
[Python]华为面试题，交换两个数组的元素使之总和的差值最小。 -
jigloo：
你确认"解决"了吗？楼上的这些" ...
[Python]华为面试题，交换两个数组的元素使之总和的差值最小。 -
wjm251：
<div class="quote_title ...
[Python]华为面试题，交换两个数组的元素使之总和的差值最小。 -
fatdolphin：
ls的想的太简单了，举个简单的例子，90，1，2，3，4，5， ...
[Python]华为面试题，交换两个数组的元素使之总和的差值最小。 -
shinkadoki：
合并，排序。从两端开始取值，各去一半，数组内的值总和相差最小。 ...
[Python]华为面试题，交换两个数组的元素使之总和的差值最小。
这是个NPC问题，所以就用穷举发了，在这里给出了一个用python的itertools的解法，个人认为比较简洁。
这个NPC有点滥用了吧，你知道他的含义吗
不是很清楚，期待你写个n*n*n或者n*n算法出来，注意:"数组里面的元素个数是相等的。"
可以在多项式时间内解决的判定性问题属于P类问题
可以在多项式时间内验证一个解是否正确的问题称为NP问题。已知P属于NP，目前的困难是P是否等于NP，即NP是否属于P
这类特殊的NP问题就是NP完全问题（NPC问题，C代表complete）。NPC问题存在着一个令人惊讶的性质，即如果一个NPC问题存在多项式时间的算法，则所有的NP问题都可以在多项式时间内求解，即P=NP成立！！这是因为，每一个NPC问题可以在多项式时间内转化成任何一个NP问题。
以上是从网上某篇文章中抄出来的。总结一下，这个问题被大家以多项式时间解决了，如果是NPC，那么大家就证明了N=NP
楼上V5....
Before:
[9, 10, 16, 30, 34, 49, 59, 63, 81, 96, 105, 106, 112, 115, 116, 123, 133, 141, 142, 184, 190, 201, 201, 203, 215, 217, 229, 236, 242, 259, 262, 274, 274, 276, 293, 294, 297, 299, 304, 311, 315, 320, 321, 360, 368, 377, 377, 385, 387, 391, 408, 411, 426, 433, 434, 443, 459, 493, 496, 498, 504, 507, 512, 518, 549, 554, 560, 575, 634, 640, 642, 649, 652, 660, 664, 686, 686, 698, 700, 702, 720, 724, 735, 759, 768, 789, 789, 792, 812, 817, 817, 824, 826, 829, 841, 848, 861, 861, 862, 871, 874, 882, 888, 891, 896, 908, 908, 924, 925, 930, 930, 930, 940, 941, 947, 960, 973, 976, 981, 998]
[4, 4, 31, 37, 46, 48, 84, 98, 105, 110, 117, 119, 120, 122, 122, 145, 157, 172, 183, 187, 190, 193, 204, 215, 226, 231, 233, 233, 248, 250, 269, 291, 292, 333, 333, 341, 365, 377, 378, 380, 387, 394, 404, 406, 412, 412, 413, 414, 418, 418, 420, 420, 424, 432, 433, 438, 441, 450, 455, 460, 475, 477, 487, 491, 531, 545, 555, 561, 574, 585, 606, 620, 624, 641, 646, 652, 654, 658, 661, 668, 668, 675, 679, 684, 704, 709, 709, 711, 715, 724, 727, 734, 754, 760, 767, 775, 783, 787, 797, 803, 816, 819, 831, 833, 837, 865, 875, 891, 893, 895, 913, 913, 937, 948, 958, 964, 965, 968, 979, 1000]
1422
After:
[4, 9, 10, 16, 30, 31, 37, 46, 49, 96, 98, 105, 106, 110, 116, 117, 120, 122, 123, 141, 142, 145, 190, 201, 203, 204, 215, 231, 248, 259, 262, 274, 293, 297, 315, 321, 333, 341, 360, 368, 377, 380, 385, 387, 387, 391, 394, 404, 412, 414, 418, 418, 420, 432, 433, 450, 455, 460, 475, 491, 493, 504, 512, 549, 554, 555, 560, 575, 585, 640, 642, 649, 652, 652, 658, 661, 668, 679, 686, 698, 700, 709, 709, 715, 734, 754, 760, 767, 768, 787, 789, 792, 803, 817, 819, 824, 826, 831, 841, 848, 861, 861, 862, 865, 888, 891, 893, 895, 908, 913, 924, 930, 930, 937, 940, 958, 968, 973, 998, 1000]
[4, 34, 48, 59, 63, 81, 84, 105, 112, 115, 119, 122, 133, 157, 172, 183, 184, 187, 190, 193, 201, 215, 217, 226, 229, 233, 233, 236, 242, 250, 269, 274, 276, 291, 292, 294, 299, 304, 311, 320, 333, 365, 377, 377, 378, 406, 408, 411, 412, 413, 420, 424, 426, 433, 434, 438, 441, 443, 459, 477, 487, 496, 498, 507, 518, 531, 545, 561, 574, 606, 620, 624, 634, 641, 646, 654, 660, 664, 668, 675, 684, 686, 702, 704, 711, 720, 724, 724, 727, 735, 759, 775, 783, 789, 797, 812, 816, 817, 829, 833, 837, 871, 874, 875, 882, 891, 896, 908, 913, 925, 930, 941, 947, 948, 960, 964, 965, 976, 979, 981]
0
效果不错
按照合并 排序后我写了个。因为排序算法很多，所以就没写。归并排序应该就可以
这个NPC有点滥用了吧，你知道他的含义吗
不是很清楚，期待你写个n*n*n或者n*n算法出来，注意:"数组里面的元素个数是相等的。"
这个NPC有点滥用了吧，你知道他的含义吗
经过哥们提醒，改良了下，对于数组长度为m，n有m*n种交换数组，求其中差值最小的，结果应该是正确的
int[] arr1 = { 1, 2, 3, 4, 5, 100, 101 };
int[] arr2 = { 11, 12, 13, 14, 15,100, 170 };
结果为
[100, 1, 2, 3, 4, 100, 101]
311
[5, 11, 12, 13, 14, 15, 170]
240
至少
[1, 2, 3, 4, 5, 100, 170]
285
[11, 12, 13, 14, 15, 100, 101]
266
比代码求出来的效果好
还真是那么回事，兄弟知道哪里缺陷么？这样想到的解决办法就是合并排序再。。。
经过哥们提醒，改良了下，对于数组长度为m，n有m*n种交换数组，求其中差值最小的，结果应该是正确的
int[] arr1 = { 1, 2, 3, 4, 5, 100, 101 };
int[] arr2 = { 11, 12, 13, 14, 15,100, 170 };
结果为
[100, 1, 2, 3, 4, 100, 101]
311
[5, 11, 12, 13, 14, 15, 170]
240
至少
[1, 2, 3, 4, 5, 100, 170]
285
[11, 12, 13, 14, 15, 100, 101]
266
比代码求出来的效果好
经过哥们提醒，改良了下，对于数组长度为m，n有m*n种交换数组，求其中差值最小的，结果应该是正确的
我觉得你这个应该是n^3，当然如果优化一下求和过程，可以降得到n^2。
你能证明这个算法的正确性吗？
是一对一交换，不过数组不一定等长吧，
对对，脑子坏了，呵呵
这个公式我想不出来，尤其是要考虑包内个数必须为数组的长度 交换的意思应该是两个数组长度一致，1对1交换吧
是一对一交换，不过数组不一定等长吧，
这个公式我想不出来，尤其是要考虑包内个数必须为数组的长度 交换的意思应该是两个数组长度一致，1对1交换吧
import itertools
def funcProduct(a, b):
for c in itertools.permutations(b):
for d in itertools.product(*[list(itertools.permutations(x)) for x in zip(a, c)]):
yield zip(*d)
a = [1,2,3,4]
b = [5,6,700,800]
print min(funcProduct(a,b), key=lambda x:abs(sum(x[0])-sum(x[1])))
分享到：
评论
28 楼
leero
2011-04-04
看不懂python，
27 楼
jigloo
2011-04-02
你确认"解决"了吗？楼上的这些"多项式算法"要不是错误的，要不就是不满足题意。就是我提醒你的"两个数组长度要一致"
26 楼
wjm251
2011-04-02
jigloo 写道
wjm251 写道
jigloo 写道
这是个NPC问题，所以就用穷举发了，在这里给出了一个用python的itertools的解法，个人认为比较简洁。
这个NPC有点滥用了吧，你知道他的含义吗
不是很清楚，期待你写个n*n*n或者n*n算法出来，注意:"数组里面的元素个数是相等的。"
可以在多项式时间内解决的判定性问题属于P类问题
可以在多项式时间内验证一个解是否正确的问题称为NP问题。已知P属于NP，目前的困难是P是否等于NP，即NP是否属于P
这类特殊的NP问题就是NP完全问题（NPC问题，C代表complete）。NPC问题存在着一个令人惊讶的性质，即如果一个NPC问题存在多项式时间的算法，则所有的NP问题都可以在多项式时间内求解，即P=NP成立！！这是因为，每一个NPC问题可以在多项式时间内转化成任何一个NP问题。
以上是从网上某篇文章中抄出来的。总结一下，这个问题被大家以多项式时间解决了，如果是NPC，那么大家就证明了N=NP
25 楼
fatdolphin
2011-04-01
ls的想的太简单了，举个简单的例子，90，1，2，3，4，5，你这个算法就不会返回正确的结果
24 楼
shinkadoki
2011-04-01
合并，排序。从两端开始取值，各去一半，数组内的值总和相差最小。
23 楼
northc
2011-03-31
opal 写道
简单易懂的解决方案（java）
import java.util.*;
public class Main {
public static void main(String args[]) {
Integer a[] = { 1, 2, 3, 4, 5, 11, 12 };
Integer b[] = { 13, 14, 15, 100,100,101,170};
Integer d,v;
List<Integer> c = new ArrayList<Integer>(Arrays.asList(a));
c.addAll(Arrays.asList(b));
Collections.sort(c,new Comparator<Integer>(){
public int compare(Integer a,Integer b) {
return b.compareTo(a);
}
});
int i=1,j=1;
a[0] = c.get(0);
b[0] = c.get(1);
d = a[0] - b[0];
for (int k=2; k<c.size() ; k++) {
v = c.get(k);
if (i >= a.length) {
b[j++] = v;
d -= v;
continue;
}
if (j >= b.length) {
a[i++] = v;
d += v;
continue;
}
if (d < 0) {
a[i++] = v;
d += v;
} else {
b[j++] = v;
d -= v;
}
}
System.out.println(Arrays.asList(a).toString());
System.out.println(Arrays.asList(b).toString());
System.out.println("diff=" + d);
}
}
楼上V5....
22 楼
opal
2011-03-30
简单易懂的解决方案（java）
import java.util.*;
public class Main {
public static void main(String args[]) {
Integer a[] = { 1, 2, 3, 4, 5, 11, 12 };
Integer b[] = { 13, 14, 15, 100,100,101,170};
Integer d,v;
List<Integer> c = new ArrayList<Integer>(Arrays.asList(a));
c.addAll(Arrays.asList(b));
Collections.sort(c,new Comparator<Integer>(){
public int compare(Integer a,Integer b) {
return b.compareTo(a);
}
});
int i=1,j=1;
a[0] = c.get(0);
b[0] = c.get(1);
d = a[0] - b[0];
for (int k=2; k<c.size() ; k++) {
v = c.get(k);
if (i >= a.length) {
b[j++] = v;
d -= v;
continue;
}
if (j >= b.length) {
a[i++] = v;
d += v;
continue;
}
if (d < 0) {
a[i++] = v;
d += v;
} else {
b[j++] = v;
d -= v;
}
}
System.out.println(Arrays.asList(a).toString());
System.out.println(Arrays.asList(b).toString());
System.out.println("diff=" + d);
}
}
21 楼
feisuzhu
2011-03-27
#!/usr/bin/python
# Simulated annealing
from random import randint, random
from math import exp
l1 = [randint(0,1000) for i in xrange(120)]
l2 = [randint(0,1000) for i in xrange(120)]
l1.sort()
l2.sort()
def sa():
t = 1000.0
cool = 0.999
sl1 = sum(l1)
sl2 = sum(l2)
ev = abs(sl1 - sl2)
while t>0.00001:
a = randint(0,len(l1)-1)
b = randint(0,len(l2)-1)
nsl1 = sl1 - l1[a] + l2[b]
nsl2 = sl2 - l2[b] + l1[a]
nev = abs(nsl1 - nsl2)
d = nev - ev
if d<0 or (d>0 and exp(-d/t)>random()):
ev = nev
sl1, sl2 = nsl1, nsl2
l1[a], l2[b] = l2[b], l1[a]
t *= cool
print "Before:"
print l1
print l2
print abs(sum(l1) - sum(l2))
sa()
print "After:"
l1.sort()
l2.sort()
print l1
print l2
print abs(sum(l1) - sum(l2))
Before:
[9, 10, 16, 30, 34, 49, 59, 63, 81, 96, 105, 106, 112, 115, 116, 123, 133, 141, 142, 184, 190, 201, 201, 203, 215, 217, 229, 236, 242, 259, 262, 274, 274, 276, 293, 294, 297, 299, 304, 311, 315, 320, 321, 360, 368, 377, 377, 385, 387, 391, 408, 411, 426, 433, 434, 443, 459, 493, 496, 498, 504, 507, 512, 518, 549, 554, 560, 575, 634, 640, 642, 649, 652, 660, 664, 686, 686, 698, 700, 702, 720, 724, 735, 759, 768, 789, 789, 792, 812, 817, 817, 824, 826, 829, 841, 848, 861, 861, 862, 871, 874, 882, 888, 891, 896, 908, 908, 924, 925, 930, 930, 930, 940, 941, 947, 960, 973, 976, 981, 998]
[4, 4, 31, 37, 46, 48, 84, 98, 105, 110, 117, 119, 120, 122, 122, 145, 157, 172, 183, 187, 190, 193, 204, 215, 226, 231, 233, 233, 248, 250, 269, 291, 292, 333, 333, 341, 365, 377, 378, 380, 387, 394, 404, 406, 412, 412, 413, 414, 418, 418, 420, 420, 424, 432, 433, 438, 441, 450, 455, 460, 475, 477, 487, 491, 531, 545, 555, 561, 574, 585, 606, 620, 624, 641, 646, 652, 654, 658, 661, 668, 668, 675, 679, 684, 704, 709, 709, 711, 715, 724, 727, 734, 754, 760, 767, 775, 783, 787, 797, 803, 816, 819, 831, 833, 837, 865, 875, 891, 893, 895, 913, 913, 937, 948, 958, 964, 965, 968, 979, 1000]
1422
After:
[4, 9, 10, 16, 30, 31, 37, 46, 49, 96, 98, 105, 106, 110, 116, 117, 120, 122, 123, 141, 142, 145, 190, 201, 203, 204, 215, 231, 248, 259, 262, 274, 293, 297, 315, 321, 333, 341, 360, 368, 377, 380, 385, 387, 387, 391, 394, 404, 412, 414, 418, 418, 420, 432, 433, 450, 455, 460, 475, 491, 493, 504, 512, 549, 554, 555, 560, 575, 585, 640, 642, 649, 652, 652, 658, 661, 668, 679, 686, 698, 700, 709, 709, 715, 734, 754, 760, 767, 768, 787, 789, 792, 803, 817, 819, 824, 826, 831, 841, 848, 861, 861, 862, 865, 888, 891, 893, 895, 908, 913, 924, 930, 930, 937, 940, 958, 968, 973, 998, 1000]
[4, 34, 48, 59, 63, 81, 84, 105, 112, 115, 119, 122, 133, 157, 172, 183, 184, 187, 190, 193, 201, 215, 217, 226, 229, 233, 233, 236, 242, 250, 269, 274, 276, 291, 292, 294, 299, 304, 311, 320, 333, 365, 377, 377, 378, 406, 408, 411, 412, 413, 420, 424, 426, 433, 434, 438, 441, 443, 459, 477, 487, 496, 498, 507, 518, 531, 545, 561, 574, 606, 620, 624, 634, 641, 646, 654, 660, 664, 668, 675, 684, 686, 702, 704, 711, 720, 724, 724, 727, 735, 759, 775, 783, 789, 797, 812, 816, 817, 829, 833, 837, 871, 874, 875, 882, 891, 896, 908, 913, 925, 930, 941, 947, 948, 960, 964, 965, 976, 979, 981]
0
效果不错
20 楼
神之小丑
2011-03-25
flysunmicro 写道
合并，排序
按照合并 排序后我写了个。因为排序算法很多，所以就没写。归并排序应该就可以
public void mergeSort(int[] array1,int[] array2){
/*
* 这里将这两个数组合并排序成一个数组
* 这里就省略
*/
int[] array=new int[array1.length+array2.length];
for(int i=0;i<array1.length;i++){
array[i]=array1[i];
array[i+array1.length]=array2[i];
}
System.out.println("合并数组array：");
for(int i:array)
System.out.print(i+"\t");
System.out.println();
sumResolve(array,array1,array2);
}
private void sumResolve(int[] array,int[] array1,int[] array2){
array1[0]=array[array.length-1];
array2[0]=array[array.length-2];
int array1Sum=array1[0];
int array2Sum=array2[0];
int index1=1;
int index2=1;
for(int i=array.length-3;i>=0;i--){
if(array1Sum>=array2Sum&&index2<array2.length){
array2[index2]=array[i];
array2Sum+=array2[index2];
index2++;
}else if(index1<array1.length){
array1[index1]=array[i];
array1Sum+=array1[index1];
index1++;
}
}
System.out.println("数组array1：");
for(int j:array1)
System.out.print(j+"\t");
System.out.print("和为："+array1Sum);
System.out.println();
System.out.println("数组array2：");
for(int j:array2)
System.out.print(j+"\t");
System.out.print("和为："+array2Sum);
System.out.println();
}
int[] arr1 = { 1, 2, 3, 4, 5, 11,12 };
int[] arr2 = { 13, 14, 15,100,100,101, 170 };
mergeSort(arr1, arr2);
outoutPut:
合并数组array：
1 2 3 4 5 11 12 13 14 15 100 100 101 170
数组array1：
170 100 5 4 3 2 1 和为：285
数组array2：
101 100 15 14 13 12 11 和为：266
19 楼
Excalibur
2011-03-25
<div class="quote_title">chinpom 写道</div>
<div class="quote_div">
<p><img src="/images/smiles/icon_biggrin.gif" alt=""> 在网上找了一篇帖子，给LZ参考一下：</p>
<pre name="code" class="c">/*
有两个数组a,b，大小都为n,数组元素的值任意整形数，无序；
要求：通过交换a,b中的元素，使[数组a元素的和]与[数组b元素的和]之间的差最小。
*/
/*
求解思路：
当前数组a和数组b的和之差为
A = sum(a) - sum(b)
a的第i个元素和b的第j个元素交换后，a和b的和之差为
A' = sum(a) - a[i] + b[j] - （sum(b) - b[j] + a[i])
= sum(a) - sum(b) - 2 (a[i] - b[j])
= A - 2 (a[i] - b[j])
设x = a[i] - b[j]
|A| - |A'| = |A| - |A-2x|
假设A > 0,
当x 在 (0,A)之间时，做这样的交换才能使得交换后的a和b的和之差变小，x越接近A/2效果越好,
如果找不到在(0,A)之间的x，则当前的a和b就是答案。
所以算法大概如下：
在a和b中寻找使得x在(0,A)之间并且最接近A/2的i和j，交换相应的i和j元素，重新计算A后，重复前面的步骤直至找不到(0,A)之间的x为止。
*/
把算法大概实现了一下，程序如下：
1 int test(float a[], float b[], int n)
2 {
3 float sumA, sumB; //sumA为数组a总和，sumB为数组b总和
4 float sum_diff, num_diff; //sum_diff为a,b总和差， num_diff为a,b中各选的两个数之差
5 float temp1, temp2; //temp1为 每轮sum_diff/2， temp2为每轮所选两个数之差于temp1最接近的那个
6 int i, j;
7 float temp; //用于对调a,b间数
8 int tempi, tempj; //每轮所选两个数之差于temp1最接近的那组数
9 unsigned int flag_sum = 0, flag_num = 0; //flag_sum为1， sumA大于sumB; flag_num为1, 此轮存在两个数之差小于sum_diff
10
11
12
13
14 while(1){
15
16 //算出a,b数组和
17 sumA = 0;
18 sumB = 0;
19 for(i=0;i < n;i++)
20 {
21 sumA += a[i];
22 sumB += b[i];
23 }
24
25 if(sumA >= sumB){
26 sum_diff = sumA - sumB;
27 flag_sum = 1;
28 }
29 else
30 sum_diff = sumB - sumA;
31
32 temp1 = sum_diff/2;
33 temp2 = temp1;
34 tempi = 0;
35 tempj = 0;
36
37 //找出a,b间差值最接近sum_diff/2的那一对数
38 if(flag_sum == 1){ //sumA > sumB
39 for(i=0; i < n; i++)
40 for(j=0; j < n; j++)
41
42 if(a[i] > b[j]){
43 num_diff = a[i] - b[j];
44 if(num_diff < sum_diff){
45 flag_num =1;
46 if(num_diff >= temp1){
47 if(num_diff-temp1 < temp2){
48 temp2 = num_diff-temp1;
49 tempi = i;
50 tempj = j;
51 }
52 }
53 else{
54 if(temp1 - num_diff < temp2){
55 temp2 = temp1 - num_diff;
56 tempi = i;
57 tempj = j;
58 }
59 }
60 }
61 }
62 }
63 else{
64 for(i=0; i < n; i++)
65 for(j=0; j < n; j++)
66
67 if(a[i] < b[j]){
68 num_diff = b[j] - a[i];
69 if(num_diff < sum_diff){
70 flag_num =1;
71 if(num_diff >= temp1){
72 if(num_diff-temp1 < temp2){
73 temp2 = num_diff-temp1;
74 tempi = i;
75 tempj = j;
76 }
77 }
78 else{
79 if(temp1 - num_diff < temp2){
80 temp2 = temp1 - num_diff;
81 tempi = i;
82 tempj = j;
83 }
84 }
85 }
86 }
87 }
88
89 if(flag_num == 0)
90 break;
91
92 temp = a[tempi];
93 a[tempi] = b[tempj];
94 b[tempj] = temp;
95
96 flag_num = 0;
97 flag_sum = 0;
98 }
99
100 for(i=0; i < n;i++)
101 printf("%f\t",a[i]);
102
103 printf("\n");
104
105 for(i=0; i < n;i++)
106 printf("%f\t",b[i]);
107
108 printf("\n");
109
110 return 0;
111 }
112
113
114 int main(int argc, char *argv[])
115 {
116
117 float a[3] = {4,5,12};
118 float b[3] = {1,2,3};
119
120 test(a, b, 3);
121
122 return 0;
123 }</pre>
</div>
<p>输入为：</p>
<p> int[] arr1 = { 1, 2, 3, 4, 5, 6, 7, 239, 100};<br> int[] arr2 = { 21, 22, 23, 24, 25, 26, 27, 100, 102 }; </p>
<p>时出现死循环了吧</p>
<p> </p>
<p>至少存在一个答案如下：</p>
<p>int[] arr1 = { 21, 22, 23, 24, 25, 26, 27, 100,100};<br> int[] arr2 = { 1, 2, 3, 4, 5, 6, 7, 239, 102 };</p>
<p> </p>
<p>这种贪心算法能证明可行吗？</p>
<p>我觉得无法证明</p>
<p> </p>
<p> </p>
<div class="quote_div">
<p><img src="/images/smiles/icon_biggrin.gif" alt=""> 在网上找了一篇帖子，给LZ参考一下：</p>
<pre name="code" class="c">/*
有两个数组a,b，大小都为n,数组元素的值任意整形数，无序；
要求：通过交换a,b中的元素，使[数组a元素的和]与[数组b元素的和]之间的差最小。
*/
/*
求解思路：
当前数组a和数组b的和之差为
A = sum(a) - sum(b)
a的第i个元素和b的第j个元素交换后，a和b的和之差为
A' = sum(a) - a[i] + b[j] - （sum(b) - b[j] + a[i])
= sum(a) - sum(b) - 2 (a[i] - b[j])
= A - 2 (a[i] - b[j])
设x = a[i] - b[j]
|A| - |A'| = |A| - |A-2x|
假设A > 0,
当x 在 (0,A)之间时，做这样的交换才能使得交换后的a和b的和之差变小，x越接近A/2效果越好,
如果找不到在(0,A)之间的x，则当前的a和b就是答案。
所以算法大概如下：
在a和b中寻找使得x在(0,A)之间并且最接近A/2的i和j，交换相应的i和j元素，重新计算A后，重复前面的步骤直至找不到(0,A)之间的x为止。
*/
把算法大概实现了一下，程序如下：
1 int test(float a[], float b[], int n)
2 {
3 float sumA, sumB; //sumA为数组a总和，sumB为数组b总和
4 float sum_diff, num_diff; //sum_diff为a,b总和差， num_diff为a,b中各选的两个数之差
5 float temp1, temp2; //temp1为 每轮sum_diff/2， temp2为每轮所选两个数之差于temp1最接近的那个
6 int i, j;
7 float temp; //用于对调a,b间数
8 int tempi, tempj; //每轮所选两个数之差于temp1最接近的那组数
9 unsigned int flag_sum = 0, flag_num = 0; //flag_sum为1， sumA大于sumB; flag_num为1, 此轮存在两个数之差小于sum_diff
10
11
12
13
14 while(1){
15
16 //算出a,b数组和
17 sumA = 0;
18 sumB = 0;
19 for(i=0;i < n;i++)
20 {
21 sumA += a[i];
22 sumB += b[i];
23 }
24
25 if(sumA >= sumB){
26 sum_diff = sumA - sumB;
27 flag_sum = 1;
28 }
29 else
30 sum_diff = sumB - sumA;
31
32 temp1 = sum_diff/2;
33 temp2 = temp1;
34 tempi = 0;
35 tempj = 0;
36
37 //找出a,b间差值最接近sum_diff/2的那一对数
38 if(flag_sum == 1){ //sumA > sumB
39 for(i=0; i < n; i++)
40 for(j=0; j < n; j++)
41
42 if(a[i] > b[j]){
43 num_diff = a[i] - b[j];
44 if(num_diff < sum_diff){
45 flag_num =1;
46 if(num_diff >= temp1){
47 if(num_diff-temp1 < temp2){
48 temp2 = num_diff-temp1;
49 tempi = i;
50 tempj = j;
51 }
52 }
53 else{
54 if(temp1 - num_diff < temp2){
55 temp2 = temp1 - num_diff;
56 tempi = i;
57 tempj = j;
58 }
59 }
60 }
61 }
62 }
63 else{
64 for(i=0; i < n; i++)
65 for(j=0; j < n; j++)
66
67 if(a[i] < b[j]){
68 num_diff = b[j] - a[i];
69 if(num_diff < sum_diff){
70 flag_num =1;
71 if(num_diff >= temp1){
72 if(num_diff-temp1 < temp2){
73 temp2 = num_diff-temp1;
74 tempi = i;
75 tempj = j;
76 }
77 }
78 else{
79 if(temp1 - num_diff < temp2){
80 temp2 = temp1 - num_diff;
81 tempi = i;
82 tempj = j;
83 }
84 }
85 }
86 }
87 }
88
89 if(flag_num == 0)
90 break;
91
92 temp = a[tempi];
93 a[tempi] = b[tempj];
94 b[tempj] = temp;
95
96 flag_num = 0;
97 flag_sum = 0;
98 }
99
100 for(i=0; i < n;i++)
101 printf("%f\t",a[i]);
102
103 printf("\n");
104
105 for(i=0; i < n;i++)
106 printf("%f\t",b[i]);
107
108 printf("\n");
109
110 return 0;
111 }
112
113
114 int main(int argc, char *argv[])
115 {
116
117 float a[3] = {4,5,12};
118 float b[3] = {1,2,3};
119
120 test(a, b, 3);
121
122 return 0;
123 }</pre>
</div>
<p>输入为：</p>
<p> int[] arr1 = { 1, 2, 3, 4, 5, 6, 7, 239, 100};<br> int[] arr2 = { 21, 22, 23, 24, 25, 26, 27, 100, 102 }; </p>
<p>时出现死循环了吧</p>
<p> </p>
<p>至少存在一个答案如下：</p>
<p>int[] arr1 = { 21, 22, 23, 24, 25, 26, 27, 100,100};<br> int[] arr2 = { 1, 2, 3, 4, 5, 6, 7, 239, 102 };</p>
<p> </p>
<p>这种贪心算法能证明可行吗？</p>
<p>我觉得无法证明</p>
<p> </p>
<p> </p>
18 楼
jigloo
2011-03-25
wjm251 写道
jigloo 写道
这是个NPC问题，所以就用穷举发了，在这里给出了一个用python的itertools的解法，个人认为比较简洁。
这个NPC有点滥用了吧，你知道他的含义吗
不是很清楚，期待你写个n*n*n或者n*n算法出来，注意:"数组里面的元素个数是相等的。"
17 楼
wjm251
2011-03-25
jigloo 写道
这是个NPC问题，所以就用穷举发了，在这里给出了一个用python的itertools的解法，个人认为比较简洁。
这个NPC有点滥用了吧，你知道他的含义吗
16 楼
chinpom
2011-03-24
<p><img src="/images/smiles/icon_biggrin.gif" alt=""> 在网上找了一篇帖子，给LZ参考一下：</p>
<pre name="code" class="c">/*
有两个数组a,b，大小都为n,数组元素的值任意整形数，无序；
要求：通过交换a,b中的元素，使[数组a元素的和]与[数组b元素的和]之间的差最小。
*/
/*
求解思路：
当前数组a和数组b的和之差为
A = sum(a) - sum(b)
a的第i个元素和b的第j个元素交换后，a和b的和之差为
A' = sum(a) - a[i] + b[j] - （sum(b) - b[j] + a[i])
= sum(a) - sum(b) - 2 (a[i] - b[j])
= A - 2 (a[i] - b[j])
设x = a[i] - b[j]
|A| - |A'| = |A| - |A-2x|
假设A > 0,
当x 在 (0,A)之间时，做这样的交换才能使得交换后的a和b的和之差变小，x越接近A/2效果越好,
如果找不到在(0,A)之间的x，则当前的a和b就是答案。
所以算法大概如下：
在a和b中寻找使得x在(0,A)之间并且最接近A/2的i和j，交换相应的i和j元素，重新计算A后，重复前面的步骤直至找不到(0,A)之间的x为止。
*/
把算法大概实现了一下，程序如下：
1 int test(float a[], float b[], int n)
2 {
3 float sumA, sumB; //sumA为数组a总和，sumB为数组b总和
4 float sum_diff, num_diff; //sum_diff为a,b总和差， num_diff为a,b中各选的两个数之差
5 float temp1, temp2; //temp1为 每轮sum_diff/2， temp2为每轮所选两个数之差于temp1最接近的那个
6 int i, j;
7 float temp; //用于对调a,b间数
8 int tempi, tempj; //每轮所选两个数之差于temp1最接近的那组数
9 unsigned int flag_sum = 0, flag_num = 0; //flag_sum为1， sumA大于sumB; flag_num为1, 此轮存在两个数之差小于sum_diff
10
11
12
13
14 while(1){
15
16 //算出a,b数组和
17 sumA = 0;
18 sumB = 0;
19 for(i=0;i < n;i++)
20 {
21 sumA += a[i];
22 sumB += b[i];
23 }
24
25 if(sumA >= sumB){
26 sum_diff = sumA - sumB;
27 flag_sum = 1;
28 }
29 else
30 sum_diff = sumB - sumA;
31
32 temp1 = sum_diff/2;
33 temp2 = temp1;
34 tempi = 0;
35 tempj = 0;
36
37 //找出a,b间差值最接近sum_diff/2的那一对数
38 if(flag_sum == 1){ //sumA > sumB
39 for(i=0; i < n; i++)
40 for(j=0; j < n; j++)
41
42 if(a[i] > b[j]){
43 num_diff = a[i] - b[j];
44 if(num_diff < sum_diff){
45 flag_num =1;
46 if(num_diff >= temp1){
47 if(num_diff-temp1 < temp2){
48 temp2 = num_diff-temp1;
49 tempi = i;
50 tempj = j;
51 }
52 }
53 else{
54 if(temp1 - num_diff < temp2){
55 temp2 = temp1 - num_diff;
56 tempi = i;
57 tempj = j;
58 }
59 }
60 }
61 }
62 }
63 else{
64 for(i=0; i < n; i++)
65 for(j=0; j < n; j++)
66
67 if(a[i] < b[j]){
68 num_diff = b[j] - a[i];
69 if(num_diff < sum_diff){
70 flag_num =1;
71 if(num_diff >= temp1){
72 if(num_diff-temp1 < temp2){
73 temp2 = num_diff-temp1;
74 tempi = i;
75 tempj = j;
76 }
77 }
78 else{
79 if(temp1 - num_diff < temp2){
80 temp2 = temp1 - num_diff;
81 tempi = i;
82 tempj = j;
83 }
84 }
85 }
86 }
87 }
88
89 if(flag_num == 0)
90 break;
91
92 temp = a[tempi];
93 a[tempi] = b[tempj];
94 b[tempj] = temp;
95
96 flag_num = 0;
97 flag_sum = 0;
98 }
99
100 for(i=0; i < n;i++)
101 printf("%f\t",a[i]);
102
103 printf("\n");
104
105 for(i=0; i < n;i++)
106 printf("%f\t",b[i]);
107
108 printf("\n");
109
110 return 0;
111 }
112
113
114 int main(int argc, char *argv[])
115 {
116
117 float a[3] = {4,5,12};
118 float b[3] = {1,2,3};
119
120 test(a, b, 3);
121
122 return 0;
123 }</pre>
<pre name="code" class="c">/*
有两个数组a,b，大小都为n,数组元素的值任意整形数，无序；
要求：通过交换a,b中的元素，使[数组a元素的和]与[数组b元素的和]之间的差最小。
*/
/*
求解思路：
当前数组a和数组b的和之差为
A = sum(a) - sum(b)
a的第i个元素和b的第j个元素交换后，a和b的和之差为
A' = sum(a) - a[i] + b[j] - （sum(b) - b[j] + a[i])
= sum(a) - sum(b) - 2 (a[i] - b[j])
= A - 2 (a[i] - b[j])
设x = a[i] - b[j]
|A| - |A'| = |A| - |A-2x|
假设A > 0,
当x 在 (0,A)之间时，做这样的交换才能使得交换后的a和b的和之差变小，x越接近A/2效果越好,
如果找不到在(0,A)之间的x，则当前的a和b就是答案。
所以算法大概如下：
在a和b中寻找使得x在(0,A)之间并且最接近A/2的i和j，交换相应的i和j元素，重新计算A后，重复前面的步骤直至找不到(0,A)之间的x为止。
*/
把算法大概实现了一下，程序如下：
1 int test(float a[], float b[], int n)
2 {
3 float sumA, sumB; //sumA为数组a总和，sumB为数组b总和
4 float sum_diff, num_diff; //sum_diff为a,b总和差， num_diff为a,b中各选的两个数之差
5 float temp1, temp2; //temp1为 每轮sum_diff/2， temp2为每轮所选两个数之差于temp1最接近的那个
6 int i, j;
7 float temp; //用于对调a,b间数
8 int tempi, tempj; //每轮所选两个数之差于temp1最接近的那组数
9 unsigned int flag_sum = 0, flag_num = 0; //flag_sum为1， sumA大于sumB; flag_num为1, 此轮存在两个数之差小于sum_diff
10
11
12
13
14 while(1){
15
16 //算出a,b数组和
17 sumA = 0;
18 sumB = 0;
19 for(i=0;i < n;i++)
20 {
21 sumA += a[i];
22 sumB += b[i];
23 }
24
25 if(sumA >= sumB){
26 sum_diff = sumA - sumB;
27 flag_sum = 1;
28 }
29 else
30 sum_diff = sumB - sumA;
31
32 temp1 = sum_diff/2;
33 temp2 = temp1;
34 tempi = 0;
35 tempj = 0;
36
37 //找出a,b间差值最接近sum_diff/2的那一对数
38 if(flag_sum == 1){ //sumA > sumB
39 for(i=0; i < n; i++)
40 for(j=0; j < n; j++)
41
42 if(a[i] > b[j]){
43 num_diff = a[i] - b[j];
44 if(num_diff < sum_diff){
45 flag_num =1;
46 if(num_diff >= temp1){
47 if(num_diff-temp1 < temp2){
48 temp2 = num_diff-temp1;
49 tempi = i;
50 tempj = j;
51 }
52 }
53 else{
54 if(temp1 - num_diff < temp2){
55 temp2 = temp1 - num_diff;
56 tempi = i;
57 tempj = j;
58 }
59 }
60 }
61 }
62 }
63 else{
64 for(i=0; i < n; i++)
65 for(j=0; j < n; j++)
66
67 if(a[i] < b[j]){
68 num_diff = b[j] - a[i];
69 if(num_diff < sum_diff){
70 flag_num =1;
71 if(num_diff >= temp1){
72 if(num_diff-temp1 < temp2){
73 temp2 = num_diff-temp1;
74 tempi = i;
75 tempj = j;
76 }
77 }
78 else{
79 if(temp1 - num_diff < temp2){
80 temp2 = temp1 - num_diff;
81 tempi = i;
82 tempj = j;
83 }
84 }
85 }
86 }
87 }
88
89 if(flag_num == 0)
90 break;
91
92 temp = a[tempi];
93 a[tempi] = b[tempj];
94 b[tempj] = temp;
95
96 flag_num = 0;
97 flag_sum = 0;
98 }
99
100 for(i=0; i < n;i++)
101 printf("%f\t",a[i]);
102
103 printf("\n");
104
105 for(i=0; i < n;i++)
106 printf("%f\t",b[i]);
107
108 printf("\n");
109
110 return 0;
111 }
112
113
114 int main(int argc, char *argv[])
115 {
116
117 float a[3] = {4,5,12};
118 float b[3] = {1,2,3};
119
120 test(a, b, 3);
121
122 return 0;
123 }</pre>
15 楼
liuningbo
2011-03-24
Excalibur 写道
liuningbo 写道
Excalibur 写道
我觉得你这个应该是n^3，当然如果优化一下求和过程，可以降得到n^2。
你能证明这个算法的正确性吗？
你能证明这个算法的正确性吗？
经过哥们提醒，改良了下，对于数组长度为m，n有m*n种交换数组，求其中差值最小的，结果应该是正确的
int[] arr1 = { 1, 2, 3, 4, 5, 100, 101 };
int[] arr2 = { 11, 12, 13, 14, 15,100, 170 };
结果为
[100, 1, 2, 3, 4, 100, 101]
311
[5, 11, 12, 13, 14, 15, 170]
240
至少
[1, 2, 3, 4, 5, 100, 170]
285
[11, 12, 13, 14, 15, 100, 101]
266
比代码求出来的效果好
还真是那么回事，兄弟知道哪里缺陷么？这样想到的解决办法就是合并排序再。。。
14 楼
Excalibur
2011-03-24
liuningbo 写道
Excalibur 写道
我觉得你这个应该是n^3，当然如果优化一下求和过程，可以降得到n^2。
你能证明这个算法的正确性吗？
你能证明这个算法的正确性吗？
经过哥们提醒，改良了下，对于数组长度为m，n有m*n种交换数组，求其中差值最小的，结果应该是正确的
int[] arr1 = { 1, 2, 3, 4, 5, 100, 101 };
int[] arr2 = { 11, 12, 13, 14, 15,100, 170 };
结果为
[100, 1, 2, 3, 4, 100, 101]
311
[5, 11, 12, 13, 14, 15, 170]
240
至少
[1, 2, 3, 4, 5, 100, 170]
285
[11, 12, 13, 14, 15, 100, 101]
266
比代码求出来的效果好
13 楼
liuningbo
2011-03-24
Excalibur 写道
我觉得你这个应该是n^3，当然如果优化一下求和过程，可以降得到n^2。
你能证明这个算法的正确性吗？
你能证明这个算法的正确性吗？
private int primalMinus=0;
private int sum1=0;
private int sum2=0;
private void primalMinus(){
for (int i = 0; i < arr1.length; i++) {
sum1+=arr1[i];
}
for (int i = 0; i < arr2.length; i++) {
sum2+=arr2[i];
}
primalMinus=Math.abs(sum1-sum2);
}
public void exchange(){
primalMinus();//计算最初差值
int index=0;
int len=arr1.length;
int currMinus=primalMinus;
while(true){
for (int i = 0; i < arr2.length; i++) {
echangeMatrix(index,i);//交换值
int afterChange=getMinus();
if(currMinus>=afterChange){
currMinus=afterChange;//一次循环中找到最小minus的
}else {
echangeMatrix(index,i);//若不是则不交换，即再换同一位置一次
}
}
index++;
if(index>=len){
break;
}
}
}
private void echangeMatrix(int index,int des){
int temp=0;
temp=arr1[index];
arr1[index]=arr2[des];
sum1+=arr1[index];
sum2-=arr1[index];
arr2[des]=temp;
sum1-=arr2[des];
sum2+=arr2[des];
primalMinus=Math.abs(sum1-sum2);
}
/**计算和
* ryuuninbou
* @return int
*/
private int getMinus(){
return primalMinus;
}
经过哥们提醒，改良了下，对于数组长度为m，n有m*n种交换数组，求其中差值最小的，结果应该是正确的
12 楼
Excalibur
2011-03-24
liuningbo 写道
看看写了个 ，实现不需数组长度一致，复杂度O(n^2),求好的算法
/** arr1={1,2,3};
* arr2={22,33,44,55};
* 交换两个矩阵数据
*/
public void exchange(){
int index=0;
int len=arr1.length;
int currMinus=getMinus();
while(true){
for (int i = 0; i < arr2.length; i++) {
echangeMatrix(index,i);//交换值
if(currMinus>getMinus()){
currMinus=getMinus();//一次循环中找到最小minus的
}else {
echangeMatrix(index,i);//若不是则不交换，即再换同一位置一次
}
}
index++;
if(index>=len){
break;
}
}
}
private void echangeMatrix(int index,int des){
int temp=0;
temp=arr1[index];
arr1[index]=arr2[des];
arr2[des]=temp;
}
/**计算和
* ryuuninbou
* @return int
*/
private int getMinus(){
int sum1=0;
int sum2=0;
for (int i = 0; i < arr1.length; i++) {
sum1+=arr1[i];
}
for (int i = 0; i < arr2.length; i++) {
sum2+=arr2[i];
}
return Math.abs(sum1-sum2);
} 我觉得你这个应该是n^3，当然如果优化一下求和过程，可以降得到n^2。
你能证明这个算法的正确性吗？
11 楼
Excalibur
2011-03-24
liuningbo 写道
是一对一交换，不过数组不一定等长吧，
对对，脑子坏了，呵呵
10 楼
liuningbo
2011-03-24
Excalibur 写道
ggzwtj 写道
楼主有用过背包算法，就是传说中的小偷想偷东西，但是包包的容量是有限的，拿那些东西才能取得最多的东西。
其实可以换个角度想问题，就可以把楼主的问题转换成背包问题了：
如果想让两个数组的和之差最小，这不就是让两个数组的和都非常接近总和的一半！当然很多情况下是不能是得两个数组的和相等，都等于总和的一半。
如果不想等的话，必然有一个数组的和是小于总和一半的。我们要做的就是怎么让这个小的部分最接近总和的一半。
所以，这个问题应该可以转化成0-1背包问题，而这个包的大小就是所有数总和的一半，最后我们要求的是用一定量的数字怎么把这个包装得最满。
所以，这不是一个NP问题。
ps：如果我对楼主的描述没有理解错的话。:)
其实可以换个角度想问题，就可以把楼主的问题转换成背包问题了：
如果想让两个数组的和之差最小，这不就是让两个数组的和都非常接近总和的一半！当然很多情况下是不能是得两个数组的和相等，都等于总和的一半。
如果不想等的话，必然有一个数组的和是小于总和一半的。我们要做的就是怎么让这个小的部分最接近总和的一半。
所以，这个问题应该可以转化成0-1背包问题，而这个包的大小就是所有数总和的一半，最后我们要求的是用一定量的数字怎么把这个包装得最满。
所以，这不是一个NP问题。
ps：如果我对楼主的描述没有理解错的话。:)
这个公式我想不出来，尤其是要考虑包内个数必须为数组的长度 交换的意思应该是两个数组长度一致，1对1交换吧
是一对一交换，不过数组不一定等长吧，
9 楼
Excalibur
2011-03-24
ggzwtj 写道
楼主有用过背包算法，就是传说中的小偷想偷东西，但是包包的容量是有限的，拿那些东西才能取得最多的东西。
其实可以换个角度想问题，就可以把楼主的问题转换成背包问题了：
如果想让两个数组的和之差最小，这不就是让两个数组的和都非常接近总和的一半！当然很多情况下是不能是得两个数组的和相等，都等于总和的一半。
如果不想等的话，必然有一个数组的和是小于总和一半的。我们要做的就是怎么让这个小的部分最接近总和的一半。
所以，这个问题应该可以转化成0-1背包问题，而这个包的大小就是所有数总和的一半，最后我们要求的是用一定量的数字怎么把这个包装得最满。
所以，这不是一个NP问题。
ps：如果我对楼主的描述没有理解错的话。:)
其实可以换个角度想问题，就可以把楼主的问题转换成背包问题了：
如果想让两个数组的和之差最小，这不就是让两个数组的和都非常接近总和的一半！当然很多情况下是不能是得两个数组的和相等，都等于总和的一半。
如果不想等的话，必然有一个数组的和是小于总和一半的。我们要做的就是怎么让这个小的部分最接近总和的一半。
所以，这个问题应该可以转化成0-1背包问题，而这个包的大小就是所有数总和的一半，最后我们要求的是用一定量的数字怎么把这个包装得最满。
所以，这不是一个NP问题。
ps：如果我对楼主的描述没有理解错的话。:)
这个公式我想不出来，尤其是要考虑包内个数必须为数组的长度 交换的意思应该是两个数组长度一致，1对1交换吧
发表评论
相关推荐
实验室管理系统 微信小程序+SSM毕业设计 源码+数据库+论文+启动教程 项目启动教程：https://www.bilibili.com/video/BV1BfB2YYEnS
基于java的苹果网吧计费管理系统设计与实现.docx
纸中世界-跳跃游戏.sb3
本操作指导用于在 ENA 系列网络分析仪 E5080B 上自定义校准件。目前 Keysight 网络分析仪的 PNA 系列 N52xxB、P50xx 系列、P937x 系列、PXI 板卡式网分以及 ENA 系列的 E5080B、E5081B 的操作界面均统一到如下界面，操作方式相同。
调查海域浮游动物各类群栖息密度的空间分布表格.docx
本项目“高校毕业生就业管理系统”是一套基于SSM框架（Spring+SpringMVC+MyBatis）精心开发的Java Web应用，旨在为高校毕业生、高校就业指导部门以及企业用户提供一个高效、便捷的就业信息管理平台。 系统主要功能包括：学生用户可以查看和发布个人简历，搜索并筛选合适的工作岗位，申请心仪的职位；企业用户可以发布招聘信息，筛选和查看应聘者的简历，进行面试邀请等操作；高校就业指导部门则可以对学生的就业情况进行统计和分析，以更好地提供就业指导服务。 此外，系统采用了B/S架构，用户只需通过浏览器即可访问，无需安装客户端软件，方便快捷。数据库设计合理，数据存储安全，系统性能稳定。 本项目的开发，不仅为计算机相关专业的学生提供了一个实践SSM框架的好机会，帮助他们更好地理解和掌握Java Web开发技术，还能有效提升高校毕业生的就业效率和质量。
电影剪辑 笔记MoviePy 最近升级到 v2.0，引入了重大的重大变化。有关如何更新 v2.0 代码的更多信息，请参阅本指南。MoviePy（在线文档在此处）是一个用于视频编辑的 Python 库剪切、连接、插入标题、视频合成（又名非线性编辑）、视频处理和创建自定义效果。MoviePy 可以读取和写入所有最常见的音频和视频格式，包括 GIF，并且可以在 Windows/Mac/Linux 上运行，并搭载 Python 3.9+。例子在此示例中，我们打开一个视频文件，选择 10 到 20 秒之间的子剪辑，在屏幕中心添加标题，然后将结果写入新文件# Import everything needed to edit video clipsfrom moviepy import *# Load file example.mp4 and keep only the subclip from 00:00:10 to 00:00:20clip = VideoFileClip("long_examples/example2.mp4").with_subcl
基于java的视频播放器系统设计与实现.docx
基于java的车辆出租管理系统设计与实现.docx
mqtt等协议的pcap文件
学习python
修木工施工规范及流程.docx
适用于 Windows/Linux 和 Python 3 (3.5/3.6/3.7) 的 Tensorflow Faster R-CNNtf-faster-rcnn使用 Python 3 在 Windows 和 Linux 上使用 Tensorflow Faster R-CNN这是在 Windows 和 Linux 上编译 Faster R-CNN 的分支。它深受这里和这里的出色工作的启发。目前，此存储库支持 Python 3.5、3.6 和 3.7。感谢@morpheusthewhite请注意我没有时间或意图修复此分支的所有问题，因为我不将其用于商业用途。我创建此分支只是为了好玩。如果您想做出任何承诺，我们非常欢迎。Tensorflow 已经发布了一个对象检测 API。请参考它。https: //github.com/tensorflow/models/tree/master/research/object_detection如何使用此分支安装 tensorflow，最好是 GPU 版本。按照说明操作。如果没有安装 GPU 版本，则需要注释掉代码中的所有 GP
Python是一种高级、解释型、面向对象的编程语言，以其简洁的语法、强大的功能和广泛的应用领域而著称。它无需事先编译，代码在运行时逐行解释执行，提供了极大的灵活性和快速开发的能力。Python支持多种数据类型，包括整数、浮点数、字符串、布尔值、列表、元组、字典和集合等，以及丰富的操作符和流程控制结构，使得开发者可以编写出复杂且灵活的代码。 Python拥有一个广泛的标准库，涵盖了文件操作、网络通信、文本处理、正则表达式、数学运算等多个领域，为开发者提供了大量的模块和函数。此外，Python还拥有丰富的第三方库，如NumPy、Pandas、Matplotlib等用于数据分析和可视化的库，以及Django、Flask等用于Web开发的框架，这些库和框架进一步扩展了Python的应用领域和功能。 Python在Web开发、数据科学、人工智能、自动化运维和游戏开发等多个领域都有广泛的应用。在Web开发方面，Python提供了Django和Flask等强大的Web框架，使得开发者可以轻松地开发出各种Web应用和网站。在数据科学领域，Python是数据科学家的首选工具，其强大的数据处理能力和丰
本项目是基于Python语言开发的西西家居全屋定制系统，旨在为家居行业提供一个高效、智能的定制解决方案。项目涵盖了从客户需求分析、设计方案生成、材料选购到最终订单生成的全过程，力求实现家居定制的数字化和智能化。 在主要功能方面，系统具备强大的客户管理模块，能够详细记录和分析客户的定制需求。设计模块则采用先进的三维建模技术，为客户提供直观、真实的家居设计方案预览。此外，系统还整合了丰富的材料数据库，方便客户根据自身喜好和预算进行材料选择。 框架方面，项目采用了B/S架构，确保了系统的稳定性和可扩展性。后端使用Python的Django框架，前端则结合了HTML、CSS和JavaScript等技术，实现了用户界面的友好和响应速度。 开发此项目的目的，不仅是为了满足家居行业对个性化定制的需求，也为计算机相关专业的学生提供了一个实践和学习的平台，有助于提升他们的实际开发能力。
Binance公共API连接器Python 这是一个轻量级库，可作为Binance 公共 API的连接器支持的 API/api/*/sapi/*现货 Websocket 市场动态现货用户数据流现货 WebSocket API包含测试用例和示例可定制的基本 URL、请求超时和 HTTP 代理可以显示响应元数据安装pip install binance-connector文档https://binance-connector.readthedocs.ioRESTful API使用示例from binance.spot import Spotclient = Spot()# Get server timestampprint(client.time())# Get klines of BTCUSDT at 1m intervalprint(client.klines("BTCUSDT", "1m"))# Get last 10 klines of BNBUSDT at 1h intervalprint(client.k
Aptana是一个非常强大,开源,JavaScript-focused的AJAX开发IDE。 Aptana的特点包括： 1JavaScript,HTML,CSS语言的Code Assist功能。 2Outliner(大纲)：显示JavaScript,HTML和CSS的代码结构。
学习自律养成小程序 微信小程序+SSM毕业设计 源码+数据库+论文+启动教程 项目启动教程：https://www.bilibili.com/video/BV1BfB2YYEnS
认知能力评估表.docx
数学建模学习资料 粒子群算法 先进算法讲义.pdf