精华内容
下载资源
问答
  • 分治算法题之数组元素求和

    千次阅读 2013-03-19 23:38:26
    题目只是给出个元素求和一个特例,我们可以把题目定义的更宽泛些。给定一个连续的自然数数组a(a[i]>0,a.length>0),求所有数据元素的加法运算,使得其和等于另一个给定的整数数值m (m>0)。  这是个分治算法的场景...

            前几天逛论坛,看到一个帖子里说到一个算法题目: 给出1到19的连续递增自然数数组,求所有和为20的可能元素加法组合。每个加法组合中的元素不能重复使用。 题目只是给出个元素求和一个特例,我们可以把题目定义的更宽泛些。给定一个连续的自然数数组a(a[i]>0,a.length>0),求所有数据元素的加法运算,使得其和等于另一个给定的整数数值m (m>0)。

            这是个分治算法的场景,题目的出发点如下

    • 得到给定的m,可能要通过多步加法运算得到。一次性得出结果往往很难。但我们可以将加法步骤进行拆分,每次拆分可以穷举出所有的可能排列。比如m=10,那么两步加法得到10的排列会有几种? 很明显 [0,10],[1,9],[2,8],[3,7],[4,6],[5,5],[6,4],[7,3],[8,2],[9,1],[10,0] 就是所有的穷举结果。
    • 在每次进行步骤一的加法拆分时,可以将数组同时按照中间位置进行拆分。并将步骤一得到的加法穷举结果代入。如此递归,直至数组中只有一个元素存在。

           如下以a=[1,2,3,4,5,6,7,8,9], m=10为例对步骤进行一下说明

           1. 将m进行两步加法划分得到[0,10],[1,9],[2,8],[3,7],[4,6],[5,5],[6,4],[7,3],[8,2],[9,1],[10,0] 所有的穷举结果。

           2. 将数组从中间数进行划分得到两个子数组left = [1,2,3,4,5] ,right =[6,7,8,9],如下图所示

           3. 对所有加法组合及对应子数组进行递归拆分求解,这里以加法组合[10,0]为例进行展开,如下图示


                 如上图所示, 子数组[6,7,8,9] 求和为0的可能组合很明显根本不需要去求。我们只关心子数组[1,2,3,4,5] 求和为10的所有组合即可。那同样对10和子数组[12,3,4,5]进行同样的拆分。我们还可以继续拆分,直到数组中只有一个元素为止。但在这一步,我们直观上已经很明显能看出可能的组合结果如下图


    4. 将数组[1,2,3,4,5] = 10,和[6,7,8,9] = 0 两个数组的求解结果进行合并,就是我们所要的对于[10,0]这个加法拆分方式的结果。

    代码如下

    import java.util.Arrays;
    
    public class EqualsTeller {
    
    	/**
    	 * 将两个一维数组left[m],right[j]合并成m[m+j]数组。
    	 */
    	private int[] merge(int[] left,int[] right){
    		int[] m = new int[left.length + right.length];
    		System.arraycopy(left,0,m,0,left.length);
    		System.arraycopy(right, 0, m, left.length, right.length);
    		return m;
    	}
    	/**
    	 * 将二维数组left[m][x] 和 right[n][y]数组合并为二维数组 merge[m*n][x+y]
    	 */
    	private int[][] crossMerge(int[][] left,int[][] right){
    		
    		if (left[0][0] == 0)
    			return right;
    		if (right[0][0] == 0)
    			return left;
    		
    		int[][] m = new int[left.length * right.length][];
    		int row = 0;
    		for (int i=0;i< left.length;i++){
    			for (int j=0;j< right.length;j++){
    				int[] l = left[i];
    				int[] r = right[j];
    				m[row] = merge(l,r);
    				row++;
    			}
    		}
    		
    		return m;
    		
    		
    	}
    	
    	private int[][] appendMerge(int[][] left,int[][] right){
    		int[][] m = new int[left.length + right.length][];
    		for (int i=0;i< left.length;i++){
    			     m[i] = left[i];
    		}
    		for (int i=left.length;i< m.length;i++){
    			    m[i] = right[i - left.length];
    
    		}
    		
    		return m;
    		
    		
    	}
    	
    	
    	/**
    	 * 给定数组 a,和一个大于零的数值sum. 找出所有合计值为sum的加法运算,加法运算中所有的元素必须来自数组a,且不能重复。
    	 * @param a 给定的数组。数组中的元素必须是连续的,递增的。例如[1,2,3,4,5,6,7,8,9]
    	 * @param sum 假定的合计值。要求大于零。
    	 * @return 二维数组,含有所有可能加法组合的方案。
    	 */
    	private int[][] findEqualFormula(int[] a,int sum){
    		boolean valid_flag = false;
    		int[][] m = new int[0][0];
    		
    		if (sum == 0){ //如果传入的sum是零的话,则无需再当前数组a中寻找可能的加法解。直接返回{{0}};
    			m = new int[1][1];
    		    m[0] = new int[]{0};
    		}
    		else
            if (a.length > 1){
                if (sum < a[0]){ //小于数组中最小值,返回{{-1}}即当前数组无法得出对应的Sum值。
                	m = new int[1][1];
        		    m[0] = new int[]{-1};
                }else if (sum > (a[0] + a[a.length -1])*(a.length)/2){ //大于数组和,返回{{-1}}即当前数组无法得出对应的Sum值。
                	m = new int[1][1];
        		    m[0] = new int[]{-1};
                }else{
                 int middle = (a.length -1)/2; //取中间数,然后对数组进行左右划分。
        		 int[] left  = Arrays.copyOfRange(a, 0, middle+1);
        	     int[] right = Arrays.copyOfRange(a, middle+1, a.length);
        		 for (int i=0;i<=sum;i++){//通过for循环将Sum值得所有两步运算进行穷举。
        			int[][] la = findEqualFormula(left,i);//递归调用,直到传入的数组中只有一个元素为止
        			if (la[0][0] == -1) //如果返回{{-1}},则说明上述数组left元素无法通过加法运算得到对应的Sum值。这时,则说明当前for循环中的两步运算组合无效。忽略当前运算组合,继续下一个组合的尝试。
        				continue;
        			int[][] ra= findEqualFormula(right,sum - i);//递归调用,直到传入的数组中只有一个元素为止
                    if (ra[0][0] == -1) //如果返回{{-1}},则说明上述数组right元素无法通过加法运算得到对应的Sum值。这时,则说明当前for循环中的两步运算组合无效。忽略当前运算组合,继续下一个组合的尝试。 			
        			    continue;
                    int[][] ma = crossMerge(la,ra);//如果上述两个递归方法返回有效的元素组合,则将元素进行交叉合并,得出当前数组元素中可用的加法组合
                    m = appendMerge(m,ma);
                    valid_flag = true;
        		 }
        		 if (!valid_flag){ // 如果for循环中所有穷举的两步运算组合都不适用,则返回{{-1}}
        			 m = new int[1][1];
        			 m[0] = new int[]{-1};
        		 }
        		 
                }
    
            }else if (a.length == 1){
            	m = new int[1][1];
            	if (a[0] == sum) //如果分解到数组中只有一个元素时,如果与sum值相等,则是我们需要找的值。返回数组{{a[0]}}
            		m[0] = new int[]{a[0]};
            	else
            		m[0] = new int[]{-1};//如果分解到数组中只有一个元素时,如果与sum值不相等,则说明数组中的值无法通过求和得到我们的预期结果。返回数组{{-1}}
            }
            
         return m;   
    
    	}
    	
    }
    

    运行结果如下 以[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19] = 20 为例


    1 19 
    2 18 
    3 17 
    1 2 17 
    4 16 
    1 3 16 
    5 15 
    1 4 15 
    2 3 15 
    6 14 
    1 5 14 
    2 4 14 
    1 2 3 14 
    7 13 
    1 6 13 
    2 5 13 
    3 4 13 
    1 2 4 13 
    8 12 
    1 7 12 
    2 6 12 
    3 5 12 
    1 2 5 12 
    1 3 4 12 
    9 11 
    1 8 11 
    2 7 11 
    3 6 11 
    1 2 6 11 
    4 5 11 
    1 3 5 11 
    2 3 4 11 
    1 9 10 
    2 8 10 
    3 7 10 
    3 8 9 
    1 2 7 10 
    1 2 8 9 
    4 6 10 
    4 7 9 
    1 3 6 10 
    1 3 7 9 
    5 6 9 
    5 7 8 
    1 4 6 9 
    1 4 7 8 
    2 3 6 9 
    2 3 7 8 
    1 5 6 8 
    2 4 6 8 
    1 2 3 6 8 
    2 5 6 7 
    3 4 6 7 
    1 2 4 6 7 
    1 4 5 10 
    2 3 5 10 
    1 2 3 4 10 
    2 4 5 9 
    1 2 3 5 9 
    3 4 5 8 
    1 2 4 5 8 
    1 3 4 5 7 
    2 3 4 5 6 
    


    展开全文
  • 让自己经常做些算法训练, 目前在LeetCode上面找Easy类型的做起, 俗话说柿子要挑软的捏嘛. Problem => Algorithms => Two Sum 一个非常简单的题目: 幸亏下面有Example说明, 不然我以为用两个元素的Index...

    让自己经常做些算法训练, 目前在LeetCode上面找Easy类型的做起, 俗话说柿子要挑软的捏嘛.
    一个非常简单的题目:
    在这里插入图片描述
    幸亏下面有Example说明, 不然我以为用数组中两个元素的Index相加, 尴尬⊙﹏⊙‖∣
    二话不说, 直接上双层for循环:

    public int[] twoSum(int[] nums, int target) {
            for(int i = 0; i < nums.length - 1; i ++){
                for(int j = i + 1; j < nums.length; j ++){
                    if(nums[i] + nums[j] == target) {
                        return new int[]{i, j};
                    }
                }
            }
            throw new IllegalArgumentException("No two sum solution");
        }
    

    嗯, 说到最后面一行抛异常, 我最开始是return null, 要善用异常处理, 后面我会专门花一块时间学一下.

    看了答案, 我的解法被归类于暴力法(Brute force), 有点儿尴尬. 说实话, 虽然很久没写代码, 但是我其实觉得我的变成思想是有所提升的.

    瞄了一下第二个解法----Two-pass Hash Table

    public int[] twoSumMap(int[] nums, int target){
            Map<Integer, Integer> map = new HashMap<Integer, Integer>();
            for(int i = 0; i < nums.length; i ++){
                map.put(nums[i], i);
            }
            for(int i = 0; i < nums.length; i ++){
                int complement = target - nums[i];
                if(map.containsKey(complement) && map.get(complement) != i){
                    return new int[] {i, map.get(complement)};
                }
            }
            throw new IllegalArgumentException("No two sum solution");
        }
    

    原来是用了Hash Map进行两次遍历, 豁然开朗, 第一次遍历将数组中所有的元素和下标, 以key:value的形式组装成map, 元素是key, 下标是value.
    在此遍历数组时, 用target - nums[i] 的值去map中判断, true时成功.

    两个对比一下, 第二种方法最多只是完整的遍历2次, 但是第一种方法会随着数组元素数量的增多, 而使执行时间的增长远超于第二种方法.

    这里关于时间复杂度方面就不写了, 因为不懂, 出差不方便, 等回家要啃《算法》

    另外第三种解法就更效率了-------One-pass Hash Table

    public int[] twoSumMapOneFor(int[] nums, int target){
            Map<Integer, Integer> map = new HashMap<Integer, Integer>();
            for (int i = 0; i < nums.length; i++) {
                int complement = target - nums[i];
                if(map.containsKey(complement)){
                    return new int[]{map.get(complement), i};
                }
                map.put(nums[i], i);
            }
            throw new IllegalArgumentException("No two sum solution");
        }
    

    可以看出这段代码非常高效, 一次遍历就搞定, 并且因为实在if语句结束后才执行map的put方法, 所以不需要判断是否为同一个数组元素, 因为当前元素还没进入map中.

    总结一下, 后两种方法一看就明白, 说明并没有超出自己的能力或技术范围, 说明自己需要提升自己的经验并多做相关的训练和学习. 另外就是自己以前写代码的时候, map用的少, 所以没有第一时间想到它. 还有就是这个题目太简单了, 写文字的时间远大于写代码加思考的时间, 性价比太低, 以后这种简单的题目我就简单总结.

    展开全文
  • 题目: 给定一个整形数组和一个整数target,返回2个元素的下标,它们满足相加的和为target。你可以假定每个输入,都会恰好有一个满足条件的返回结果。 思路: 一次遍历即可,借助一个Map用于存储value-index,每次去...
    二数之和

    题目: 给定一个整形数组和一个整数target,返回2个元素的下标,它们满足相加的和为target。你可以假定每个输入,都会恰好有一个满足条件的返回结果。

    思路: 一次遍历即可,借助一个Map用于存储value-index,每次去map中get差值,如果为null,则将当前值存入,否则,即找到对应的匹配。注,遍历到两者中的后一个元素时才会找到匹配。

    class Solution {
    	public int[] twoSum(int[] nums, int target) {
    		int[] result = new int[2];
    		Map<Integer, Integer> tempMap = new HashMap<>();
    		for (int i = 0; i < nums.length; i++) {
    			int temp = target - nums[i];
    			if (tempMap.containsKey(temp)) {
    				result[0] = tempMap.get(temp);
    				result[1] = i;
    				return result;
    			} else {
    				tempMap.put(nums[i], i);
    			}
    		}
    		result[0] = 0;
    		result[1] = 0;
    		return result;
    	}
    }
    
    三数之和

    题目: 给定一个数组S,它包含n个整数,它是否存在3个元素a,b,c,满足a+b+c=0?找出所有满足条件的元素数组。提示:a,b,c三个元素必须是升序排列(也就是满足a ≤ b ≤ c),最终的结果不能包含重复的元素数组。例如给定S为{-1 0 1 2 -1 -4},返回结果是(-1, 0, 1)和(-1, -1, 2)。

    思路: 遍历数组建立Map(value-indexList),排序数组,三层循环变为二层,最内层根据差值查询Map即可,以下点可以加快搜索进度

    • 如果第一层循环获得的起始值已经大于0,则直接break。
    • 如果待查找的第三个数的值已经小于第二个数,则直接break。
    • 第一层、第二层从第二次循环开始,如果当前值和前一个值相等,则continue。
    	public List<List<Integer>> threeSum(int[] nums) {
    		List<List<Integer>> res = new ArrayList<>();
    		// nums先进行排序
    		Arrays.sort(nums);
    		Map<Integer, List<Integer>> map = new HashMap<>();
    		for (int i = 0; i < nums.length; i++) {
    			int num = nums[i];
    			if (map.get(num) == null) {
    				List<Integer> subscripts = new ArrayList<>();
    				subscripts.add(i);
    				map.put(num, subscripts);
    			} else {
    				map.get(num).add(i);
    			}
    		}
    		for (int i = 0; i <= nums.length - 3; i++) {
    			if (nums[i] > 0) {
    				break;
    			}
    			if (i > 0 && nums[i] == nums[i - 1]) {
    				continue;
    			}
    			for (int j = i + 1; j <= nums.length - 2; j++) {
    				if (j > i + 1 && nums[j] == nums[j - 1]) {
    					continue;
    				}
    				int finalNum = -nums[i] - nums[j];
    				if (finalNum < nums[j]) {
    					break;
    				}
    				List<Integer> subscripts = map.get(finalNum);
    				if (subscripts == null) {
    					continue;
    				}
    				for (Integer subscript : subscripts) {
    					if (subscript != j && subscript != i) {
    						List<Integer> list = new ArrayList<>();
    						list.add(nums[i]);
    						list.add(nums[j]);
    						list.add(nums[subscript]);
    						res.add(list);
    						break;
    					}
    				}
    			}
    		}
    		return res;
    	}
    
    展开全文
  • Scala数组 唐刚 常用算法 sum求和:元素类型必须是数值类型 array.sum min和max输出数组中最小和最大的元素 array.min array.max sorted将数组元素排序 array.sorted mkString指定元素之间的分隔符显示数组元素 array...
  • 给定一个数组x,每个元素都是正整数,找出其中满足条件“求和等于y”的所有子数组。(简化问题,每个元素都不相等) x=[x1,...,xn],暴力搜索,复杂度O(2^n),不可取。 动态规划思路。构建矩阵A: A[j,i]=k,如果k!...

    算法记录:
    给定一个数组x,每个元素都是正整数,找出其中满足条件“求和等于y”的所有子数组。(简化问题,每个元素都不相等)
    x=[x1,...,xn],暴力搜索,复杂度O(2^n),不可取。
    动态规划思路。构建矩阵A:

    • A[j,i]=k,如果k!=-1,表示数组[x1,...,xk]包含求和等于j的子数组,如果k=-1,表示数组[x1,...,xi]不包含求和等于k的子数组。
    • 最终需要返回能构成求和等于y的子数组,则先看A[y, :]行,检测是否有不等于-1的值,如果有,例如A[y,z],则说明[A1, ..., Az]包含目标子数组,并且Az是其中的元素。
      接下来迭代地求解求和等于y-xz的子数组。

    算法实现如下,下面的算法只找出了一个子数组,稍作修改可以找出所有子数组。
    矩阵A非常稀疏,可以通过优化的数据结构减少开销。

    import numpy as np
    
    x = [1,2,3,4]
    
    n = len(x)
    M = sum(x) + 1
    A = (np.ones(M * n)*-1).reshape(M, n)
    
    ## 计算矩阵A
    i = 0
    A[x[i], i] = i
    
    for i in range(1, n):
        for j in range(M):
            if A[j, i - 1] != -1 and j + x[i] < M:
                A[j + x[i], i] = i
                A[x[i]    , i] = i
    
    print(A)
    y=4
    
    ## 寻找子数组
    res = []
    while y > 0:
        idss = (A[y]>=0)
        if idss.any():
            idss = A[y, idss]
            ids = int(idss[0])
            res.append(ids) 
            y = int(y - x[ids])
        else:
            break
    
    print(res)
    

    转载于:https://www.cnblogs.com/luweiseu/p/9922115.html

    展开全文
  • 题目假设给你的数组总是有且只有一个解,而且同一个元素不能使用两次,另外返回的下标要从1开始。 如果找不到我们返回[-1,-1] public class Three { //Time:O(n),Space:O(1) public int[] ...
  • Java数组中常见算法

    2021-02-21 21:07:27
    文章目录系列文章目录数组元素的赋值:杨辉三角回形数数值类型的计算:求和最大值、最小值平均值数组的复制:数组的反转:数组的查找:线性查找:二分查找:数组元素的排序:冒泡排序 O(n²):快速排序O(log2n): ...
  • Scala入门_数组的常用算法

    千次阅读 2020-02-07 16:49:00
    数组常用算法 scala中的数组封装了一些常用的计算操作,将来在对数据处理的时候,不需要我们自己再重新实现。以下为常用的几个算法求和——sum方法 求最大值——max方法 求最小值——min方法 排序——sorted...
  • 最近在研究怎样使算法效率提高的问题,涉及到一个数组元素求和问题,假设一个数组A[ARRAY_SIZE],求数组里面所有元素的和。我以前所能想到的就是o(n)的算法,遍历数组,使用一个变量sum依次加上数组的元素。但是,...
  • 1-递归实现数组求和 2-一个变量二维数组 3-递归判断数组递增 4-排序数组中查找指定元素重复出现次数 5-无序数组的交集 6-有序数组的交集 7-重复次数最多的元素 8-On时间复杂度中寻找数组中出现一半以上的数 9-求解...
  • jq数组求和

    2018-07-25 10:11:00
    题目描述计算给定数组 arr 中所有元素的总和输入描述:数组中的元素均为 ...arr.slice(1)表示返回从下标为1开始的所有数组元素//不考虑算法复杂度,用递归做 function sum(arr){ var len=arr.length; if(len...
  • 一、连续数组求和 Leetcode 53 最大子序和 题目描述:给定一个整数数组 nums ,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。 示例: 输入: [-2,1,-3,4,-1,2,1,-5,4], 输出: 6 ...
  • 文 | Edward5.4 数组元素的排序通常情况下,我们对数组的操作远远不止遍历判断大小或者判断奇偶数这么简单。比如,当我们需要求一个数组中所有元素的平均值时,操作很简单,只需要去遍历这个数组,并将其内部所有...
  • 距上一篇双指针的算法介绍已有四个月,换了个忙碌的工作,没...上一节是几个经典的求和问题,这一节是元素交换的几个典型场景。 应用场景之元素交换 26. Remove Duplicates from Sorted Array Given a sorted a...
  • 知识点:数组练习 ...1、输出数组中的最大元素 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ConsoleApp2 { ...
  • JS 数组求和

    千次阅读 2018-12-31 00:58:05
    数组中的元素均为 Number 类型 输入样例: [ 1, 2, 3, 4 ] 输出样例: 10 源代码: (来源作者:牛客网O.z.) 不考虑算法复杂度,用递归来实现: function sum(arr) {  var len = arr.length;  if(len...
  • 双指针算法的第三篇,题目的类型与前面都不同,鄙人给这个思想起了个不太合适的名字——滑动窗,其实与第一种两数求和的思想差不多,不同点大概是,滑动窗强调的是双指针之间的数组求和问题只是一头一尾的遍历操作...
  • 数组求和-JS

    2019-10-05 11:57:56
    数组中的元素均为 Number 类型 示例1 输入 [ 1, 2, 3, 4 ] 输出 10 不考虑算法复杂度,用递归做: 1 2 3 4 5 6 7 8 9 10 function ...
  • 普通迭代法,求解一个n个数组元素的和vector<int> v = { 4, 7, 8, 32, 7,9 }; int sum = 0; for (int i = 0; i < v.size(); i++) { sum += v[i]; } return sum; 时间复杂度T(n) = 1 + n * 1 + 1 = n + 2...
  • 如何递归实现数组求和

    千次阅读 2015-05-14 09:27:19
    如何用递归实现数组求和 给定一个含有n个元素的整形数组a,求a中所有元素的和. 非递归算法: int sumr(int *a,int n) { int sum=0; for(int i=0;i;i++) sum+=a[i]; return sum; } 递归算法: int sum...
  • js数组求和的5种方法

    2020-10-27 10:29:06
    js数组求和的5种方法 题目描述 计算给定数组 arr 中所有元素的总和 输入描述: 数组中的元素均为 Number 类型 输入例子: sum([ 1, 2, 3, 4 ]) 输出例子: 10 1、不考虑算法复杂度,用递归做: function ...
  • 给定一个非空整数数组,找到使所有数组元素相等所需的最小移动数,其中每次移动可将选定的一个元素加1或减1。 您可以假设数组的长度最多为10000。 二.示例 三.算法分析 先对列表进行排序,防止得到不是最小...
  • 这是算法题未排序数组中累加和为给定值的最长子数组系列问题的一种情况,数组元素只有1,-1,要求和为0的最长子数组。这道题的结果就是比较和为0的子数组长度,哪个最长,结果就是哪一个。例如: 这里最暴力的...
  • 本文实例总结了JS数组求和的常用方法。分享给大家供大家参考,具体如下: 题目描述 计算给定数组 arr 中所有元素的总和 输入描述: 数组中的元素均为 Number 类型 输入例子: sum([ 1, 2, 3, 4 ]) 输出例子: 10 ...
  • scala的数组常用算法

    千次阅读 2020-02-09 18:40:08
    数组常用算法 scala中的数组封装了一些常用的计算操作,将来在对数据处理的时候,不需要我们自己再重新实现。以下为常用的几个算法求和——sum方法 求最大值——max方法 求最小值——min方法 排序——sorted方法 ...
  • 以递归方法求数组元素的和,要求分别求偶、奇下标的和,再求总和 注意:此题很明显用递归并不简便,但为了锻炼同学们递归的思想并熟练其用法,要求以递归方法解答。 输入格式 一行输入,数字以空格隔开,下标...
  • Java数组常用算法

    2018-09-18 11:46:52
    找出数组中的最大值: double[] a = new double[N]; double aMax = a[0]; for(int i = 1; i &...计算数组元素的平均值:实现思路,先求和,再计算平均值。 double[] a = new double[N]; int n ...
  • [编程题]数组求和

    2016-11-21 18:49:00
    输入描述: 数组中的元素均为 Number 类型 输入例子: sum([ 1, 2, 3, 4 ]) 输出例子: 10 不考虑算法复杂度,用递归做: function sum(arr) { var len = arr.length; if(len == 0){ return...
  • 本文实例总结了JS数组求和的常用方法。分享给大家供大家参考,具体如下:题目描述计算给定数组 arr 中所有元素的总和输入描述:数组中的元素均为 Number 类型输入例子:sum([ 1, 2, 3, 4 ])输出例子:10方法1.不考虑...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 287
精华内容 114
热门标签
关键字:

数组元素求和算法