LeetCode1269. 停在原地的方案数 / 剑指 Offer 38. 字符串的排列 / 216. 组合总和 III / 剑指 Offer 39. 数组中出现次数超过一半的数字/229. 求众数(
Posted Zephyr丶J
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了LeetCode1269. 停在原地的方案数 / 剑指 Offer 38. 字符串的排列 / 216. 组合总和 III / 剑指 Offer 39. 数组中出现次数超过一半的数字/229. 求众数(相关的知识，希望对你有一定的参考价值。
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;
}
//如果不相同,就减去
count1leetcode-164周赛-1269-停在原地的方案数
LeetCode 1269. 停在原地的方案数 (Java 记忆化，动态规划)
LeetCode 1269. 停在原地的方案数 (Java 记忆化，动态规划)