算法机考模拟题

最新推荐文章于 2022-08-13 18:31:18 发布

森宝宝

最新推荐文章于 2022-08-13 18:31:18 发布

阅读量1.2k

点赞数

文章标签： graph DFS BFS dp greedy

本文链接：https://blog.csdn.net/qiaosen20/article/details/73468168

版权

一、

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：

100

010

001

答案为3.

例2：

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];
    }
};

森宝宝

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
5
评论
算法机考模拟题

一、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 class Solution {public:
复制链接

扫一扫