一、
1、题目描述
Description
定义超级和函数F如下:
F(0, n) = n,对于所有的正整数n..
F(k, n) = F(k – 1, 1) + F(k – 1, 2) + … + F(k – 1, n),对于所有的正整数k和n.
请实现下面Solution类中计算F(k, n)的函数(1 <= k, n <= 14).
class Solution {
public:
int F(int k, int n) {
}
};
例1:F(1, 3) = 6
例2:F(2, 3) = 10
例3:F(10, 10) = 167960
注意:你只需要提交Solution类的代码,你在本地可以编写main函数测试程序,但不需要提交main函数的代码. 注意不要修改类和函数的名称.
2、考点及思路
考查分治思想,将一个大问题划分为一个小问题,并通过递归的方式完成小问题。
3、代码实现
class Solution {
public:
int F(int k, int n) {
if(k==0) return n;
else{
int sum=0;
for(int i=1;i<=n;i++){
sum+=F(k-1,i);
}
return sum;
}
}
};
二、
1、题目描述
Description
N个会议要同时举行,参会人数分别为A[0], A[1], ..., A[N-1]. 现有M个会议室,会议室可容纳人数分别为B[0], B[1], ..., B[M-1]. 当A[i]<=B[j]时,可以把会议i安排在会议室j,每间会议室最多安排一个会议,每个会议最多只能安排一个会议室. 求最多安排多少个会议.
1 <= N, M <= 100000, 每个会议的参会人数和每间会议室的容纳人数均在1和1000之间.
请为下面的Solution类实现解决上述问题的函数assignConferenceRoom. 函数参数A和B的意义如上,返回值为最多可安排的会议数.
class Solution {
public:
int assignConferenceRoom(vector<int>& A, vector<int>& B) {
}
};
例1:A={2, 3}, B={1, 2},答案为1.
例2:A={3, 4, 5},B={10, 3, 2},答案为2.
注意:你只需要提交Solution类的代码,你在本地可以编写main函数测试程序,但不需要提交main函数的代码. 注意不要修改类和函数的名称.
2、考点及思路
考查贪心算法,将两个数组排序,并用最大会议室去满足最大需求,无法满足则看次之的需求。
3、代码实现
class Solution {
public:
int assignConferenceRoom(vector<int>& A, vector<int>& B) {
sort(A.begin(),A.end());
sort(B.begin(),B.end());
int a=A.size()-1;
int b=B.size()-1;
int count=0;
while(a>=0&&b>=0){
if(B[b]<A[a]){
a--;
}
else{
b--;
a--;
count++;
}
}
return count;
}
};
三、
1、题目描述
Description
两个二叉树结构相同,且对应结点的值相同,我们称这两个二叉树等价.
例如:以下两个二叉树等价
1 1
/ \ / \
2 3 2 3
而以下两个则不等价
1 1
/ \ / \
2 3 3 2
以下两个也不等价
1 1
/ \ / \
2 3 2 2
给出两个二叉树p和q,判断它们是否等价.
p和q的结点数不多于100000,每个结点的数值在1和1000000000之间.
请为下面的Solution类实现解决上述问题的isEqual函数,函数的两个参数p和q分别代表两个二叉树的根节点,如果以p和q为根的二叉树等价则函数返回true,否则返回false.
/**
Definition for a binary tree node.
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
*/
class Solution {
public:
bool isEqual(TreeNode* p, TreeNode* q) {
}
};
注意:你只需要提交Solution类的代码,你在本地可以编写main函数测试程序,但不需要提交main函数的代码,也不需要提交TreeNode的定义. 注意不要修改类和函数的名称.
2、考点及思路
考查DFS,通过DFS搜索两棵树,对比查看是否相同,我使用的是递归实现版本。
3、代码实现
class Solution {
public:
bool isEqual(TreeNode* p, TreeNode* q) {
if(p==NULL&&q==NULL)
return true;
if((p==NULL&&q!=NULL)||(q==NULL&&p!=NULL))
return false;
if(p->val!=q->val)
return false;
else
return (isEqual(p->left,q->left)&&isEqual(p->right,q->right));
}
};
四、
1、题目描述
Description
对于一个01矩阵A,求其中有多少片连成一片的1. 每个1可以和上下左右的1相连.
请为下面的Solution类实现解决这一问题的函数countConnectedOnes,函数参数A为给出的01矩阵,A的行数和列数均不大于1000. 函数的返回值是问题的答案.
class Solution {
public:
int countConnectedOnes(vector<vector<char>>& A) {
}
};
例1:
A=
100
010
001
答案为3.
例2:
A=
1101
0101
1110
答案为2.
注意:你只需要提交Solution类的代码,你在本地可以编写main函数测试程序,但不需要提交main函数的代码. 注意不要修改类和函数的名称.
2、考点及思路
考查BFS,通过BFS寻找一个点所连接的所有点,我使用queue记录同一层的节点。
3、代码实现
class Solution {
public:
int countConnectedOnes(vector<vector<char>>& A) {
int m = A.size();
if (m == 0) return 0;
int n = A[0].size();
if (n == 0) return 0;
vector<vector<bool>> B(m, vector<bool>(n, false));
int count = 0;
for (int i = 0; i<m; i++) {
for (int j = 0; j<n; j++) {
if (A[i][j] == '1'&&B[i][j] == false) {
count++;
BFS(A, B, i, j);
}
}
}
return count;
}
void BFS(vector<vector<char>>& A, vector<vector<bool>>& B, int i, int j) {
queue<pair<int, int>> que;
que.push(make_pair(i, j));
while (!que.empty()) {
pair<int, int> p = que.front();
que.pop();
if (p.first -1 >= 0 && A[p.first -1][p.second] == '1'&&B[p.first - 1][p.second] == false) {
que.push(make_pair(p.first - 1, p.second));
B[p.first - 1][p.second] = true;
}
if (p.first + 1 <A.size() && A[p.first + 1][p.second] == '1'&&B[p.first + 1][p.second] == false) {
que.push(make_pair(p.first + 1, p.second));
B[p.first + 1][p.second] = true;
}
if (p.second - 1 >= 0 && A[p.first][p.second-1] == '1'&&B[p.first][p.second-1] == false) {
que.push(make_pair(p.first, p.second-1));
B[p.first][p.second-1] = true;
}
if (p.second + 1 < A[0].size() && A[p.first][p.second + 1] == '1'&&B[p.first][p.second + 1] == false) {
que.push(make_pair(p.first, p.second + 1));
B[p.first][p.second + 1] = true;
}
}
}
};
五、
1、题目描述
Description
在图论中,如果一个有向图从任意顶点出发无法经过若干条边回到该点,则这个图是一个有向无环图(Directed Acyclic Graph,DAG). 对于一个n个节点的有向图(节点编号从0到n-1),请判断其是否为有向无环图.
图的节点数和边数均不多于100000.
请为下面的Solution类实现解决上述问题的isDAG函数,函数参数中n为图的节点数,edges是边集,edges[i]表示第i条边从edges[i].first指向edge[i].second. 如果是有向无环图返回true,否则返回false.
class Solution {
public:
bool isDAG(int n, vector<pair<int, int>>& edges) {
}
};
例1:
n = 3,edges = {(0, 1), (0, 2)},函数应返回true.
例2:
n = 2,edges = {(0, 1), (1, 0)},函数应返回false.
注意:你只需要提交Solution类的代码,你在本地可以编写main函数测试程序,但不需要提交main函数的代码. 注意不要修改类和函数的名称.
2、考点及思路
考查图论知识,我在检查是否有回边的过程中使用了dfs进行检索。
3、代码实现
class Solution {
public:
bool isDAG(int n, vector<pair<int, int>>& edges) {
vector<vector<int>> graph(n);
for (int i = 0; i < edges.size(); i++)
graph[edges[i].first].push_back(edges[i].second);
vector<bool> visited(n, false);
vector<bool> onpath(n,false);
for (int i = 0; i < n; i++)
if (has_circle(graph,i,visited,onpath))
return false;
return true;
}
bool has_circle(vector<vector<int>>& graph, int node, vector<bool>& visited, vector<bool>& onpath) {
if (visited[node]) return false;
onpath[node] = visited[node] = true;
for (int i = 0; i < graph[node].size(); i++) {
if (onpath[graph[node][i]] || has_circle(graph, graph[node][i], visited, onpath))
return true;
}
onpath[node] = false;
return false;
}
};
六、
1、题目描述
Description
从数列A[0], A[1], A[2], ..., A[N-1]中选若干个数,要求相邻的数不能都选,也就是说如果选了A[i], 就不能选A[i-1]和A[i+1]. 求能选出的最大和.
1 <= N <= 100000, 1 <= A[i] <= 1000
请为下面的Solution类实现解决上述问题的函数maxSum,函数参数A是给出的数列,返回值为所求的最大和.
class Solution {
public:
int maxSum(vector<int>& A) {
}
};
例1:A = {2, 5, 2},答案为5.
例2:A = {2, 5, 4},答案为6.
注意:你只需要提交Solution类的代码,你在本地可以编写main函数测试程序,但不需要提交main函数的代码. 注意不要修改类和函数的名称.
2、考点及思路
考查动态规划,定义函数并写出状态转移方程即可。
3、代码实现
class Solution {
public:
int maxSum(vector<int>& A) {
if (A.size() == 0) return 0;
vector<int> f(A.size());
f[0] = A[0];
f[1] = A[0] > A[1] ? A[0] : A[1];
for (int i = 2; i < A.size(); i++) {
f[i] = f[i - 1] > (f[i - 2] + A[i]) ? f[i - 1] : (f[i - 2] + A[i]);
}
return f[A.size() - 1];
}
};
七、
1、题目描述
Description
对于两个只含有小写英文字母(’a’-‘z’)的单词word1和word2,你可以对word1进行以下3种操作:
1) 插入一个字母;
2) 删除一个字母;
3) 替换一个字母.
请计算将word1变换成word2的最少操作数.
word1和word2的长度均不大于1000.
请为下面的Solution类实现解决上述问题的函数minDistance,函数的参数word1和word2为给出的两个单词,返回值为所求最少操作数.
class Solution {
public:
int minDistance(string word1, string word2) {
}
};
例1:word1 = “sunny”, word2 = “snowy”,返回值为3.
例2:word1 = “abc”, word2 = “ac”,返回值为1.
注意:你只需要提交Solution类的代码,你在本地可以编写main函数测试程序,但不需要提交main函数的代码. 注意不要修改类和函数的名称.
2、考点及思路
考查动态规划。需要注意dp[i][j]表示长度为i的word1与长度为j的word2的单词距离,dp的两个维度的长度分别为m+1,n+1,同时dp[i][j]对应的最后一个字符是字符串word1[i-1]和word2[j-1]。
3、代码实现
class Solution {
public:
int minDistance(string word1, string word2) {
int x= word1.length();
int y= word2.length();
vector<vector<int>> dp(x+1,vector<int>(y+1,0));
for(int i=0;i<=x;i++){
dp[i][0]=i;
}
for(int j=0;j<=y;j++){
dp[0][j]=j;
}
for(int i=1;i<=x;i++){
for(int j=1;j<=y;j++){
if(word1[i-1]==word2[j-1])
dp[i][j]=dp[i-1][j-1];
else{
dp[i][j]=min(dp[i-1][j-1],min(dp[i][j-1],dp[i-1][j]))+1;
}
}
}
return dp[x][y];
}
};