- 课程表
你这个学期必须选修 numCourse 门课程，记为 0 到 numCourse-1 。
在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们：[0,1]
给定课程总量以及它们的先决条件，请你判断是否可能完成所有课程的学习？
本题可以采取DFS，如果找到了环路则证明不可以，否则可以
const int maxn=1000050;
class Solution {
public:
//DFS，模板题
vector<int>ans[maxn];//定义一个二维数组，也可以下面这种定义方法：
bool dfs(int x,vector<int>&vis){
vis[x]=0;//表示当前这个节点已近访问过了。
bool ret=true;
for(auto v:ans[x]){
if(vis[v]==0)return false;
if(vis[v]==-1)ret=ret&&dfs(v,vis);
}
vis[x]=-1;//表示以这个点出发的所有能够遍历的点已经遍历完了。。这个点出发不存在环啦。。。
return ret;
}
bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
vector<int> vis(numCourses,-1);//表示的是是否访问过,初始化-1，表示没有访问过
for(auto v:prerequisites){
ans[v[1]].push_back(v[0]);
}
bool ret=true;
for(int i=0;i<numCourses;i++){
if(vis[i]==-1){
ret=ret&&dfs(i,vis);
}
}
return ret;
}
};
- 实现Trie树
实现一个 Trie (前缀树)，包含 insert, search, 和 startsWith 这三个操作。
class Trie {
bool isEnd;
Trie* next[26];
public:
Trie() {
isEnd = false;
memset(next, 0, sizeof(next));
}
void insert(string word) {
Trie* node = this;
for (char c : word) {
if (node->next[c-'a'] == NULL) {
node->next[c-'a'] = new Trie();
}
node = node->next[c-'a'];
}
node->isEnd = true;
}
bool search(string word) {
Trie* node = this;
for (char c : word) {
node = node->next[c - 'a'];
if (node == NULL) {
return false;
}
}
return node->isEnd;
}
bool startsWith(string prefix) {
Trie* node = this;
for (char c : prefix) {
node = node->next[c-'a'];
if (node == NULL) {
return false;
}
}
return true;
}
};
- 长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的连续子数组，返回 0。
采用双指针滑动易解
class Solution {
public:
int minSubArrayLen(int s, vector<int>& nums)
{
int n = nums.size();
int ans = INT_MAX;
int left = 0;
int sum = 0;
for (int i = 0; i < n; i++)
{
sum += nums[i];
while (sum >= s)
{
ans = min(ans, i + 1 - left);
sum -= nums[left++];
}
}
return (ans != INT_MAX) ? ans : 0;
}
};
- 课程表2
现在你总共有 n 门课需要选，记为 0 到 n-1。
在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。
可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。
可以采取DFS或者BFS求解
class Solution {
private:
// 存储有向图
vector<vector<int>> edges;
// 标记每个节点的状态：0=未搜索，1=搜索中，2=已完成
vector<int> visited;
// 用数组来模拟栈，下标 0 为栈底，n-1 为栈顶
vector<int> result;
// 判断有向图中是否有环
bool invalid;
public:
void dfs(int u) {
// 将节点标记为「搜索中」
visited[u] = 1;
// 搜索其相邻节点
// 只要发现有环，立刻停止搜索
for (int v: edges[u]) {
// 如果「未搜索」那么搜索相邻节点
if (visited[v] == 0) {
dfs(v);
if (invalid) {
return;
}
}
// 如果「搜索中」说明找到了环
else if (visited[v] == 1) {
invalid = true;
return;
}
}
// 将节点标记为「已完成」
visited[u] = 2;
// 将节点入栈
result.push_back(u);
}
vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
edges.resize(numCourses);
visited.resize(numCourses);
for (const auto& info: prerequisites) {
edges[info[1]].push_back(info[0]);
}
// 每次挑选一个「未搜索」的节点，开始进行深度优先搜索
for (int i = 0; i < numCourses && !invalid; ++i) {
if (!visited[i]) {
dfs(i);
}
}
if (invalid) {
return {
};
}
// 如果没有环，那么就有拓扑排序
// 注意下标 0 为栈底，因此需要将数组反序输出
reverse(result.begin(), result.end());
return result;
}
};
class Solution {
private:
// 存储有向图
vector<vector<int>> edges;
// 存储每个节点的入度
vector<int> indeg;
// 存储答案
vector<int> result;
public:
vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
edges.resize(numCourses);
indeg.resize(numCourses);
for (const auto& info: prerequisites) {
edges[info[1]].push_back(info[0]);
++indeg[info[0]];
}
queue<int> q;
// 将所有入度为 0 的节点放入队列中
for (int i = 0; i < numCourses; ++i) {
if (indeg[i] == 0) {
q.push(i);
}
}
while (!q.empty()) {
// 从队首取出一个节点
int u = q.front();
q.pop();
// 放入答案中
result.push_back(u);
for (int v: edges[u]) {
--indeg[v];
// 如果相邻节点 v 的入度为 0，就可以选 v 对应的课程了
if (indeg[v] == 0) {
q.push(v);
}
}
}
if (result.size() != numCourses) {
return {
};
}
return result;
}
};
- 添加与搜索单词
本题采用Trie树+DFS搜索解决
class WordDictionary {
struct TrieNode
{
bool end;
unordered_map<char, TrieNode*> map;
TrieNode() : end(false) {
}
};
TrieNode* m_root;
public:
/** Initialize your data structure here. */
WordDictionary() {
m_root = new TrieNode;
}
/** Adds a word into the data structure. */
void addWord(string word) {
if (word.empty())
{
return;
}
TrieNode* cur = m_root;
for (int i = 0; i < word.size(); ++i)
{
auto iter = cur->map.find(word.at(i));
if (iter == cur->map.end())
{
cur->map[word.at(i)] = new TrieNode;
}
cur = cur->map[word.at(i)];
}
cur->end = true;
}
/** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
bool search(string word)
{
if (word.empty())
{
return false;
}
return __dfs(m_root, word, 0);
}
private:
bool __dfs(TrieNode* node, const string& word, int index)
{
if (index == word.size())
{
if (node->end)
{
return true;
}
return false;
}
if (word.at(index) == '.')
{
bool ret = false;
for (const auto& p : node->map)
{
ret |= __dfs(p.second, word, index + 1);
}
return ret;
}
else
{
auto iter = node->map.find(word.at(index));
if (iter != node->map.end())
{
return __dfs(iter->second, word, index + 1);
}
}
return false;
}
};
/**
* Your WordDictionary object will be instantiated and called as such:
* WordDictionary* obj = new WordDictionary();
* obj->addWord(word);
* bool param_2 = obj->search(word);
*/
- 单词搜索2
给定一个二维网格 board 和一个字典中的单词列表 words，找出所有同时在二维网格和字典中出现的单词。单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。
本题其实是基于上题的Trie树实现
class Trie
{
public:
bool isEnd;
Trie *nxt[26];
string word;
Trie()
{
isEnd = 0;
for (int i = 0; i < 26; i++)
{
nxt[i] = nullptr;
}
word = "";
}
void insert(string word)
{
Trie *node = this;
for (char each : word)
{
if (node->nxt[each - 'a'] == nullptr)
{
node->nxt[each - 'a'] = new Trie();
}
node = node->nxt[each - 'a'];
}
node->isEnd = 1;
node->word = word;
}
};
class Solution
{
public:
vector<string> ans;
void dfs(Trie *now, int x, int y, vector<vector<char>> &board)
{
if (now->isEnd)
{
now->isEnd = 0;
ans.push_back(now->word);
return;
}
if (x < 0 || x >= board.size() || y < 0 || y >= board[0].size())
return;
if (board[x][y] == '#')
return;
if (now->nxt[board[x][y] - 'a'] == nullptr)
return;
now = now->nxt[board[x][y] - 'a'];
char cur = board[x][y];
board[x][y] = '#';
dfs(now, x + 1, y, board);
dfs(now, x - 1, y, board);
dfs(now, x, y + 1, board);
dfs(now, x, y - 1, board);
board[x][y] = cur;
}
vector<string> findWords(vector<vector<char>> &board, vector<string> &words)
{
Trie *root = new Trie();
for (auto word : words)
{
root->insert(word);
}
for (int i = 0; i < board.size(); i++)
{
for (int j = 0; j < board[0].size(); j++)
{
dfs(root, i, j, board);
}
}
return ans;
}
};
- 打家劫舍2
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
相对于前题加一个区分即可
class Solution {
public:
int rob(vector<int>& nums) {
int len = nums.size();
if (len == 0)
return 0;
if (len == 1)
return nums[0];
int val1 = 0, val2 = 0;
vector<int> dp(len, 0);
dp[0] = nums[0];
dp[1] = max(dp[0], nums[1]);
for (int i = 2; i < len - 1; i++)
{
dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
}
val1 = dp[len - 2];
dp[0] = 0;
dp[1] = nums[1];
for (int i = 2; i < len; i++)
{
dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
}
val2 = dp[len - 1];
return max(val1, val2);
}
};