leetcode算法实例---组合和枚举问题

最新推荐文章于 2023-01-17 23:41:46 发布
最新推荐文章于 2023-01-17 23:41:46 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： 解决方案 算法 誓必精通leetcode算法 文章标签： leetcode 算法 递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zkn_cs_dn_2013/article/details/77499039
版权

给定一列数(未排序)和一列目标值, 找出唯一的一个组合和等于目标值的组合, 数组中的数不能重复使用.

算法思路: 使用递归.

对数组排序, 从小到大;
令i = 起始下标(初始为0), 对于每一个数,
如果它等于目标值, 则在缓存结果中加入此数并将缓存结果加入输出队列, 随后在缓存结果中删除此数;
如果它小于目标值, 则在缓存结果中加入此数并递归调用此算法, 目标值更新为差值, 起始下标为i;
如果它大于目标值, 算法返回.
对于2.2的理解: 如果这个数小于目标值, 由于算法是循环递归, 那么起始的下标必定不能小于i(否则出现重复情况)
代码如下：

import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

/**
 * 将手续费作为一笔交易，如果拼凑不出来，则拆分剩余明细中金额最大的那笔交易
 * @author kenan.zhang
 * @date 2017-08-23
 */
public class Calc {

    public static void recursion(List<Integer> sourceList,LinkedList<Integer> tmpList,List<LinkedList<Integer>> resultList,Integer targetValue,int startIndex){
        for (int i = startIndex; i < sourceList.size(); i++) {
            Integer currentValue = sourceList.get(i);
            if(currentValue <= targetValue){
                if(currentValue.equals(targetValue)){
                    tmpList.add(currentValue);
                    resultList.add(new LinkedList<Integer>(tmpList));
                    tmpList.remove(currentValue);
                    break;
                }else if(currentValue < targetValue){
                    tmpList.add(currentValue);
                    recursion(sourceList, tmpList, resultList, targetValue-currentValue, i+1);
                    tmpList.remove(currentValue);
                    //只取第一个符合条件的数据组
                    if(resultList.size() == 1){
                        //从源数据列表中去掉已经使用过的数据
                        sourceList.removeAll(resultList.get(0));
                        break;
                    }
                }
            }else{
                break;
            }
        }

    }

    public static Map<Integer,LinkedHashMap<Integer,List<Integer>>> getResult(List<Integer> sourceList,List<Integer> targetValues){
        Collections.sort(sourceList);
        Collections.sort(targetValues);
        int startIndex = 0;
        List<Integer> remainTargetValues = new LinkedList<Integer>();
        Map<Integer,LinkedHashMap<Integer,List<Integer>>> resultMap = new LinkedHashMap<Integer,LinkedHashMap<Integer,List<Integer>>>();
        for(int i=0;i<targetValues.size();i++){
            Integer currentValue = targetValues.get(i);
            List<LinkedList<Integer>> resultList = new LinkedList<LinkedList<Integer>>();
            LinkedList<Integer> tmpList = new LinkedList<Integer>();
            recursion(sourceList, tmpList, resultList,currentValue, startIndex);
            if(resultList.size() == 0){
                remainTargetValues.add(currentValue);
                resultMap.put(currentValue, null);
            }else{
                LinkedHashMap<Integer,List<Integer>> res = new LinkedHashMap<Integer,List<Integer>>();
                //为了区分该汇总交易是否通过某笔交易明细拆分拼凑而来：如果子map的key为Integer.MAX_VALUE，否则对应的是被拆分的交易明细
                res.put(Integer.MAX_VALUE, resultList.get(0));
                resultMap.put(currentValue, res);
            }
        }
        //对最大的一笔交易进行拆分
        int lastIndex = sourceList.size()-1;
        Integer lastValue = sourceList.get(lastIndex);
        for(int i=0;i<remainTargetValues.size();i++){
            Integer targetValue = remainTargetValues.get(i);
            List<Integer> myTmpList = new LinkedList<Integer>();
            Integer gap = lastValue - sourceList.get(i);
            if(gap >= 0){
                myTmpList.add(sourceList.get(i));
                myTmpList.add(targetValue-sourceList.get(i));
                Collections.sort(myTmpList);
                LinkedHashMap<Integer,List<Integer>> res = new LinkedHashMap<Integer,List<Integer>>();
                //为了区分该汇总交易是否通过某笔交易明细拆分拼凑而来：如果子map的key为Integer.MAX_VALUE，否则对应的是被拆分的交易明细
                res.put(lastValue, myTmpList);
                resultMap.put(targetValue, res);
                sourceList.set(lastIndex, gap);
            }else{
                System.out.println(sourceList);
                for(int k=remainTargetValues.size()-1;k<sourceList.size();k++){
                    myTmpList.add(sourceList.get(k));
                }
                myTmpList.add(lastValue);
                LinkedHashMap<Integer,List<Integer>> res = new LinkedHashMap<Integer,List<Integer>>();
                //为了区分该汇总交易是否通过某笔交易明细拆分拼凑而来：如果子map的key为Integer.MAX_VALUE，否则对应的是被拆分的交易明细
                res.put(lastValue, myTmpList);
                resultMap.put(targetValue, res);
            }
        }
        return resultMap;
    }

    //重载
    public static Map<Integer,LinkedHashMap<Integer,List<Integer>>> getResult(Integer[] source,Integer[] target){
        List<Integer> sourceList = new LinkedList<Integer>();
        sourceList.addAll(Arrays.asList(source));
        LinkedList<Integer> targetValues = new LinkedList<Integer>(Arrays.asList(target));
        return getResult(sourceList, targetValues);
    }
    public static void main(String[] args) {
        Integer[] source = new Integer[]{69, 35, 29, 26, 18, 12, 46, 92, 96, 75, 58, 34, 110};
        Integer[] target = new Integer[]{104,44,58,61,73,260,100};
        Map<Integer,LinkedHashMap<Integer,List<Integer>>> resultMap = getResult(source, target);
        System.out.println("结果resultMap是:"+resultMap);
        List<Integer> sourceList = new LinkedList<Integer>();
        sourceList.addAll(Arrays.asList(source));
        LinkedList<Integer> targetValues = new LinkedList<Integer>(Arrays.asList(target));
        Map<Integer,LinkedHashMap<Integer,List<Integer>>> resultMap2 = getResult(sourceList, targetValues);
        System.out.println("结果resultMap2是:"+resultMap2);
    }

}

改进版：

import java.math.BigDecimal;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

/**
 * 将手续费作为一笔交易，如果拼凑不出来，则拆分剩余明细中金额最大的那笔交易
 * 该方案理论上可能存在需要拆分多笔交易的情况
 * @author kenan.zhang
 * @date 2017-08-23
 */
public class Calculator2 {

    public static void recursion(List<Map<String,Object>> detailList,LinkedList<Map<String,Object>> tmpList,LinkedList<Object> resultList,Map<String,Object> targetSummary,int startIndex){

        for (int i = startIndex; i < detailList.size(); i++) {
            Map<String,Object> currentDetail = detailList.get(i);
            BigDecimal summaryMoney = (BigDecimal) targetSummary.get("summaryMoney");
            BigDecimal detailMoney = (BigDecimal) currentDetail.get("detailMoney");
            if(detailMoney.compareTo(summaryMoney) != 1){
                if(detailMoney.compareTo(summaryMoney) == 0){
                    tmpList.add(currentDetail);
                    resultList.add(new LinkedList<Map<String,Object>>(tmpList));
                    tmpList.remove(currentDetail);
                    resultList.add(targetSummary);
                    //从源数据列表中去掉已经使用过的数据
                    detailList.removeAll((Collection<?>) resultList.get(0));
                    break;
                }else if(detailMoney.compareTo(summaryMoney) == -1){
                    tmpList.add(currentDetail);
                    targetSummary.put("summaryMoney", summaryMoney.subtract(detailMoney));
                    recursion(detailList, tmpList, resultList, targetSummary, i+1);
                    //值还原
                    targetSummary.put("summaryMoney", ((BigDecimal)(targetSummary.get("summaryMoney"))).add(detailMoney));
                    tmpList.remove(currentDetail);
                    //只取第一对符合条件的数据,第一个元素代表明细数据列表,第二个元素代表对应的汇总数据
                    if(resultList.size() == 2){
                        //从源数据列表中去掉已经使用过的数据
                        detailList.removeAll((Collection<?>) resultList.get(0));
                        break;
                    }
                }
            }else{
                break;
            }
        }

    }


    public static LinkedList<Object> getResult(Map<String,List<Map<String,Object>>> sourceData){

        List<Map<String,Object>> detailList = sourceData.get("detail");
        List<Map<String,Object>> summaryList = sourceData.get("summary");
        DetailValueComparator detailComparator = new DetailValueComparator();
        SummaryValueComparator summaryComparator = new SummaryValueComparator();
        Collections.sort(detailList,detailComparator);
        Collections.sort(summaryList,summaryComparator);
        int startIndex = 0;
        List<Map<String,Object>> remainSummaryList = new LinkedList<Map<String,Object>>();
        LinkedList<Object> returnList = new LinkedList<Object>();
        for(int i=0;i<summaryList.size();i++){
            Map<String,Object> currentSummary = summaryList.get(i);
            LinkedList<Object> resultList = new LinkedList<Object>();
            LinkedList<Map<String,Object>> tmpList = new LinkedList<Map<String,Object>>();
            recursion(detailList, tmpList, resultList,currentSummary, startIndex);
            if(resultList.size() == 0){
                remainSummaryList.add(currentSummary);
            }
            returnList.addAll(resultList);
        }

        Collections.sort(detailList,detailComparator);
        for(int i=0;i<remainSummaryList.size();i++){
            //对最大的一笔交易进行拆分
            int lastIndex = detailList.size()-1;
            Map<String,Object> lastDetail = detailList.get(lastIndex);
            Map<String,Object> targetSummary = remainSummaryList.get(i);
            LinkedList<Map<String,Object>> myTmpList = new LinkedList<Map<String,Object>>();
            BigDecimal lastDetailMoney = (BigDecimal) lastDetail.get("detailMoney");
            BigDecimal summaryMoney = (BigDecimal) targetSummary.get("summaryMoney");
            BigDecimal sum = new BigDecimal(0);
            //待删除列表
            List<Map<String,Object>> listToRemove = new LinkedList<Map<String,Object>>();
            for(int j=0;j<detailList.size();j++){
                myTmpList.add(detailList.get(j));
                Object t = detailList.get(j).get("detailMoney");
                BigDecimal detailMoney = new BigDecimal(t.toString());
                listToRemove.add(detailList.get(j));
                sum = sum.add(detailMoney);
                if(!less(sum, summaryMoney)){
                    listToRemove.remove(detailList.get(j));
                    myTmpList.remove(detailList.get(j));
                    Map<String,Object> m = new HashMap<String,Object>();
                    //gap代表拼凑的金额
                    BigDecimal gap = summaryMoney.subtract(sum.subtract(detailMoney));
                    m.put("detailMoney", gap);
                    m.put("ifBorrow", "yes");
                    //被拆交易的序列号
                    m.put("borrowSerial", lastDetail.get("serialNo"));
                    myTmpList.add(m);
                    returnList.add(myTmpList);
                    returnList.add(targetSummary);
                    //更新被拆分交易的金额
                    lastDetail.put("detailMoney", lastDetailMoney.subtract(gap));
                    detailList.removeAll(listToRemove);
                    if(equal(sum, summaryMoney)){
                        detailList.remove(lastDetail);
                    }
                    //重新排序,保证每次取到最大的交易明细进行拆分
                    Collections.sort(detailList, detailComparator);
                    break;
                }
            }
        }
        return returnList;
    }

    public static boolean greater(BigDecimal d1,BigDecimal d2){
        return d1.compareTo(d2)==1;
    }

    public static boolean equal(BigDecimal d1,BigDecimal d2){
        return d1.compareTo(d2)==0;
    }

    public static boolean less(BigDecimal d1,BigDecimal d2){
        return d1.compareTo(d2)==-1;
    }

    public static void main(String[] args) {

        Map<String,List<Map<String,Object>>> sourceData = new HashMap<String,List<Map<String,Object>>>();
        List<Map<String,Object>> detailList = new LinkedList<Map<String,Object>>();
        Map<String, Object> m1 = new HashMap<String, Object>();
        m1.put("detailMoney", new BigDecimal(69));
        m1.put("serialNo", 69);
        detailList.add(m1);
        m1 = new HashMap<String, Object>();
        m1.put("detailMoney", new BigDecimal(35));
        m1.put("serialNo", 35);
        detailList.add(m1);
        m1 = new HashMap<String, Object>();
        m1.put("detailMoney", new BigDecimal(29));
        m1.put("serialNo", 29);
        detailList.add(m1);
        m1 = new HashMap<String, Object>();
        m1.put("detailMoney", new BigDecimal(26));
        m1.put("serialNo", 26);
        detailList.add(m1);
        m1 = new HashMap<String, Object>();
        m1.put("detailMoney", new BigDecimal(18));
        m1.put("serialNo", 18);
        detailList.add(m1);
        m1 = new HashMap<String, Object>();
        m1.put("detailMoney", new BigDecimal(12));
        m1.put("serialNo", 12);
        detailList.add(m1);
        m1 = new HashMap<String, Object>();
        m1.put("detailMoney", new BigDecimal(46));
        m1.put("serialNo", 46);
        detailList.add(m1);
        m1 = new HashMap<String, Object>();
        m1.put("detailMoney", new BigDecimal(92));
        m1.put("serialNo", 92);
        detailList.add(m1);
        m1 = new HashMap<String, Object>();
        m1.put("detailMoney", new BigDecimal(96));
        m1.put("serialNo", 96);
        detailList.add(m1);
        m1 = new HashMap<String, Object>();
        m1.put("detailMoney", new BigDecimal(75));
        m1.put("serialNo", 75);
        detailList.add(m1);
        m1 = new HashMap<String, Object>();
        m1.put("detailMoney", new BigDecimal(58));
        m1.put("serialNo", 58);
        detailList.add(m1);
        m1 = new HashMap<String, Object>();
        m1.put("detailMoney", new BigDecimal(34));
        m1.put("serialNo", 34);
        detailList.add(m1);
        m1 = new HashMap<String, Object>();
        m1.put("detailMoney", new BigDecimal(120));
        m1.put("serialNo", 120);
        detailList.add(m1);
        m1 = new HashMap<String, Object>();
        m1.put("detailMoney", new BigDecimal(32));
        m1.put("serialNo", 32);
        detailList.add(m1);
        sourceData.put("detail", detailList);

        List<Map<String,Object>> summaryList = new LinkedList<Map<String,Object>>();
        Map<String, Object> m2 = new HashMap<String, Object>();
        m2.put("summaryMoney", new BigDecimal(104));
        m2.put("serialNo", 104);
        summaryList.add(m2);
        m2 = new HashMap<String, Object>();
        m2.put("summaryMoney", new BigDecimal(44));
        m2.put("serialNo", 44);
        summaryList.add(m2);
        m2 = new HashMap<String, Object>();
        m2.put("summaryMoney", new BigDecimal(58));
        m2.put("serialNo", 58);
        summaryList.add(m2);
        m2 = new HashMap<String, Object>();
        m2.put("summaryMoney", new BigDecimal(93));
        m2.put("serialNo", 93);
        summaryList.add(m2);
        m2 = new HashMap<String, Object>();
        m2.put("summaryMoney", new BigDecimal(73));
        m2.put("serialNo", 73);
        summaryList.add(m2);
        m2 = new HashMap<String, Object>();
        m2.put("summaryMoney", new BigDecimal(260));
        m2.put("serialNo", 260);
        summaryList.add(m2);
        m2 = new HashMap<String, Object>();
        m2.put("summaryMoney", new BigDecimal(110));
        m2.put("serialNo", 110);
        summaryList.add(m2);
        sourceData.put("summary", summaryList);

        DetailValueComparator detailComparator = new DetailValueComparator();
        SummaryValueComparator summaryComparator = new SummaryValueComparator();
        Collections.sort(detailList,detailComparator);
        Collections.sort(summaryList,summaryComparator);
        LinkedList<Object> result = getResult(sourceData);
        System.out.println(result);
    }

}

SummaryValueComparator.java

import java.math.BigDecimal;
import java.util.Comparator;
import java.util.Map;

public class SummaryValueComparator implements Comparator<Map<String, Object>> {
    public int compare(Map<String, Object> m, Map<String, Object> n) {
        return ((BigDecimal) m.get("summaryMoney")).compareTo((BigDecimal) n.get("summaryMoney"));
    }
}

DetailValueComparator.java

import java.math.BigDecimal;
import java.util.Comparator;
import java.util.Map;

public class DetailValueComparator implements Comparator<Map<String, Object>> {
    public int compare(Map<String, Object> m, Map<String, Object> n) {
        return ((BigDecimal) m.get("detailMoney")).compareTo((BigDecimal) n.get("detailMoney"));
    }
}

由于可能存在需要拆分多笔交易的情况，程序针对该情况作了优化

数据输出：
[[{serialNo=12, detailMoney=12}, {serialNo=32, detailMoney=32}], {serialNo=44, summaryMoney=44}, [{serialNo=58, detailMoney=58}], {serialNo=58, summaryMoney=58}, [{serialNo=18, detailMoney=18}, {serialNo=26, detailMoney=26}, {serialNo=29, detailMoney=29}], {serialNo=73, summaryMoney=73}, [{serialNo=35, detailMoney=35}, {serialNo=69, detailMoney=69}], {serialNo=104, summaryMoney=104}, [{serialNo=34, detailMoney=34}, {serialNo=46, detailMoney=46}, {detailMoney=13, ifBorrow=yes, borrowSerial=120}], {serialNo=93, summaryMoney=93}, [{serialNo=75, detailMoney=75}, {detailMoney=35, ifBorrow=yes, borrowSerial=120}], {serialNo=110, summaryMoney=110}, [{serialNo=120, detailMoney=72}, {serialNo=92, detailMoney=92}, {detailMoney=96, ifBorrow=yes, borrowSerial=96}], {serialNo=260, summaryMoney=260}]

通过连续相加进行拼凑：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

/**
 * @author kenan.zhang
 * @date 2017-08-29
 */
public class Calculator3 {

    public static List<Map<Integer,List<Integer>>> patch(List<Integer> source,List<Integer> target){

        List<Map<Integer,List<Integer>>> result = new LinkedList<Map<Integer,List<Integer>>>();
        //找出最大的那笔交易进行拆分
        Integer max = Collections.max(source);
        source.remove(max);
        for(int i=0;i<target.size();i++){
            Integer t = target.get(i);
            int start = 0;
            //偏移量
            int shift= 0;
            //获取最接近汇总数据的明细数据
            int sum = 0;
            for(int j=0;j<source.size();j++){
                Integer s = source.get(j);
                if(sum==0 && t-s < 0){
                    start++;
                    continue;
                }else{
                    sum += s;
                    if(sum > t){
                        break;
                    }
                    shift++;
                }
            }
            List<Integer> sub = source.subList(start, start+shift);
            Map<Integer,List<Integer>> item = new HashMap<Integer,List<Integer>>();
            item.put(t, new LinkedList<Integer>(sub));
            result.add(item);
            source.removeAll(sub);
        }
        //对明细数据总和不等于汇总数据的item进行拼凑
        for(Map<Integer,List<Integer>> item:result){
            Iterator<Entry<Integer, List<Integer>>> iter = item.entrySet().iterator();
            Entry<Integer, List<Integer>> entry = iter.next();
            int sum = 0;
            List<Integer> v = entry.getValue();
            Integer k = entry.getKey();
            for(int i=0;i<v.size();i++){
                sum += v.get(i);
            }
            if(sum < k){
                v.add(k-sum);
            }
        }
        return result;

    }

    public static void main(String[] args) {
        Integer[] source = new Integer[]{1032, 69, 35, 29, 26, 18, 12, 46, 92, 96, 75, 58, 34, 120,9000};
        Integer[] target = new Integer[]{104,44,58,93,73,260,110,10000};
        List<Map<Integer,List<Integer>>> result = patch(new ArrayList<Integer>(Arrays.asList(source)),new ArrayList<Integer>(Arrays.asList(target)));
        System.out.println(result);
    }

}

数据输出样例：
[{104=[69, 35]}, {44=[29, 15]}, {58=[26, 18, 12, 2]}, {93=[46, 47]}, {73=[58, 15]}, {260=[92, 96, 72]}, {110=[75, 34, 1]}, {10000=[1032, 120, 8848]}]

详细代码可参考我的github:https://github.com/iamzken/recursion

AI传道士
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
leetcode530-leetcode-algorithms-questions:leetcode-算法-问题
06-30
leetcode 530 直到 2018-12-02 00:46:43，我已经解决了124 / 899问题。 力扣解决方案表 ID 标题 困难 001 简单的 002 中等的 003 中等的 004 两个有序数组的中位数 难的 005 中等的 006 中等的 007 反转整数 简单的 ...
LeetCode精选TOP面试题66.加一
whtli的博客
10-22 118
题目描述 给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。 最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。 假设除了整数 0 之外，这个整数不会以零开头 example input : {0} output : {1} input : {1,9} output : {2,0} input : {9,9,9} output : {1,0,0,0} 解题思路 思路1 借助大数BigDecimal 先将数组转换为StringBuilder sb 再借助sb生成大
关于枚举法及组合型、排列型枚举模板
qq_64030389的博客
03-26 2466
枚举法 枚举算法的思想： 将问题的所有可能成为答案的解一一列举，然后根据问题所给出的条件判断此解是否合适，如果合适就保留，反之舍弃。 枚举算法解题的基本思路： 确定枚举解的范围，以及判断条件 选取合适枚举方法，进行逐一枚举，此时应注意能否覆盖所有的可能的解 在枚举时使用判断条件检验，留下所有符合要求的解。 枚举算法的一般步骤： 根据题目确定枚举的范围，并选取合适的枚举方式，不能遗漏任何一个真正解，同时避免重复。 为了提高解决问题的效率，看题目是否存在优化，将可能成为解的答案范围尽可能的缩小。
枚举C(n,m)组合的算法集锦
baidu_38487648的博客
11-13 2499
1.绪论 1.1问题描述 现有一个大小为n的样本空间，从其他随机抽取m个样本，其中n，m>=0,m<=m,请枚举所有的组合情况。 1.2组合数求解的意义 排列组合是组合学最基本的概念。排列，就是指从给定个数的元素中取出指定个数的元素进行排序；组合则是指从给定个数的元素中仅仅取出指定个数的元素，不考虑排序。排列组合的中心问题是研究给定要求的排列和组合可能出现的情况总数。排列组合与古典概率论关系
leetcode_1291.顺次数--一道简单的枚举题
Adorablenewbaby的博客
08-06 153
leetcode_1291 题目描述 题目大意 思路描述 代码 写在最后 题目描述 我们定义 「顺次数」为：每一位上的数字都比前一位上的数字大 1 的整数。 请你返回由 [low, high] 范围内所有顺次数组成的 有序 列表（从小到大排序）。 示例 1： 输出：low = 100, high = 300 输出：[123,234] 示例 2： 输出：low = 1000, high = 13000 输出：[1234,2345,3456,4567,5678,6789,12345] 提示：
leetcode算法专题训练：八.暴力枚举专题
Worthy_Wang的博客
01-29 368
八.暴力枚举专题 78.子集 90.子集2 77.组合 46.全排列 47.全排列2 60.排列序列 31.下一个排列 17.电话号码的字母组合 八.暴力枚举专题 78.子集 题目描述:给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。 说明：解集不能包含重复的子集。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/subsets 解题思路：子集的本质是求 组合 ，此题也实质上是 组合 的变形题，用D.
蓄水池算法leetcode-leetcode-js-chimy:leetcode-js-chimy
06-30
leetcode-javascript-chimy 数据结构 1.数组 贪心算法 分支算法 动态规划算法 2.字符串 3.队列 4.链表 5.双指针 6.栈 7.堆 8。树 9.二叉搜索树 10.字典树 11.线段树 12.并查集 13.哈希表 14.图 基础算法 1.排序 2....
leetcode算法题-链表操作（两数相加）
12-20
leetcode 算法题： 两数相加 ...链接：https://leetcode-cn.com/problems/add-two-numbers 示例： 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 原因：342 + 465 = 807 由题意可知，链表为逆
javalruleetcode-leetcode-algorithms-java:leetcode算法笔记-java
06-29
java lru leetcode leetcode-algorithms-java leetcode 算法笔记-java
leetcode2sumc-leetcode-algorithm-practice:leetcode-算法-实践
07-06
leetcode-算法-实践 1. 二和 给定一个整数数组，返回两个数字的索引，使它们相加为特定目标。您可以假设每个输入将只有一个解决方案，并且您可能不会两次使用相同的元素。 例子： Given nums = [2, 7, 11, 15], ...
整数转罗马数字
as1490047935的博客
04-07 106
public class Solution { public String intToRoman(int num) { // 把阿拉伯数字与罗马数字可能出现的所有情况和对应关系，放在两个数组中，并且按照阿拉伯数字的大小降序排列 int[] nums = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1}; String[] romans = {"M", "CM", "D", "CD", "..
LeetCode算法刷题（2）— 枚举
weixin_47511190的博客
10-24 216
一、最值算法 //时间复杂度：O(n) //空间复杂度：O(1) class Solution { public: int maxProduct(vector<int>& nums) { int maxn=-1,maxnn=-1; for(int i=0; i < nums.size(); i++){ if(nums[i] > maxn){ maxnn=maxn;
leetcode 高薪_「LeetCode算法精讲」计算小于n的质数数量(Python)
weixin_40005454的博客
10-22 168
题目内容统计所有小于非负整数 n 的质数的数量。示例:输入: 10输出: 4解释: 小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。运行效率LeetCode的Python执行用时随缘，只要时间复杂度没有明显差异，执行用时一般都在同一个量级，仅作参考意义。解法一(完全暴力算法)：【思路】首先，依据质数的定义，我们得到如下算法：遍历所有小于目标值(n)且大于等于2的整数(c)...
LeetCode 60. 排列序列(枚举)
Alphacoo的博客
05-28 162
LeetCode 60. 排列序列 题意 给出集合 [1,2,3,…,n]，其所有元素共有n!种排列。给定n和k，返回第k个按字典序排序的全排列。 分析 1.从左边到右边依次考虑每一位。 2.对于每一位，从小到大依次枚举没有确定位置的数，然后确定当前位置的数值。 举个例子，这里n=4, k=11。 首先我们将所有排列按首位分组： 1. 1 + （2,3,4的全排列） 2. 2 + （1,3,4的全排列） 3. 3 + （1,2,4的全排列） 4. 4 + （1,2,3的全排列）
Leetcode——多维枚举问题二
yj
11-21 322
1385.两个数组间的距离值 https://leetcode-cn.com/problems/find-the-distance-value-between-two-arrays/ while for if 循环给人的感觉就是层层深入，先深入for这层循环然后再对条件进行分析，再依次深入下一层循环。 //感觉就是步步深入的那种感觉，先用for在这个循环然后再深入到for这个循环里面 int findTheDistanceValue(int* arr1, int arr1Size, in.
【LeetCode】模拟题、枚举
myaijarvis notebook
05-03 419
简单 937. 重新排列日志文件 【参考：937. 重新排列日志文件 - 力扣（LeetCode）】 【参考：【宫水三叶】简单排序运用题 - 重新排列日志文件 - 力扣（LeetCode）】 多读几遍题目，代码排序记得写注释 class Solution { class Log { int type, idx;// 日志类型(1是数字日志，0是字母日志) 下标 String ori, sign, content; // 日志 标识符 日志内容 Log(
【算法】枚举算法
qq_52870580的博客
01-11 4486
算法详述 枚举：即对可能的解集合一一列举。 枚举算法的实现往往通过使用循环（嵌套）就能够轻易实现，所以并没有什么思维难度。 解题思路： 1. 对解的每个参数的数据范围采用循环语句一一枚举，对每次枚举采用if语句判断是否是解以及是否是最优解。 枚举小技巧： 1. 有时候，我们枚举的东西如果满足一个公式，我们的循环可以少写一层，优化效率。比如如果枚举A+B+C=100，我们只需要枚举A和B，C可以直接用100-A-B，这样就少一层循环。 2. 当然，改变枚举的顺序也是一种小技巧。一般都是从小到大.
基础算法(一)：枚举算法
荔枝当大佬的博客
01-17 2138
从这篇文章开始，小荔枝就开始学习算法和数据结构啦！我们先来看看入门的一些基础算法，在这篇文章中，主要介绍的是枚举算法。我们重点需要了解枚举算法使用时需要确定的条件，荔枝会用一道例子来凸显这些条件的重要性。
LeetCode刷题 -- 一些经典的例题
qq_43325216的博客
12-20 243
ASCII：将英语中的字符表示为数字的代码。为每个字符分配一个介于 0 到 127 之间的数字。将A~Z对应位号存入相应的数据，比如记录一个字母出现了多少次 （小写字母同理）我们可以构造的最长的回文串是"dccaccd", 它的长度是 7。常见的ASCII码大小比较：0~9
leetcoder题目java_LeetCode算法题-Toeplitz Matrix（Java实现）
最新发布
05-29
好的，您的问题是关于 `Toeplitz Matrix` 这道 LeetCode 算法题的 Java 实现。这道题的题目描述是给定一个矩阵，判断该矩阵是否为 Toeplitz 矩阵。Toeplitz 矩阵指的是从左上角到右下角的对角线上的元素都相等。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AI传道士

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值