客观题逐题精讲

class Shape {
    public:
        virtual void draw() {
            cout << "绘制图形" << endl;
        }

        virtual ~Shape() {}
};

class Circle : public Shape {
    public:
        void draw() override {
            cout << "绘制圆形" << endl;
        }
    };

class Rectangle : public Shape {
    public:
        void draw() override {
            cout << "绘制矩形" << endl;
        }
    };

int main() {
    Shape* s1 = new Circle();
    Shape* s2 = new Rectangle();

    s1->draw();
    s2->draw();

    delete s1;
    delete s2;
    return 0;
}

class Pet {
    public:
        Pet(string n, int a) : name(n), age(a) {}
        string getName() { return name; }
        void birthday() { age++; }

    private:
        string name;
        int age;
    };

int main() {
    Pet cat("奶茶", 2);
    cout << cat.getName(); // ①
    cat.birthday(); // ②
    cat.name = "大橘"; // ③
    cout << cat.getName(); // ④
}

const int MAX = 5;
int queue[MAX];
int front = 0, rear = 0;

// 入队
void enqueue(int x) {
    queue[rear] = x;
    rear = (rear + 1) % MAX;
}

// 出队
void dequeue() {
    front = (front + 1) % MAX;
}

int main() {
    enqueue(1); enqueue(2); enqueue(3); enqueue(4);
    dequeue(); dequeue();
    enqueue(5); enqueue(6);
}

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};

vector<int> rightSideView(TreeNode* root) {
    unordered_map<int, int> rightmostValueAtDepth;
    int max_depth = -1;
    queue<TreeNode*> nodeQueue;
    queue<int> depthQueue;
    nodeQueue.push(root);
    depthQueue.push(0);

    while (!nodeQueue.empty()) {
        TreeNode* node = nodeQueue.front(); nodeQueue.pop();
        int depth = depthQueue.front(); depthQueue.pop();

        if (node != NULL) {
            max_depth = max(max_depth, depth);
            rightmostValueAtDepth[depth] = node->val;
            nodeQueue.push(node->left);
            nodeQueue.push(node->right);

            depthQueue.push(_);
            depthQueue.push(_);
        }
    }

    vector<int> rightView;
    for (int depth = 0; _____; ++depth) {
        rightView.push_back(rightmostValueAtDepth[depth]);
    }
    return rightView;
};

1 depth
2 depth
3 depth < max_depth

1 depth + 1
2 depth + 1
3 depth <= max_depth

1 depth + 1
2 depth + 1
3 depth < max_depth

1 depth
2 depth
3 depth <= max_depth

int visit(vector<int>& nums) {
    if (nums.empty()) {
        return 0;
    }
    int size = nums.size();
    if (size == 1) {
        return nums[0];
    }
    vector<int> dp = vector<int>(size, 0);
    dp[0] = nums[0];
    dp[1] = max(nums[0], nums[1]);
    for (int i = 2; i < size; i++) {
        dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]); // 在此处填写代码
    }
    return dp[size - 1];
}

dp[i] = dp[i - 1] + nums[i];

dp[i] = max(dp[i - 1], dp[i - 2] * nums[i]);

dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);

dp[i] = dp[i - 2] + nums[i];

class Point {
    public:
        double x, y;
        Point(double px, double py) : x(px), y(py) {}
        void print() {
            cout << "(" << x << ", " << y << ")";
        }
    };

int main() {
    Point a(3.0, 4.0); // ①
    Point b; // ②
    a.print();
}

struct Node {
    int val;
    Node *left, *right;
    Node(int v) : val(v), left(nullptr), right(nullptr) {}
};

void travel(Node* root) {
    if (!root) return;
    stack<Node*> s;
    s.push(root);

    while (!s.empty()) {
        Node* cur = s.top(); s.pop();
        cout << cur->val << "";

        if (cur->right) s.push(cur->right);
        if (cur->left) s.push(cur->left);
    }
}

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};

void preorder(TreeNode *root, vector<int> &res) {
    if (root == nullptr) {
        return;
    }
    res.push_back(root->val);
    preorder(root->left, res);
    preorder(root->right, res);
}

vector<int> preorderTraversal(TreeNode *root) {
    vector<int> res;
    preorder(root, res);
    return res;
};

int main() {
    int W = 5;
    int w[] = {2, 3, 4};
    int v[] = {10, 1, 1};
    int n = 3;
    int dp[6] = {0};

for (int i = 0; i < n; i++) {
        for (int j = W; j >= w[i]; j--) { // 逆序!
            dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
        }
    }
    cout << dp[W];
}