深度优先搜索练习四

例题一：电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。（九键输入法）

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3rkv8HWI-1651898281742)(…/Java数据结构/图片/image-20220502164823941.png)]

分析：

一个数字字符对应几个字符；（键值对）

不同字母组合，排列组合

思路一：dfs

class Solution {
    Map<Character,String> map;
    public List<String> letterCombinations(String digits) {
        ArrayList<String> ret = new ArrayList<>();
        if(digits.length()==0 || digits==null)
            return ret;
        map = new HashMap<>();
        map.put('2',"abc");
        map.put('3',"def");
        map.put('4',"ghi");
        map.put('5',"jkl");
        map.put('6',"mno");
        map.put('7',"pqrs");
        map.put('8',"tuv");
        map.put('9',"wxyz");
        help(digits,0,ret,new StringBuffer());
        return ret;
    }
    private void help(String digits,int index,ArrayList<String> ret,StringBuffer str){
        if(index>=digits.length())
            ret.add(str.toString());
        else{
            String tmp = map.get(digits.charAt(index));
        
            for(int i = 0;i<tmp.length();i++){
                str.append(tmp.charAt(i));
                help(digits,index+1,ret,str);
                str.deleteCharAt(index);
            }
        }
    }
}

例题二：二进制手表

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

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

小时不会以零开头：

例如，“01:00” 是无效的时间，正确的写法应该是 “1:00” 。
分钟必须由两位数组成，可能会以零开头：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-watch

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

分析：

四位小时位；1，2，4，8

六位分钟位：1，2，4，8，16，32

思路一：

class Solution {
    int[] hours = new int[]{1, 2, 4, 8, 0, 0, 0, 0, 0, 0};
    int[] minutes = new int[]{0, 0, 0, 0, 1, 2, 4, 8, 16, 32};
    List<String> res = new ArrayList<>();

    public List<String> readBinaryWatch(int num) {
        backtrack(num, 0, 0, 0);
        return res;
    }

    public void backtrack(int num, int index, int hour, int minute){
        if(hour > 11 || minute > 59) 
            return;
        if(num == 0){
            StringBuilder sb = new StringBuilder();
            sb.append(hour).append(':');
            if (minute < 10) {
                sb.append('0');
            }
            sb.append(minute);
            res.add(sb.toString());
            return;
        }
        for(int i = index; i < 10; i++){
            backtrack(num - 1, i + 1, hour + hours[i], minute + minutes[i]);
        }  
    }
}

思路二：高位小时位，低位分钟位

共10位二进制位：高四位存小时位，低六位存分钟位

遍历10位，置1为灯亮，获得最后的数字

将数字转化为字符串加入结果集

public List<String> readBinaryWatch(int turnedOn) {
        List<String> res = new LinkedList<>();
        backtrace(0, 0, 10, turnedOn, res);
        return res;
    }
	//path:路径（小时分钟组合数） idx：第几位 len：总共几位 total：需要的数量 res：结果集
    private void backtrace(int path, int idx, int len, int total, List<String> res) {
        if (total == 0) {
            String r = convert(path);
            if (!"".equals(r)) {
                res.add(r);
            }
            return;
        }
        //剪枝：可选位数，小于需要的位数（能亮的灯数，小于需要亮的灯数）
        if (len - idx < total) {
            return;
        }
        //不选
        backtrace(path, idx + 1, len, total, res);
        //选
        path |= (1 << idx);
        backtrace(path, idx + 1, len, total - 1, res);
    }
	//转换，将存储的小时数和分钟数，获取并转化为字符串
    private String convert(int num) {
        int hour = (num & 0b1111000000) >> 6;
        int minute = (num & 0b111111);
        if (hour >= 12) {
            return "";
        }
        if (minute > 59) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        sb.append(hour + ":");
        if (minute < 10) {
            sb.append("0");
        }
        sb.append(minute);
        return sb.toString();
    }