LeetCode1269. 停在原地的方案数 / 剑指 Offer 38. 字符串的排列 / 216. 组合总和 III / 剑指 Offer 39. 数组中出现次数超过一半的数字/229. 求众数

最新推荐文章于 2023-05-07 22:52:08 发布

Zephyr丶J

最新推荐文章于 2023-05-07 22:52:08 发布

阅读量122

点赞数

分类专栏： LeetCode 文章标签：算法 java

本文链接：https://blog.csdn.net/windyjcy/article/details/116735262

版权

LeetCode 专栏收录该内容

198 篇文章 1 订阅

订阅专栏

1269. 停在原地的方案数

2021.5.13 每日一题

题目描述

有一个长度为 arrLen 的数组，开始有一个指针在索引 0 处。

每一步操作中，你可以将指针向左或向右移动 1 步，或者停在原地（指针不能被移动到数组范围外）。

给你两个整数 steps 和 arrLen ，请你计算并返回：在恰好执行 steps 次操作以后，指针仍然指向索引 0 处的方案数。

由于答案可能会很大，请返回方案数 模 10^9 + 7 后的结果。

 

示例 1：

输入：steps = 3, arrLen = 2
输出：4
解释：3 步后，总共有 4 种不同的方法可以停在索引 0 处。
向右，向左，不动
不动，向右，向左
向右，不动，向左
不动，不动，不动
示例  2：

输入：steps = 2, arrLen = 4
输出：2
解释：2 步后，总共有 2 种不同的方法可以停在索引 0 处。
向右，向左
不动，不动
示例 3：

输入：steps = 4, arrLen = 2
输出：8

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-ways-to-stay-in-the-same-place-after-some-steps
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

第一眼看到就是回溯，然后就秒写了，果不其然超时了，（27， 7）这是示例倒下了

class Solution {
    int count = 0;
    int arrLen;
    public int numWays(int steps, int arrLen) {
        //回溯吗，感觉会超时，不过先写写咯
        int pos = 0;  //现在位置
        this.arrLen = arrLen;
        dfs(steps, pos);
        return count;
    }

    public void dfs(int steps, int pos){
        if(pos < 0 || pos >= arrLen)
            return;
        if(steps == 0 && pos == 0){
            count = (count + 1) % (1000000007);
            return;
        }
        if(steps == 0)
            return;
        //向右
        dfs(steps - 1, pos + 1);
        //不动
        dfs(steps - 1, pos);
        //向左
        dfs(steps - 1, pos - 1);
    }
}

然后再想想，向左向右的个数应该是相等的，才能够回到0，剩下不动次数是无所谓的
看第一个示例，向左或者向右的次数为0或1，为0时 =》不动不动不动一种方案
为1时，不动有1个，而不动可以加在任何位置，向右向左两次操作，三个位置可以插入，所以3种方案
加起来4种
再看示例3，向左向右次数为0，1，2
为0时，同样是一直不动，一种
为1时，三个空位，选两个位置插入“不动”，位置可以重复，重复的时候，是3种；不重复就是求组合数，也是3种
为2时，没有空位，第一步只能向右，最后一步只能向左，但是由于总长度为2，所以只能向右向左向右向左，1种
总共8种

因此，好像可以看出点规律，也就是根据向右向左的次数分别讨论，但是感觉当步数大了的时候还是很复杂

然后看着看着，想着怎么剪枝，想着想着，发现好像可以动态规划，然后发现怎么定义状态数组都不知道…看了题解，感觉好简单，然后评论都说不算困难题，心态崩了

class Solution {
    final int S = 1000000007;
    public int numWays(int steps, int arrLen) {
        //求方案数-->动态规划
        //dp[i][j]为经过i步，在位置j的方案数,j最大不会超过steps，也不会超过arrlen - 1，因此两者取小
        int idxj = Math.min(steps, arrLen - 1);
        int[][] dp = new int[steps + 1][idxj + 1];
        //初始化,dp[0][j] = 0;
        dp[0][0] = 1;
        //转移方程，可以从三个方向转移而来
        //dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1] + dp[i - 1][j + 1]
        for(int i = 1; i <= steps; i++){
            for(int j = 0; j <= idxj; j++){
                dp[i][j] = dp[i - 1][j];
                if(j - 1 >= 0){
                    dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % S;
                }
                if(j + 1 <= idxj){
                    dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % S;
                }
            }
        }
        return dp[steps][0];

    }

}

压缩空间，因为只和上一行有关
另外，因为左右移动次数是一致的，因此最远能去的位置是(steps + 1) / 2;

class Solution {
    final int S = 1000000007;
    public int numWays(int steps, int arrLen) {
        //求方案数-->动态规划-->状态压缩
        //dp[i][j]为经过i步，在位置j的方案数,j最大不会超过steps，也不会超过arrlen - 1，因此两者取小
        //因为向右了就要向左，所以可以再压缩
        int idxj = Math.min((steps + 1) / 2, arrLen - 1);
        int[] dp = new int[idxj + 1];
        //初始化,dp[0][j] = 0;
        dp[0] = 1;
        //转移方程，可以从三个方向转移而来
        //dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1] + dp[i - 1][j + 1]
        for(int i = 1; i <= steps; i++){
            //因为上一行的状态要反复使用，所以先建一个数组存当前行状态
            int[] newdp = new int[idxj + 1];
            for(int j = 0; j <= idxj; j++){
                newdp[j] = dp[j];
                if(j - 1 >= 0){
                    newdp[j] = (newdp[j] + dp[j - 1]) % S;
                }
                if(j + 1 <= idxj){
                    newdp[j] = (newdp[j] + dp[j + 1]) % S;
                }
            }
            dp = newdp;
        }
        return dp[0];

    }

}

这么做完了，发现还是基础有问题，能写出递归，最起码应该能写出状态的定义，还是太菜了
等了一会三叶姐的题解，发现还能更优，因为随着步数的减少，所能到达的边界会越来越小，tql

剑指 Offer 38. 字符串的排列

题目描述

输入一个字符串，打印出该字符串中字符的所有排列。

你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。
	
示例:

输入：s = "abc"
输出：["abc","acb","bac","bca","cab","cba"]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/zi-fu-chuan-de-pai-lie-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

经典排列问题，要注意字符串中有重复的元素，因此需要先排序，再对相同的情况进行处理
要注意这里是对树层中的重复进行剪枝，而不是对树枝中的重复进行剪枝，所以是 if(i > 0 && !uesd[i - 1] && ss[i] == ss[i - 1])，如下图(手绘哈哈)：
在这里插入图片描述

class Solution {
    //重复卡住了，想想怎么去重来着,先排序
    List<String> list = new ArrayList<>();
    boolean[] uesd;
    public String[] permutation(String s) {
        //排列问题，经典回溯问题
        char[] ss = s.toCharArray();
        Arrays.sort(ss);
        uesd = new boolean[ss.length];
        StringBuilder sb = new StringBuilder();
        backtracking(ss, sb);
        String[] ret = new String[list.size()];
        for(int i = 0; i < list.size(); i++){
            ret[i] = list.get(i);
        }
        return ret;

    }

    public void backtracking(char[] ss, StringBuilder sb){
        if(sb.length() == ss.length){
            list.add(sb.toString());
            return;
        }
        for(int i = 0; i < ss.length; i++){
            if(!uesd[i]){
                //上一个字符和这个字符相同并且没有被使用过，跳过
                if(i > 0 && !uesd[i - 1] && ss[i] == ss[i - 1])
                    continue;
                sb.append(ss[i]);
                uesd[i] = true;
                backtracking(ss, sb);
                sb.deleteCharAt(sb.length() - 1);
                uesd[i] = false;
            }
        }
    }
}

但是其实条件写成 if(i > 0 && uesd[i - 1] && ss[i] == ss[i - 1]) 这样也能过，即对树枝的剪枝，因为下图：
在这里插入图片描述

另外，剑指offer中所给的思路是交换，即每次固定一个位置，然后对下一个位置的字符进行选择，用Set集合降重

class Solution {
    //学一下交换的写法，并用set降重
    List<String> res = new LinkedList<>();
    char[] c;
    public String[] permutation(String s) {
        //排列问题  
        c = s.toCharArray();
        backtracking(0);
        return res.toArray(new String[res.size()]);
    }
    
    public void backtracking(int start){
        if(start == c.length - 1){
            //这个方法用于将c字符数组变成字符串
            res.add(String.valueOf(c));
            return;
        }
        HashSet<Character> set = new HashSet<>();
        for(int i = start; i < c.length; i++){
            //如果set中包含c[i]就说明当前层重复了，去掉
            if(set.contains(c[i]))
                continue;
            //将当前位置固定
            set.add(c[i]);
            swap(i, start);
            backtracking(start + 1);
            swap(i, start);
        }
    }

    public void swap(int i, int j){
        char temp = c[i];
        c[i] = c[j];
        c[j] = temp;
    }
}

组合问题

书中又提到了如果是求组合怎么办，如果求n个字符的长度为m的组合
每次选择一个字符，对于当前字符，如果选择了，那么就是在剩下的n- 1 个字符中选m-1个字符
如果不选择，那么就是在n-1个字符中选m个
至于重复呢，也是排序后在树层上剪枝if(i > idx && ss[i] == ss[i - 1])

    public void backtracking(char[] ss, StringBuilder sb, int len, int idx){
        if(sb.length() == len){
            list.add(sb.toString());
            return;
        }
        for(int i = idx; i < ss.length; i++){
	        if(i > idx && ss[i] == ss[i - 1])
	        	continue;
			sb.append(ss[i]);
			backtracking(ss, sb， len, i + 1);
			sb.deleteCharAt(sb.length() - 1);      
        }
    }

最后书中又给了两道题，一道是把八个数放在正方体八个顶点，使相对的面四个数之和相同，做法同样是求出排列，然后判断条件
还有一道八皇后，也是经典问题了

看到组合总和有一道没做，顺便做了

216. 组合总和 III

题目描述

找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。

说明：

所有数字都是正整数。
解集不能包含重复的组合。 
示例 1:

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

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combination-sum-iii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

相当于1-9 九个数里面选三个

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        backtracing(n, k, 1);
        return res;
    }

    public void backtracing(int n, int k, int idx){
        if(k == 0 && n == 0){
            res.add(new ArrayList<>(path));
            return;
        }
        if(k == 0 || n <= 0)
            return; 
        for(int i = idx; i < 10; i++){
            path.add(i);
            backtracing(n - i, k - 1, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

剑指 Offer 39. 数组中出现次数超过一半的数字

题目描述

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。


示例 1:

输入: [1, 2, 3, 2, 2, 2, 5, 4, 2]
输出: 2

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shu-zu-zhong-chu-xian-ci-shu-chao-guo-yi-ban-de-shu-zi-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

摩尔投票法，不同的相互抵消，相同的增加个数，很好理解，最后剩下的肯定是众数

class Solution {
    public int majorityElement(int[] nums) {
        //这道题，一眼望过去可以计数，排序什么的，或者是双指针，相同的和不同的相互抵消
        //我印象里好像有个什么博弈的方法，对，只要是不同的就相互抵消，最后剩下的就是最多的
        int num = nums[0];
        int count = 1;
        for(int i = 1; i < nums.length; i++){
            if(count == 0){
                num = nums[i];
                count++;
            }
            else if(nums[i] == num)
                count++;
            else if(nums[i] != num)
                count--;
        }
        return num;
    }
}

229. 求众数 II

题目描述

给定一个大小为 n 的整数数组，找出其中所有出现超过 ⌊ n/3 ⌋ 次的元素。

进阶：尝试设计时间复杂度为 O(n)、空间复杂度为 O(1)的算法解决此问题。

 

示例 1：

输入：[3,2,3]
输出：[3]
示例 2：

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

输入：[1,1,1,3,3,2,2,2]
输出：[1,2]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/majority-element-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

随着刚刚摩尔投票法，让我想起来了这个题，之前做摩尔投票的时候，换成这个题，我就不会做了，现在再来回味一下
刚刚求一个候选人的时候，可以把整个数组分成两部分，一部分是支持这个人的，一部分是支持其他人的，是一个人和其他人对抗；
而现在，要选两个人，可以把数组分成三个部分，支持a，支持b和支持其他人，支持其他人的部分我们称之为c，这样把a和c、b和c成组来看就相当于上一个题了
因此，现在先选定两个候选人，如果是支持a的，就给a一票；支持b的就给b一票，支持c的，就把a和b的票都抵消一张；如果计数为0了，就更换候选人
最后要验证选出的两个数是否都满足条件

根据这样的思路，就可以推广到选n个候选人
代码如下：

class Solution {
    public List<Integer> majorityElement(int[] nums) {
        //摩尔投票法（升级），我理解这个方法就是，选n个候选人，就需要有多于 1 / (n + 1)的票数，
        //所以将剩下的小于1/n的人和这几个候选人每个人的票数相加，就相当于每个候选人的票数大于这一部分的1/2，
        //所以就可以转换为169题，选大于1/2的那个题
        //所以先确定两个候选人，如果第三个投票结果和他们中任何一个相同，使其中那个人的票数加1；
        //如果第三个投票结果和他们任何一个都不同，那么就都抵消掉
        //如果某一个计数等于0，那就更换候选人
        //以这个过程遍历结束，剩余结果可能是符合要求的，也可能是不符合的
        //所以需要计数阶段，就是遍历一次nums，统计个数

        List<Integer> res = new ArrayList<>();
        int cand1 = nums[0], count1 = 0;
        int cand2 = nums[0], count2 = 0;
        //抵消阶段
        for(int n : nums){
            if(n == cand1){
                count1++;
                continue;
            }
            if(n == cand2){
                count2++;
                continue;
            }
            //当count1等于0的时候，换候选人
            if(count1 == 0){
                cand1 = n;
                count1++;
                continue;
            }
            if(count2 == 0){
                cand2 = n;
                count2++;
                continue;
            }
            //如果不相同,就减去
            count1--;
            count2--;
        }
        //计数阶段
        count1 = 0;
        count2 = 0;
        for(int n : nums){
            if(cand1 == n)
                count1++;
            //这里必须用else if，因为两个候选人可能相同
            else if(cand2 == n){
                count2++;
            }
        }
        if(count1 > nums.length / 3)
            res.add(cand1);
        if(count2 > nums.length / 3)
            res.add(cand2);
        return res;
    }
}