• 三层for循环怎么优化
千次阅读
2021-07-16 14:18:29

举🌰：

五个盒子，每个盒子里面有3个球（数字表示），每次每个盒子取一个，求组合数，球编号之和。

方法一：for 循环--多层嵌套

box,box1,box2 =  [0,1,2],[0,3,4],[0,5,6]    # 0，1，2 三个盒子，数字代表球的种类
box3,box4,box5 = [0,5,6],[0,3,4],[0,1,2]    # 3，4，5 三个盒子
Box = [box,box1,box2,box3,box4,box5]
count = 0
# methond 1
for a in Box[0]:
for b in Box[1]:
for c in Box[2]:
for d in Box[3]:
for e in Box[4]:
for f in Box[5]:
print((a,b,c,d,e,f),sep = ',')
sum = a+b+c+d+e+f
print("sum:",sum)
count  += 1
print("count:",int(count))

# 运行结果(展示一部分）
..............
(2, 4, 6, 6, 3, 2)
sum: 23
count: 726
(2, 4, 6, 6, 4, 0)
sum: 22
count: 727
(2, 4, 6, 6, 4, 1)
sum: 23
count: 728
(2, 4, 6, 6, 4, 2)
sum: 24
count: 729

方法一代码太low了，脸上挂不住啊～

方法二：python内置itertools迭代器，具体介绍可以看一下这位小哥的博客：

https://blog.csdn.net/u013300049/article/details/79313979

import itertools

box,box1,box2 =  [0,1,2],[0,3,4],[0,5,6]
box3,box4,box5 = [0,5,6],[0,3,4],[0,1,2]
Box = [box,box1,box2,box3,box4,box5]
count = 0
# methond 2
for i in itertools.product(box,box1,box2,box3,box4 ,box5):
print(i)
count += 1
print("sum:",sum(i))
print("count:",count)

# 结果（展示部分）
..............
(2, 4, 6, 6, 3, 2)
sum: 23
count: 726
(2, 4, 6, 6, 4, 0)
sum: 22
count: 727
(2, 4, 6, 6, 4, 1)
sum: 23
count: 728
(2, 4, 6, 6, 4, 2)
sum: 24
count: 729

总结：如果这篇博客让你有多一点点了解编程知识，那就点个赞吧！

更多相关内容
• ## 多层for循环优化

千次阅读 2019-05-12 13:33:51
1.6.1 找出最大周长的三角形 /*可以用穷举找出最长，三重循环。*/ for (i = 0; i ;++i) { for (j = i + 1; j ; ++j) { for (k = j + 1; k ; ++k) { len = b[i] + b[j] + b[k]; m
• 1.6.1 找出最大周长的三角形
/*可以用穷举找出最长，三重循环。*/
for (i = 0; i < a;++i) {
for (j = i + 1; j < a; ++j) {
for (k = j + 1; k < a; ++k) {
len = b[i] + b[j] + b[k];
ma = max(b[i], max(b[j], b[k]));
ans = len - ma;
if (ma < ans) { z = max(z, len); }
}
}
}


• 1.6.2 Ants（POJ No.1852）
Description
An army of ants walk on a horizontal pole of length l cm, each with a constant speed of 1 cm/s. When a walking ant reaches an end of the pole, it immediatelly falls off it. When two ants meet they turn back and start walking in opposite directions. We know the original positions of ants on the pole, unfortunately, we do not know the directions in which the ants are walking. Your task is to compute the earliest and the latest possible times needed for all ants to fall off the pole.
/*2只蚂蚁相遇，把它看成相遇后还是沿原方向前行结果也是一样的*/
for (i = 0; i < n; ++i) {
mint = max(mint, min(x[i], L - x[i]));
}
for (i = 0; i < n; ++i) {
maxt = max(maxt, max(x[i], L - x[i]));
}


• 1.6.3 抽签问题
你的朋友提议玩一个游戏，将写有数字的n个纸片放入口袋中，你可以从口袋中抽取4次纸片，每次记下纸片上的数字后都将其放回口袋中，如果这四个数字的和为m,
就是你赢，否则就是你的朋友赢，你挑战了好几次，结果一次也没有赢，于是撕破口袋，取出所有的纸片，检查自己是否有赢的可能性。
请编写一个程序，判断当纸片上写的数字是K1，K2,K3,…,Kn 时，是否存在抽取四次和为m的情况，如果存在，输出Yes,若不存在，输出No。
/*如果n在合理范围内，可以直接四重循环穷举（循环：n^4）*/
bool f = false;
for (a = 0; a < n;++a) {
for (b =0; b < n;++b) {
for (c = 0; c < n;++c) {
for (d = 0; d < n;++d) {
if (k[a] + k[b] + k[c]+k[d]==m) {f = true;}
}
}
}
}

/*如果n过大，四重循环效率太慢，我们可以用二分搜索算法替换最内侧的循环*/
//循环：n^3logn ；排序：nlogn
bool binary_search(int *a,int n,int key) {
int low, high,mid;
bool f = false;
low = 0;
high = n;
while (low <= high) {
mid = (low + high) / 2;
if (key < a[mid]) { high = mid - 1; }
else if (key > a[mid]) { low = mid + 1; }
else {f = true; break;}
}
return f;
}
----------
sort(k,k+n);
bool f = false;
for (a = 0; a < n;++a) {
for (b = 0; b < n;++b) {
for (c =0; c < n;++c) {
if (binary_search(k, n, m - (k[a] + k[b] + k[c])))
{ f = true;}
}
}
}

/*同样道理，我们可以尝试用二分搜索来替换内侧两重循环;(循环：n^2logn；排序：n^2logn)*/
//先将内侧两重循环排好序
for (i = 0; i < n; ++i) {
for (int j = 0; j < n;++j) {
kk[i*n+j] = k[i] + k[j];
}
}
sort(kk,kk+n*n);
//再来搜索
bool f = false;
for (a = 0; a < n;++a) {
for (b = 0; b < n;++b) {
if (binary_search(kk,kk+n*n, m - (k[a] + k[b]))) { f = true; }
}
}

展开全文
• 今天就来说一下java代码优化的事情，今天主要聊一下对于for(while等同理)循环优化。作为大结构之一的循环，在我们编写代码的时候会经常用到。循环结构让我们操作数组、集合和其他一些有规律的事物变得更加的方便...

完成同样的功能，用不同的代码来实现，性能上可能会有比较大的差别，所以对于一些性能敏感的模块来说，对代码进行一定的优化还是很有必要的。今天就来说一下java代码优化的事情，今天主要聊一下对于for(while等同理)循环的优化。

作为三大结构之一的循环，在我们编写代码的时候会经常用到。循环结构让我们操作数组、集合和其他一些有规律的事物变得更加的方便，但是如果我们在实际开发当中运用不合理，可能会给程序的性能带来很大的影响。所以我们还是需要掌握一些技巧来优化我们的代码的。

嵌套循环

stratTime =System.nanoTime();for (int i = 0; i < 10000000; i++) {for (int j = 0; j < 10; j++) {

}

}

endTime=System.nanoTime();

System.out.println("外大内小耗时："+ (endTime - stratTime));

应改为：

stratTime =System.nanoTime();for (int i = 0; i <10 ; i++) {for (int j = 0; j < 10000000; j++) {

}

}

endTime=System.nanoTime();

System.out.println("外小内大耗时："+(endTime - stratTime));

两者耗时对比：

外大内小耗时：200192114

外小内大耗时：97995997

由以上对比可知，优化后性能提升了一倍，嵌套循环应该遵循“外小内大”的原则，这就好比你复制很多个小文件和复制几个大文件的区别。

提取与循环无关的表达式

fstratTime =System.nanoTime();for (int i = 0; i < 10000000; i++) {

i=i*a*b;

}

endTime=System.nanoTime();

System.out.println("未提取耗时："+(endTime - stratTime));

应改为：

stratTime =System.nanoTime();

c= a*b;for (int i = 0; i < 10000000; i++) {

i=i*c;

}

endTime=System.nanoTime();

System.out.println("已提取耗时："+(endTime - stratTime));

两者耗时对比：

未提取耗时：45973050

已提取耗时：1955

代码中a+b与我们的循环无关，所以应该把它放到外面，避免重复计算，可以看出，优化后性能提升了好几个数量级，这些是不容忽视的。

消除循环终止判断时的方法调用

stratTime =System.nanoTime();for (int i = 0; i < list.size(); i++) {

}

endTime=System.nanoTime();

System.out.println("未优化list耗时："+(endTime - stratTime));

应改为：

stratTime =System.nanoTime();int size =list.size();for (int i = 0; i < size; i++) {

}

endTime=System.nanoTime();

System.out.println("优化list耗时："+(endTime - stratTime));

两者耗时对比：

未优化list耗时：27375

优化list耗时：2444

list.size()每次循环都会被执行一次，这无疑会影响程序的性能，所以应该将其放到循环外面，用一个变量来代替，优化前后的对比也很明显。

异常捕获

stratTime =System.nanoTime();for (int i = 0; i < 10000000; i++) {try{

}catch(Exception e) {

}

}

endTime=System.nanoTime();

System.out.println("在内部捕获异常耗时："+(endTime - stratTime));

应改为：

stratTime =System.nanoTime();try{for (int i = 0; i < 10000000; i++) {

}

}catch(Exception e) {

}

endTime=System.nanoTime();

System.out.println("在外部捕获异常耗时："+(endTime - stratTime));

两者耗时对比：

在内部捕获异常耗时：12150142

在外部捕获异常耗时：1955

大家都知道，捕获异常是很耗资源的，所以不要讲try catch放到循环内部，优化后同样有好几个数量级的提升。

性能优化的内容有很多，代码优化只是其中一小部分，我们在日常开发中应养成良好的编码习惯。接下来会跟大家探讨更多关于性能优化的内容，希望大家积极交流指导。

展开全文
• ## 多重for循环优化，提升运行效率

万次阅读 多人点赞 2018-07-18 09:37:08
在循环次数较少的时候一般不会发现for循环的写法会对效率产生多大问题，但一旦循环次数较多，比如说上万，循环层数较多，效率问题就非常明显了，我是在做一个数据量非常大有三层for循环的项目的时候，为显示曲线出来...

在循环次数较少的时候一般不会发现for循环的写法会对效率产生多大问题，但一旦循环次数较多，比如说上万，循环层数较多，效率问题就非常明显了，我是在做一个数据量非常大有三层for循环的项目的时候，为显示曲线出来太花费时间，客户体验会非常不好，才研究这个情况的，事实证明，优化后的多重for循环提升了一大半的效率，是不是很神奇。 当然，本文也有借鉴其他同胞的方法。

1. 实例化变量放在for循环外，减少实例化次数，尽量只实例化一次；

2. 普通变量 改为 寄存器变量
i++ 改为 ++i

int i=0, j;
j=++i; //前置版本，运算对象先自增1，然后将改变后的对象作为求值结果，再赋值给j；
j=i++; //后置版本，先赋值给j；再运算对象自增1，但求值结果是运算对象改变之前那个值的副本.

C++Primer 中解释：前置版本的递增运算符避免了不必要的工作，它把值加1后直接返回改变了的运算对象。与之相比，后置版本需要将原始值存储下来以便于返回这个未修改的内容，如果我们不需要修改前的值，那么后置版本的操作就是一种浪费。

3. for(int i = 0; i<50; i++)
循环条件使用<要快于<=，>和>=同理;

4. 把外层可以计算的尽可能放到外层，减少在内层的运算，有判断条件的语句和与循环不相关的操作语句尽量放在for外面；

5. 应当将最长的循环放在最内层，最短的循环放在最外层，以减少CPU跨切循环层的次数；
采用的是行优先访问原则，与元素存储顺序一致。

6. 对于一个可结合和可交换的合并操作来说，比如整数的加法或乘法，
我们可以通过将一组合并操作分割成 2 个或更多的部分，并在最后合并结果来提高性能。
原理：
普通代码只能利用 CPU 的一个寄存器，分割后可以利用多个寄存器。
当分割达到一个数量时，寄存器用完，性能不再提升，甚至会开始下降。
用代码来描述，如下：

// 一般情况下的代码 for (i = 1; i < n+1; i++)
{
res = res OPER i;
}

// 循环分割后代码for (i = 1; i < n; i+=2)
{
res1 = res1 OPER i;
res2 = res2 OPER (i+1);
}

int 整数加法，性能测试结果对比如下：
整数的加法，普通代码运行 26s，循环分割后，18s。
浮点数计算的性能提升，明显大于整数，乘法的性能提升，略大于加法。

展开全文
• for循环1.首先知道，for循环的3个表达式的意思：表达式1： 一般为赋值表达式，给控制变量赋初值；表达式2： 关系表达式或逻辑表达式，循环控制条件；表达式3： 一般为赋值表达式，给控制变量增量或减量。3个表达式都...
• 求划线部分的执行次数为 for (int i = 1; i <= n; i++) { for (int j = 1; j <= i; j++) { for (int k = 1; k <= j; k++) { x=x+y; ...
• //方法 /*int i, j, leni, lenj; for( i =0 , leni = list1.size(); i ; i++) { for ( j = 0, lenj = list2.size(); j ; j++) { if (list1.get(i).getAge().equals(list2.get(j).getAge())) { list2.get(j)....
• 题目：有5个长度不一的数组a1、a2、a3、a4、a5，现各从数组中取出一个数，组成...题目挺简单，看一下就明白，然后第一时间用了一堆for循环，脚本如下： a1 = [1,2,4] a2 = [2,3,4,5] a3 = [1,4,7] a4 = [3,6,7,8] a5...
• for(int i = 1 ; i <= n ; i++) for(j = 1 ; j <= i ; j++) for(k = 1 ; k <= j ; k++) x++; T(n) = = = = = = = ...
• 前几天有人问过我一个问题，就是两个嵌套for循环执行效率的问题，问有什么好的办法替换。当时我想了想，实在想不起来，哎，惭愧！！！ 请教了答案，恍然大悟。比如：两个list中分别装有相同的对象数据。 list1中有3...
• 目标：将下面3层for循环的代码进行优化： #include #include #include using namespace std; typedef vector > lvec; long arr[1000][5000] = {}; long acculate(int, int); lvec& forarr(lvec&, long, ...
• 使用方式： 标签名: for (······) { ...主要就是代码块前写上一个标签，需要跳出多层循环的地方 break 标签名。 例子(可能不是很好)： flag: for (int i = 0; i <= 100; i++) { for (int j
• 对于for循环的嵌套问题 我们常见就是这样： for (int i = 0; i < 1000; i++){ for (int j = 0; j < 100; j++){ for (int k = 0; k < 10; k++){ system.out.println(i+"====="+j+"====="+k); } } } ...
• ## python for循环优化

千次阅读 2020-02-27 14:36:44
最初，建立项目时用户少，中间使用了for循环，还是嵌套的，共两，项目整体耗时1-2个小时。最近，随着用户量增长，项目耗时达到6-7个小时。显然是不能接受的。 for t, w in user_tags: for it, w in tag_items[t]:...
• 嵌套循环应该遵循“外小内大”的原则，当需要嵌套循环时，尽可能让外层循环越小，性能越好； 原来代码： long stratTime = System.nanoTime(); for (int i = 0; i < 10000000; i++) { for (int j = 0; j < ...
• ## c++ 对for循环的并行优化例子

万次阅读 多人点赞 2018-08-17 16:14:53
什么是并行优化？ 并行优化是代码优化的基本方法，从大到小一共可以分成级：异步框架；任务并行；数据并行。在实际工作中，一般是先...今天要讨论的是第步，for循环的并行优化。与前两者不同的是，for循环...
• 方法1.退出里外循环 使用return关键字 for (int i = 0;i<10;i++){ for (int j = 0; j<10; j++) { if (i<10){ System.out.println("retuen 跳出循环"); return; } } }
• ## C++多层for循环执行步骤讲解

千次阅读 多人点赞 2020-12-13 23:09:53
本篇文章主要讲解C++中多层for循环的执行步骤，并且进行实例演示。 for循环简介 for循环在工作中使用很频繁也很重要，常常用于retry以及遍历，for循环的常见语法为: 1.retry: 通常在信号交互中使用比较常见，循环...
• for循环单层循环执行流程：http://blog.csdn.net/asheandwine/article/details/76383304接下来看双层循环：循环嵌套是指在一个循环...最常见的是在for循环中嵌套for循环。格式如下for (初始化表达式; 循环条件; 操...
• ## 双重for循环（嵌套for循环）

万次阅读 多人点赞 2021-10-13 16:20:32
双重for循环就是在一个for循环里在嵌套另一个for循环，即两个循环嵌套，还有多重循环嵌套的情况，但用的比较少，一般常用的是两个循环嵌套，很少使用多重循环，因为for循环多了会导致代码执行的效率低，而且容易死机...
• 很多场景下，为了实现某一目标我们会使用多层for循环来解决问题，针对多层for循环如何使用openmp来进行加速，是
• ## for循环双层嵌套

万次阅读 多人点赞 2018-06-14 11:09:55
for循环的双层嵌套只要分为两种类型：内外嵌套独立、内外嵌套相关。1、内外嵌套独立：for(int i=0;i&lt;4;i++) { for(int j=0;j&lt;4;j++) { System.out.print("*"); //注意不是println。print将...
• 第一种： break次级循环，同时触发父级别的停止循环条件 for (int j = 0; j < 5; j++) { for (int i = 0; i < 24; i++) { if (StockMsg[i, j] =...
• ## 双层for循环的理解

千次阅读 2020-04-04 16:44:52
双层for循环对于我这种小白来说简直有点烧脑，因为刚接触JS的话，逻辑思维还没有培养起来，这个时候碰到这样的循环的时候就有些理解吃力了，下面我讲一下自己的理解，如果其他大佬有不同意见欢迎留言。 <script&...
• 在js中，多层for循环嵌套时，如果想在内循环到达某个条件时，终止外层循环，可以这样做： a:for(let i=0;i<10;i++){ b:for(let j=0;j<10;j++){ console.log(i,j) if(i==5){ continue a; } if(i==6){ ...
• ## 多线程优化for循环

千次阅读 2020-03-24 23:23:02
使用线程优化for循环操作 for循环里的操作用时太长，使用多线程分开执行，相当于一个工作多个人来做，比原先一个人做快！ package thread; import java.util.ArrayList; import java.util.List; import java.util....
• for(i=1;i<=N;i++) for(j=1;j<=i;j++) for(k=1;k<=j;k++) m++； 求时间复杂度 时间复杂度等于m的被执行的次数: i=1时,m被执行一次： i=2时,m被执行1+3=4次： i=3时, m被执行1+3+6=10次 ...
• ## 多层for循环的优化

千次阅读 2012-12-13 23:52:53
由于这7组数据个数比较多，当时我弱弱的写了7for循环，运行的时候感觉要算几个月。看来这程序必须优化一下才能跑。单纯的枚举法太耗时间了。   没有优化前的程序片段。 for (int s1 = 0; s1 (); s1++) { ...
• ## for循环三层嵌套 时间复杂度计算

万次阅读 多人点赞 2016-11-20 19:52:16
假设有这样一个for循环 for(i=1;i<=n;i++) for(j=1;j<=i;j++) for(k=1;k<=j;k++) x++; 现在要求它的时间复杂度，看起来有点麻烦，但是只要我们把问题分解成若干个小问题一一解决，那么就容易多了...
• 这篇博客提及个关于python循环优化细节，如有其他一些优化的方案，欢迎留言分享~QWQ 合理使用生成器（generator）和yield 在谈这个环节之前，我们先回顾一波何为生成器及何为yield 要理解yiled还需要理解...

...