【leetcode-回溯】复原IP地址/子集/组合/电话号码的字母组合/二进制手表

最新推荐文章于 2022-05-29 10:53:32 发布
最新推荐文章于 2022-05-29 10:53:32 发布
阅读量346 收藏 1
点赞数
分类专栏： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31478771/article/details/115028547
版权

文章目录

复原IP地址

给定一个只包含数字的字符串，用以表示一个 IP 地址，返回所有可能从 s 获得的 有效 IP 地址 。你可以按任何顺序返回答案。
有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。
例如：“0.1.2.201” 和 “192.168.1.1” 是 有效 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效 IP 地址。

示例 1：
输入：s = “25525511135”
输出：[“255.255.11.135”,“255.255.111.35”]

示例 2：
输入：s = “0000”
输出：[“0.0.0.0”]

示例 3：
输入：s = “1111”
输出：[“1.1.1.1”]

示例 4：
输入：s = “010010”
输出：[“0.10.0.10”,“0.100.1.0”]

示例 5：
输入：s = “101023”
输出：[“1.0.10.23”,“1.0.102.3”,“10.1.0.23”,“10.10.2.3”,“101.0.2.3”]

回溯法

class Solution {
    private char[] charList;
    private List<String> result = new ArrayList<String>();
    private int[] segments = new int[4];
    private int len = 0;

    public List<String> restoreIpAddresses(String s) {
        charList = s.toCharArray();
        len = charList.length;
        backtrack(0, 0);
        return result;
    }

    private void backtrack(int start, int n) {
        if (n == 4) {
            if (start == len) {
                StringBuilder sb = new StringBuilder();
                sb.append(segments[0]);
                for (int i = 1; i < 4; i++) 
                    sb.append(".").append(segments[i]);
                result.add(sb.toString());
            }
            return;
        }
        if (start == len)
            return;

        if (charList[start] == '0') {
            segments[n] = 0;
            backtrack(start + 1, n + 1);
        } else {
            int num = 0;
            for (int i = start; i < len; i++) {
                num = 10 * num + (charList[i] - '0');
                if (num > 0 && num < 256) {
                    segments[n] = num;
                    backtrack(i + 1, n + 1);
                } else {
                    break;
                }
            }
        }
    }
}

子集1

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：
输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：
输入：nums = [0]
输出：[[],[0]]

迭代法

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> results = new ArrayList<>();
        results.add(new ArrayList<Integer>());
        for (int n : nums) {
            int size = results.size();
            for (int i = 0; i < size; i++) {
                List<Integer> cur = new ArrayList<>(results.get(i));
                cur.add(n);
                results.add(cur);
            }
        }
        return results;
    }
}

回溯法

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> results = new ArrayList<>();
        backtrack(results, new ArrayList<Integer>(), 0, nums);
        return results;
    }

    private void backtrack(List<List<Integer>> results, List<Integer> subset, int start, int[] nums) {
        results.add(new ArrayList<>(subset));
        for (int i = start; i < nums.length; i++) {
            subset.add(nums[i]);
            backtrack(results, subset, i + 1, nums);
            subset.remove(subset.size() - 1);
        }
    }
}

子集2

给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
说明：解集不能包含重复的子集。

示例:
输入: [1,2,2]
输出:
[
[2],
[1],
[1,2,2],
[2,2],
[1,2],
[]
]

回溯法

class Solution {
    private int len;
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        this.len = nums.length;
        Arrays.sort(nums);

        List<List<Integer>> result = new ArrayList<>();
        backtrack(nums, result, new ArrayList<>(), 0);
        return result;
    }

    private void backtrack(int[] ns, List<List<Integer>> res, List<Integer> comb, int start) {
        res.add(new ArrayList<>(comb));

        for (int i = start; i < len; i++) {
            if (i > start && ns[i] == ns[i - 1])
                continue;
            comb.add(ns[i]);
            backtrack(ns, res, comb, i + 1);
            comb.remove(comb.size() - 1);
        }
    }
}

迭代法

class Solution {
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        result.add(new ArrayList<>());
        Arrays.sort(nums);

        int start = 1;
        for (int i = 0; i < nums.length; i++) {
            List<List<Integer>> cur_result = new ArrayList<>();
            for (int j = 0; j < result.size(); j++) {
                if (j < start && i > 0 && nums[i] == nums[i - 1])
                    continue;
                List<Integer> combine = new ArrayList<>(result.get(j));
                combine.add(nums[i]);
                cur_result.add(combine);
            }
            start = result.size();
            result.addAll(cur_result);
        }
        return result;
    }
}

组合

给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。

示例:
输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

回溯法

class Solution {
    private int count = 0;
    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> results = new ArrayList<>();
        backtrack(results, new ArrayList<Integer>(), 1, n, k);
        return results;
    }

    private void backtrack(List<List<Integer>> results, List<Integer> subset, int start, int n, int k) {
        if (subset.size() + n - start + 1 < k)
            return;

        if (subset.size() == k) {
            results.add(new ArrayList<>(subset));
            return;
        }
        
        
        for (int i = start; i <= n; i++) {
            subset.add(i);
            backtrack(results, subset, i + 1, n, k);
            subset.remove(subset.size() - 1);
        }
    }
}

电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
在这里插入图片描述

示例 1：
输入：digits = “23”
输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”]

示例 2：
输入：digits = “”
输出：[]

示例 3：
输入：digits = “2”
输出：[“a”,“b”,“c”]

回溯法

在这里插入图片描述

class Solution {
    public List<String> letterCombinations(String digits) {
        List<String> result = new ArrayList<>();
        if (digits.length() < 1) {
            return result;
        }

        String[] letterMap = { "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        backtrack(result, letterMap, digits, 0, new StringBuffer());
        return result;
    }

    private void backtrack(List<String> result, String[] letterMap, String digits, int index, StringBuffer curString) {
        if (index == digits.length()) {
            result.add(curString.toString());
        } else {
            char curLetter = digits.charAt(index);
            String letters = letterMap[curLetter - '2'];
            for (int i = 0; i < letters.length(); i++) {
                char letter = letters.charAt(i);
                curString.append(letter);
                backtrack(result, letterMap, digits, index+1, curString);
                curString.deleteCharAt(index);
            }
        }
    }
}

二进制手表

二进制手表顶部有 4 个 LED 代表 小时（0-11），底部的 6 个 LED 代表 分钟（0-59）。每个 LED 代表一个 0 或 1，最低位在右侧。

例如，下面的二进制手表读取 “3:25” 。
在这里插入图片描述

给你一个整数 turnedOn ，表示当前亮着的 LED 的数量，返回二进制手表可以表示的所有可能时间。你可以 按任意顺序 返回答案。

小时不会以零开头：

  • 例如，“01:00” 是无效的时间，正确的写法应该是 “1:00” 。

分钟必须由两位数组成，可能会以零开头：

  • 例如，“10:2” 是无效的时间，正确的写法应该是 “10:02” 。

示例 1：
输入：turnedOn = 1
输出：[“0:01”,“0:02”,“0:04”,“0:08”,“0:16”,“0:32”,“1:00”,“2:00”,“4:00”,“8:00”]

示例 2：
输入：turnedOn = 9
输出：[]

回溯法

class Solution {
    private boolean[] used = new boolean[10];
    public List<String> readBinaryWatch(int turnedOn) {
        List<String> result = new ArrayList<>();
        if (turnedOn > 8 || turnedOn < 0)
            return result;

        backtrack(result, 0, 0, turnedOn);
        return result;
    }

    private void backtrack(List<String> result, int start, int cur, int num) {
        int minute = 0x3f & cur;
        int hour = 0xf & (cur >> 6);
        if (minute > 59 || hour > 11)
            return;
        if (num == 0) {
            StringBuilder sb = new StringBuilder();
            sb.append(hour).append(':');
            if (minute < 10) 
                sb.append('0');
            sb.append(minute);
            result.add(sb.toString());
            return;
        } 

        for (int i = start; i < 10; i++) {
            if (used[i])
                continue;
            used[i] = true;
            backtrack(result, i + 1, cur | (1 << i), num - 1);
            used[i] = false;
        }
    }
}

哈希表存储+组合

class Solution {
    public List<String> readBinaryWatch(int turnedOn) {
        List<String> result = new ArrayList<>();
        if (turnedOn > 8 || turnedOn < 0)
            return result;

        Map<Integer, List<Integer>> minuteMap = new HashMap<>();
        Map<Integer, List<Integer>> hourMap = new HashMap<>();
        for (int i = 0; i < 60; i++) {
            minuteMap.put(i, new ArrayList<Integer>());
            if (i < 12)
                hourMap.put(i, new ArrayList<Integer>());
        }
        for (int i = 0; i < 60; i++) {
            int count = Integer.bitCount(i);
            minuteMap.get(count).add(i);
            if (i < 12)
                hourMap.get(count).add(i);
        }

        for (int i = 0; i <= turnedOn; i++) {
            List<Integer> minutes = minuteMap.get(turnedOn - i), hours = hourMap.get(i);
            for (int h : hours) {
                for (int m : minutes) {
                    StringBuilder sb = new StringBuilder();
                    sb.append(h).append(':');
                    if (m < 10)
                        sb.append('0');
                    sb.append(m);
                    result.add(sb.toString());
                }
            }
        }
        return result;
    }
}
Hung武
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode中文版-LeetCode-Notebook:https://leetcode-cn.com/u/ml-zimingmeng/
06-29
leetcode中文版 「LeetCode-习题集」使用说明 | 中文说明 简介 「LeetCode-习题集」是由热爱算法的 LeetCoders 上传的代码集，我们的目标是贡献所有题解！如果您想成为代码贡献者，体会 GitHub 协同合作的乐趣，请...
leetcode(力扣) 93. 复原 IP 地址（回溯）
深度不学习！！的博客
10-27 1008
还有一点就是题目要求不得删改原s字符中的数值，但是题目s所给长度范围又达到20个，而合法ip最大长度也就是每一段都是3个字符，所以最长也就是12个字符，在这里可以设置一个终止条件，就是所给s长度大于12，则直接return。这道题也是分割，而且比上一个字符串分割感觉看上去要清晰一些，也是找组合的题嘛，回溯嘛，你要问我能不能暴力，我只能说， 可以暴力，看到有人这么做了，N层for，写到怀疑人生。这里的参数非常简单，就一个值，就是startindex，用于记录下次从哪里开始遍历。输入：s = “101023”
LeetCode 93 | 生成所有有效的IP地址
TechFlow的博客
08-24 739
本文始发于个人公众号：TechFlow，原创不易，求个关注 今天是LeetCode专题的第59篇文章，我们一起来看看LeetCode第93题，有效ip地址（Restore IP Addresses）。 这题的官方难度是Medium，点赞1296，反对505，通过率35.4%。从各项指标来说看起来有些中规中矩，实际上也的确如此。这道题的解法和立意都有些显得新意不足，但总体来说题目的质量还是可以的，值得一做。 题意 给定一个由数字组成的字符串，我们希望通过这个字符串得到所有有效ip地址的组合。对于一个有效
有效IP问题 （leetcode--递归篇）
小肥羊快快跑
07-01 2343
问题描述：给定一个只包含数字的字符串，通过返回所有可能的有效IP地址组合来恢复它。例如:给定“25525511135”，返回["255.255.11.135"，"255.255.111.35"]。(顺序并不重要)解题思路：找规律：有效IP地址的条件有1、每段地址均小于等于255； 2、共有四段地址递归方法：取某段的地址，可能是1位、2位、3位判断第一段地址是否有效，若有效，取下一段地址将某段地址与...
6-18位字母和数字的混合组成的正则表达式的js
热门推荐
道的博客
07-26 2万+
if( /^[a-zA-Z0-9]{6,18}$/.test( password ) ) { alert( 'ok' ); } 至少有一个数字字母的正则表达式： /^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{6,18}$/
计算机ip地址与子网掩码如何进行and运算_IP地址和类型
weixin_39820173的博客
11-20 3138
今天接着计算机网络往下讲，就到了咱们的Ip地址了，欢迎小伙伴们提出宝贵建议五.IP地址1.IP地址的特征 1. IP地址有32位长 2. IP地址划分成四组，每组8位，用句点隔开 3. IP地址每组取值的范围在0-255 4. IP地址是由两部分构成：网络位➕主机位2.IP地址类型：判断IP地址类别，就看四组数中的第一组数A类：1-127B类：128-191C类：192-223D类：224...
leetcode题库-leetcode:https://leetcode-cn.com/
06-29
leetcode题库 leetcode 生成文件工具 Usage: python tool.py -p [name] [options] Options: -h, --h 查看帮助 -p name leetcode 题目编号，必须 -a 题目类型为算法 -d 题目类型为数据库 -s 题目类型为Shell -c 编程...
判断青蛙过河leetcode-leetcode:https://leetcode-cn.com/problemset/all/
06-30
判断青蛙过河leetcode 目录 leetcode 打印不重复元素 √ 4、二维数组中查找目标值（从右上角开始查找）√ 子集(位运算) √ 数组走到最后最小步数 √ 最大数（数组排序比较） √ 替换空格 √ Z字型变换 √ 判断是否是...
gasstationleetcode-leetcode:https://leetcode-cn.com
06-30
leetcode leetcode Java 中的 Leetcode 解决方案 基础 （简单的） （简单的） （简单的） （中等的） （简单的） （难的） （中等的） （中等的） （简单的） （简单的） 二分查找 桶 提高 【两个排序数组的4中位数...
leetcode题库-leetcode-database:https://leetcode.com/problemset/database/
06-29
leetcode题库leetcode 数据库 标题 176 第二高薪 32.8% 容易 175 合并两张表 63.0% Easy 177 Nth 最高薪水 32.6% 中 185系前三薪37.4%辛苦 262 次行程和用户 35.0% 难 181 名员工的收入超过他们的经理 59.2% 容易 ...
ip地址类型-范围-作用
01-17
A类地址 有126个网络 每个网络1670万台主机 ⑴ A类地址第1字节为网络地址，其它3个字节为主机地址。另外第1个字节的最高位固定为0。 ⑵ A类地址范围：1.0.0.1到126.255.255.254。（00000001.00000000.00000000.00000001~01111110.11111111.11111111.11111110） *网络号地址 不能全为0或全为1;主机号地址也不能全为0或全为1(有特殊用途在下文*处将说明) ⑶ A类地址中的私有地址和保留地址： ①10.0.0.0到10.255.255.255是私有地址（所谓的私有地址就是在互联网上不使用，而被用在局域网络中的地址）。 ②127.0.0.0到127.255.255.255是保留地址，用做循环测试用的。
IP地址转换（数字和字符串）
l1040515635的博客
12-26 755
#pragma once #define WIN32_LEAN_AND_MEAN #define _WINSOCK_DEPRECATED_NO_WARNINGS #include <winsock2.h> #include <stdio.h> #include <windows.h> #include <iostream> #include &l...
给定数字串，输出可能的ip地址组合！
六维空间的专栏
10-20 1672
最近看到一个面试问题，决定挺好的，能够考验一个程序员的编程功底，于是自己写了一下。 题目：给定一个数字字符串，要求输出可能的ip地址组合 输入：12342 输出：1.2.3.42 1.2.34.2 1.23.4.2 12.3.4.2 下面是我写的一个小程序，欢迎拍砖 #include <stdio.h> #include <stdlib.h...
leetcode ip地址组合
weixin_30642267的博客
05-26 273
class Solution { public: vector<int>v1; vector<string>v; int count; string inttostring(int n) { stringstream ss; string str; ss<<n; ...
LeetCode中等题之验证IP地址
Lonery的博客
05-29 506
题目 给定一个字符串 queryIP。如果是有效的 IPv4 地址，返回 “IPv4” ；如果是有效的 IPv6 地址，返回 “IPv6” ；如果不是上述类型的 IP 地址，返回 “Neither” 。 有效的IPv4地址 是 “x1.x2.x3.x4” 形式的IP地址。 其中 0 <= xi <= 255 且 xi 不能包含 前导零。例如: “192.168.1.1” 、 “192.168.1.0” 为有效IPv4地址， “192.168.01.1” 为无效IPv4地址; “192.168.1
判断字符串能组成多少个有效的ip地址leetcode
tianren9的博客
09-28 1588
给定一个字符串，通过加入三个点，看能组成多少个有效的ip #include&lt;iostream&gt; #include&lt;vector&gt; #include&lt;string&gt; #include&lt;algorithm&gt; #include&lt;sstream&gt; using namespace std; bool isvalidip(string s) { ...
判断一个IP区间（或IP）是否被另一个IP区间所包含
03-08 1129
 以下方法实现判断一个IP是否被一个IP区间所包含有一些静态方法可能引用了同名空间的自定义的类，至于合并两个相临的IP段，可对其中的最大或最小IP+1using System;using System.Text.RegularExpressions;namespace HKH.Common{ ///  /// clsMacAndIP 的摘要说明。 ///  public class
LeetCode 93 子网 划分
u013767689的博客
02-28 353
题目： Given a string containing only digits, restore it by returning all possible valid IP address combinations. For example: Given “25525511135”, return [“255.255.11.135”, “255.255.111.35”]. (Order...
LeetCode 93. Restore IP Addresses（恢复IP地址）
James Pan
05-23 1156
原题网址：https://leetcode.com/problems/restore-ip-addresses/ Given a string containing only digits, restore it by returning all possible valid IP address combinations. For example: Given "2552551
https://leetcode-cn.com/tag/dynamic-programming/
最新发布
06-28
这个链接是 LeetCode 上关于动态规划的题目集合。动态规划是一种常用的算法思想，可以用来解决很多实际问题，比如最长公共子序列、背包问题、最短路径等等。在 LeetCode 上，动态规划也是一个非常重要的题型，很多...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值