题目## 题目
题目的主要信息：
- 从0到n-1（首尾相接）中每次去掉第m个数，下一次从去掉数的下一个开始，直到剩下最后一个数
- 返回的是最后一个数
- 有数为0的特殊情况
举一反三：
学习完本题的思路你可以解决类似的模拟问题。
方法一：递归(推荐使用)
知识点：递归
递归是一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。因此递归过程，最重要的就是查看能不能讲原本的问题分解为更小的子问题，这是使用递归的关键。
思路：
n n n个数相后去掉第 m m m个数，还剩下 n − 1 n-1 n−1个数，依然要继续去掉第 m m m个数。由此，从 ( n , m ) (n,m) (n,m)的问题变成了 ( n − 1 , m ) (n-1,m) (n−1,m)的子问题，其中若是 ( n − 1 , m ) (n-1,m) (n−1,m)的子问题返回的最后一个数是 x x x，则 ( n , m ) (n,m) (n,m)返回的结果就是 ( m + x ) % n (m+x)\%n (m+x)%n，因此，用递归解决。
- 终止条件： 当 n = 1 n=1 n=1时就只剩下了最后一个孩子，应该返回0.
- 返回值： 子问题的结果加上 m m m再对 n n n取模，就是上一级删除的元素。
- 本级任务： 递归进入子问题获取子问题删除的元素，再推算自己这一级删除的元素。
具体做法：
- step 1：首先判断没有小朋友的特殊情况。
- step 2：然后递归计算子问题，并将子问题的结果 x x x运算 ( m + x ) % n (m+x)\%n (m+x)%n得到父问题的结果。
图示：
Java实现代码：
public class Solution {
private int function(int n, int m) {
if (n == 1)
return 0;
//递归
int x = function(n - 1, m);
//返回最后删除的那个元素
return (m + x) % n;
}
public int LastRemaining_Solution(int n, int m) {
//没有小朋友的情况
if(n == 0 || m == 0)
return -1;
return function(n, m);
}
}
C++实现代码：
class Solution {
public:
int function(int n, int m) {
if (n == 1)
return 0;
//递归
int x = function(n - 1, m);
//返回最后删除的那个元素
return (m + x) % n;
}
int LastRemaining_Solution(int n, int m) {
//没有小朋友的情况
if(n == 0 || m == 0)
return -1;
return function(n, m);
}
};
Python实现代码：
import sys
sys.setrecursionlimit(100000)
class Solution:
def function(self, n: int, m: int) -> int:
if n == 1:
return 0
#递归
x = self.function(n - 1, m)
#返回最后删除的那个元素
return (m + x) % n
def LastRemaining_Solution(self , n: int, m: int) -> int:
#没有小朋友的情况
if n == 0 or m == 0:
return -1
return self.function(n, m)
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，每个元素访问一次
- 空间复杂度： O ( n ) O(n) O(n)，递归栈最大深度
方法二：迭代(扩展思路)
思路：
方法一的递归也我们可以用迭代来代替，递归是自顶向下找子问题，根据子问题再自顶向上返回给父问题，来推算父问题的结果。我们可以直接从小的子问题，往上推，还是根据公式 ( m + x ) % n (m+x)\%n (m+x)%n，只是这里的 n n n变成了每一级子问题的长度。
for (int i = 2; i <= n; i++)
x = (m + x) % i;
具体做法：
- step 1：首先判断没有小朋友的特殊情况。
- step 2：假设最后剩余1个的时候，结果肯定为0.
- step 3：从最后剩余1个小朋友推断2个，再不断根据公式推断到 n n n个。
Java实现代码：
public class Solution {
public int LastRemaining_Solution(int n, int m) {
//没有小朋友的情况
if(n == 0 || m == 0)
return -1;
int x = 0;
//从小到大，更新x
for(int i = 2; i <= n; i++)
x = (m + x) % i;
return x;
}
}
C++实现代码：
class Solution {
public:
int LastRemaining_Solution(int n, int m) {
//没有小朋友的情况
if(n == 0 || m == 0)
return -1;
int x = 0;
//从小到大，更新x
for(int i = 2; i <= n; i++)
x = (m + x) % i;
return x;
}
};
Python实现代码：
class Solution:
def LastRemaining_Solution(self , n: int, m: int) -> int:
#没有小朋友的情况
if n == 0 or m == 0:
return -1
x = 0
#从小到大，更新x
for i in range(2, n + 1):
x = (m + x) % i
return x
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，一次遍历
- 空间复杂度： O ( 1 ) O(1) O(1)，常数个变量，无额外辅助空间
题目的主要信息：
- 实现一个函数用来找出字符流中第一个只出现一次的字符
- Insert函数插入字符流的下一个字符， FirstAppearingOnce找到第一个不重复出现的字符
- 如果找不到返回#
- 字符串中出现的字符一定在 ASCII 码内
举一反三：
学习完本题的思路你可以解决如下题目：
方法一：哈希表+字符串（推荐使用）
知识点：哈希表
哈希表是一种根据关键码（key）直接访问值（value）的一种数据结构。而这种直接访问意味着只要知道key就能在 O ( 1 ) O(1) O(1)时间内得到value，因此哈希表常用来统计频率、快速检验某个元素是否出现过等。
思路：
又是一个找到是否重复的问题。我们还是可以用哈希表来记录各个字符出现的次数，根据这样只要是字符串最前面且哈希表中次数为1的字符就是我们要找的。
具体做法：
- step 1：准备一个字符串来记录输入的字符流，用哈希表统计每个字符的次数，二者都是全局变量。
- step 2：在Insert函数中对输入的字符，加到字符串最后，然后统计出现次数。
- step 3：在FirstAppearingOnce函数遍历该字符串，对于每个字符查找哈希表，返回第一个计数为1的字符，如果遍历完字符串以后都没，则返回#。
Java实现代码：
import java.util.*;
public class Solution {
private StringBuilder s = new StringBuilder();
private HashMap<Character, Integer> mp = new HashMap<>();
//Insert one char from stringstream
public void Insert(char ch)
{
//插入字符
s.append(ch);
//哈希表记录字符出现次数
mp.put(ch, mp.getOrDefault(ch, 0) + 1);
}
//return the first appearence once char in current stringstream
public char FirstAppearingOnce()
{
//遍历字符串
for(int i = 0; i < s.length(); i++)
//找到第一个出现次数为1的
if(mp.get(s.charAt(i)) == 1)
return s.charAt(i);
//没有找到
return '#';
}
}
C++实现代码：
class Solution
{
public:
unordered_map<char, int> mp;
//记录输入的字符串
string s;
//Insert one char from stringstream
void Insert(char ch) {
//插入字符
s += ch;
//哈希表记录字符出现次数
mp[ch]++;
}
//return the first appearence once char in current stringstream
char FirstAppearingOnce() {
//遍历字符串
for(int i = 0; i < s.length(); i++)
//找到第一个出现次数为1的
if(mp[s[i]] == 1)
return s[i];
//没有找到
return '#';
}
};
Python实现代码：
class Solution:
def __init__(self):
self.s = ""
self.mp = dict()
def FirstAppearingOnce(self):
#遍历字符串
for c in self.s:
#找到第一个出现次数为1的
if self.mp[c] == 1:
return c
#没有找到
return '#'
def Insert(self, char):
#插入字符
self.s += char
#哈希表记录字符出现次数
if char in self.mp:
self.mp[char] += 1
else:
self.mp[char] = 1
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，每次插入字符都是 O ( 1 ) O(1) O(1)，每次查询需要遍历字符串 O ( n ) O(n) O(n)
- 空间复杂度： O ( n ) O(n) O(n)，字符一定在ASCII范围内，因此哈希表大小为常数，但是记录的字符串长度为还是为 n n n
方法二：哈希表+队列（扩展思路）
知识点：队列
队列是一种仅支持在表尾进行插入操作、在表头进行删除操作的线性表，插入端称为队尾，删除端称为队首，因整体类似排队的队伍而得名。它满足先进先出的性质，元素入队即将新元素加在队列的尾，元素出队即将队首元素取出，它后一个作为新的队首。
思路：
除了使用字符串记录字符流，还可以用队列记录字符流，每次插入的时候，只需要将第一次出现的字符加入到队列中，然后正常计数。
查找第一个不重复出现的字符的时候，从队首开始查询哈希表，如果出现次数为1，则返回该字符，如果不为1，则从队首将其弹出，因为反正后续也不可能是这个已经重复的字符了。
具体做法：
- step 1：准备一个队列来记录输入的字符流，用哈希表统计每个字符的次数，二者都是全局变量。
- step 2：在Insert函数中对输入的字符，加到队列最后，然后统计出现次数。
- step 3：在FirstAppearingOnce函数中，不断检查队首元素直到队列为空，队首出现次数为1次，就返回，队首出现次数不为1就弹出。
图示：
Java实现代码：
import java.util.*;
public class Solution {
private Queue<Character> q = new LinkedList<>();
private HashMap<Character, Integer> mp = new HashMap<>();
//Insert one char from stringstream
public void Insert(char ch)
{
//插入字符
if(!mp.containsKey(ch))
q.offer(ch);
//哈希表记录字符出现次数
mp.put(ch, mp.getOrDefault(ch, 0) + 1);
}
//return the first appearence once char in current stringstream
public char FirstAppearingOnce()
{
while(!q.isEmpty()){
//第一个不重复的字符
if(mp.get(q.peek()) == 1)
return q.peek();
//弹出前面的已经重复的字符
else
q.poll();
}
//都重复了
return '#';
}
}
C++实现代码：
class Solution
{
public:
unordered_map<char, int> mp;
queue<char> q;
//Insert one char from stringstream
void Insert(char ch) {
//第一次出现加入队列中
if(mp.find(ch) == mp.end())
q.push(ch);
//哈希表记录字符出现次数
mp[ch]++;
}
//return the first appearence once char in current stringstream
char FirstAppearingOnce() {
while(!q.empty()){
//第一个不重复的字符
if(mp[q.front()] == 1)
return q.front();
//弹出前面的已经重复的字符
else
q.pop();
}
//都重复了
return '#';
}
};
Python实现代码：
class Solution:
def __init__(self):
self.q = []
self.mp = dict()
def FirstAppearingOnce(self):
while len(self.q) != 0:
#第一个不重复的字符
if self.mp[self.q[0]] == 1:
return self.q[0]
#弹出前面的已经重复的字符
else:
self.q.pop(0)
#都重复了
return '#'
def Insert(self, char):
#哈希表记录字符出现次数
if char in self.mp:
self.mp[char] += 1
else:
self.mp[char] = 1
#插入字符
self.q.append(char)
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，每次插入字符都是 O ( 1 ) O(1) O(1)，每次查询平均复杂度比方法一下降了，但是最坏需要遍历队列 O ( n ) O(n) O(n)
- 空间复杂度： O ( 1 ) O(1) O(1)，字符一定在ASCⅡ范围内，因此哈希表大小为常数，同时记录字符的队列也是常数
扫一扫
2849
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
